Add files using upload-large-folder tool

parse/dev/3SLW-YIw7tX/3SLW-YIw7tX.md

@@ -0,0 +1,323 @@
+# Reinforcement Learning with Neural Radiance Fields
+
+Danny Driess∗ Ingmar Schubert∗ TU Berlin TU Berlin
+
+Pete Florence Google
+
+Yunzhu Li MIT
+
+Marc Toussaint TU Berlin
+
+# Abstract
+
+It is a long-standing problem to find effective representations for training reinforcement learning (RL) agents. This paper demonstrates that learning state representations with supervision from Neural Radiance Fields (NeRFs) can improve the performance of RL compared to other learned representations or even low-dimensional, hand-engineered state information. Specifically, we propose to train an encoder that maps multiple image observations to a latent space describing the objects in the scene. The decoder built from a latent-conditioned NeRF serves as the supervision signal to learn the latent space. An RL algorithm then operates on the learned latent space as its state representation. We call this NeRF-RL. Our experiments indicate that NeRF as supervision leads to a latent space better suited for the downstream RL tasks involving robotic object manipulations like hanging mugs on hooks, pushing objects, or opening doors.
+
+Video: https://dannydriess.github.io/nerf-rl
+
+# 1 Introduction
+
+The sample efficiency of reinforcement learning (RL) algorithms crucially depends on the representation of the underlying system state they operate on [1, 2, 3, 4, 5, 6, 7]. Sometimes, a low-dimensional (direct) representation of the state, such as the positions of the objects in the environment, is considered to make the resulting RL problem most efficient [2].
+
+However, such low-dimensional, direct state representations can have several disadvantages. On the one hand, a perception module, e.g., pose estimation, is necessary in the real world to obtain the representation from raw observations, which often is difficult to achieve in practice with sufficient robustness. On the other hand, if the goal is to learn policies that generalize over different object shapes [8], using a low-dimensional state representation is often impractical. Such scenarios, while challenging for RL, are common, e.g., in robotic manipulation tasks.
+
+Therefore, there is a large history of approaches that consider RL directly from raw, high-dimensional observations like images (e.g., [9, 10]). Typically, an encoder takes the high-dimensional input and maps it to a low-dimensional latent representation of the state. The RL algorithm (e.g., the Q-function or the policy network) then operates on the latent vector as state input. This way, no separate perception module is necessary, the framework can extract information from the raw observations that are relevant for the task, and the RL agent, in principle, may generalize over challenging environments, in which, e.g., object shapes are varied. While these are advantages in principle, jointly training encoders capable of processing high-dimensional inputs from the RL signal alone is challenging. To address this, one approach is to pretrain the encoder on a different task, e.g., image reconstruction [1, 4, 11], multi-view consistency [6], or a time-constrastive task [3]. Alternatively, an auxiliary loss on the latent encoding can be added during the RL procedure [5].
+
+In both cases, the choice of the actual (auto-)encoder architecture and associated (auxiliary) loss function has a significant influence on the usefulness of the resulting latent space for the downstream
+
+RL task. Especially for image data, convolutional neural networks (CNNs) are commonly used for the encoder [12]. However, 2D CNNs have a 2D (equivariance) bias, while for many RL tasks, the 3D structure of our world is essential. Architectures like Vision Transformers [13, 14] process images with no such direct 2D bias, but they often require large scale data, which might be challenging in RL applications. Additionally, although multiple uncalibrated 2D image inputs can be used with generic image encoders [15], they do not benefit from 3D inductive biases, which may help for example in resolving ambiguities in 2D images such as occlusions and object permanence.
+
+Recently, Neural Radiance Fields (NeRFs) [16] have shown great success in learning to represent scenes with a neural network that enables to render the scene from novel viewpoints, and have sparked broad interest in computer vision [17]. NeRFs exhibit a strong 3D inductive bias, leading to better scene reconstruction capabilities than methods composed of generic image encoders (e.g., [18]).
+
+In the present work, we investigate whether incorporating these 3D inductive biases of NeRFs into learning a state representation can benefit RL. Specifically, we propose to train an encoder that maps multiple RGB image views of the scene to a latent representation through an auto-encoder structure, where a (compositional) NeRF decoder provides the self-supervision signal using an image reconstruction loss for each view.
+
+In the experiments, we show for multiple environments that supervision from NeRF leads to a latent representation that makes the downstream RL procedure more sample efficient compared to supervision via a 2D CNN decoder, a contrastive loss on the latent space, or even hand-engineered, perfect low-level state information given as keypoints. Commonly, RL is trained on environments where the objects have the same shape. Our environments include hanging mugs on hooks, pushing objects on a table, and a door opening scenario. In all of these, the objects’ shapes are not fixed, and we require the agent to generalize over all shapes from a distribution.
+
+To summarize our main contributions: (i) we propose to train state representations for RL with NeRF supervision, and (ii) we empirically demonstrate that an encoder trained with a latent-conditioned NeRF decoder, especially with an object-compositional NeRF decoder, leads to increased RL performance relative to standard 2D CNN auto-encoders, contrastive learning, or expert keypoints.
+
+# 2 Related Work
+
+Neural Scene/Object Representations in Computer Vision, and Applications. To our knowledge, the present work is the first to explore if neural scene representations like NeRFs can benefit RL. Outside of RL, however, there has been a very active research field in the area of neural scene representations, both in the representations themselves [19, 20, 21, 22] and their applications; see [23, 24, 17] for recent reviews. Within the family of NeRFs and related methods, major thrusts of research have included: improving modeling formulations [25, 26], modeling larger scenes [26, 27], addressing (re-)lighting [28, 29, 30], and an especially active area of research has been in improving speed, both of training and of inference-time rendering [31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41]. In our case, we are not constrained by inference-time computation issues, since we do not need to render images, and only have to run our latent-space encoder (with a runtime of approx. 7 ms on an RTX3090). Additionally of particular relevance, various methods have developed latent-conditioned [42, 43, 44] or compositional/object-oriented approaches for NeRFs [45, 46, 47, 48, 49, 50, 51, 52, 53], although they, nor other NeRF-style methods to our knowledge, have been applied to RL. Neural scene representations have found application across many fields (i.e., augmented reality and medical imaging [54]) and both NeRFs [55, 56, 57, 58] and other neural scene approaches [59, 60, 61, 62] have started to be used for various problems in robotics, including pose estimation [55], trajectory planning [56], visual foresight [11, 53], grasping [59, 57], and rearrangement tasks [60, 61, 58].
+
+Learning State Representations for Reinforcement Learning. One of the key enabling factors for the success of deep RL is its ability to find effective representations of the environment from high-dimensional observation data [10, 63]. Extensive research has gone into investigating different ways to learn better state representations using various auxiliary objective functions. Contrastive learning is a common objective and has shown success in unsupervised representation learning in computer vision applications [64, 65]. Researchers built upon this success and have shown such learning objectives can lead to better performance and sample efficiency in deep RL [66, 67], where the contrasting signals could come from time alignment [68, 3], camera viewpoints [69], and different sensory modalities [70], with applications in real-world robotic tasks [6, 71]. Extensive efforts have investigated the role of representation learning in RL [72], provided a detailed analysis of the importance of different visual representation pretraining methods [73], and shown how we can improve training stability in the face of multiple auxiliary losses [74]. There is also a range of additional explorations on pretraining methods with novel objective functions (e.g., bisimulation metrics [75] and temporal cycle-consistency loss [76]) and less-explored data sources (e.g., in-thewild images [77] and action-free videos [78]). Please check the survey for more related work in this direction [79]. Our method is different in that we explicitly utilize a decoder that includes strong 3D inductive biases provided by NeRFs, which we empirically show improves RL for tasks that depend on the geometry of the objects.
+
+# 3 Background
+
+# 3.1 Reinforcement Learning
+
+This work considers decision problems that can be described as discrete-time Markov Decision Processes (MDPs) $M \ = \ \langle S , A , T , \gamma , R , P _ { 0 } \rangle$ . $s$ and $\mathcal { A }$ are the sets of all states and actions, respectively. The transition probability (density) from $s$ to $s ^ { \prime }$ using an action $a$ is $T ( s ^ { \prime } \mid s , a )$ . The agent receives a real-valued reward $R ( s , a , s ^ { \prime } )$ after each step. The discount factor $\gamma \in \ [ 0 , 1 )$ trades off immediate and future rewards. $P _ { 0 } : \mathcal { S }  \mathbb { R } _ { 0 } ^ { + }$ is the diswhere this w tribution of the start state. RL algorithms try to find the optimal policy $\begin{array} { r } { \pi ^ { * } = \mathrm { a r g m a x } _ { \pi } \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } \mathbb { E } _ { s _ { t + 1 } \sim T ( \cdot | s _ { t } , a _ { t } ) , a _ { t } \sim \pi ( \cdot | s _ { t } ) , s _ { 0 } \sim P _ { 0 } } \left[ R ( \bar { s _ { t } } , a _ { t } , \bar { s _ { t + 1 } } ) \right] . } \end{array}$ $\pi ^ { * } : \mathcal { S } \times \mathcal { A } \to \mathbb { R } _ { 0 } ^ { + }$ 0  Importantly, inand the shape of $\mathrm { R L }$ $s$ the objects in the scene. We require the RL agent to generalize over all of these shapes at test time. We can therefore think of the state as a tuple $\boldsymbol { s } = \left( s _ { p } , s _ { s } \right)$ , where $s _ { p }$ encodes positional information, and $s _ { s }$ encodes the shapes involved. We focus the experiments on sparse reward settings, meaning $R ( s , a , s ^ { \prime } ) = R _ { 0 } > 0$ for $\boldsymbol { s } ^ { \prime } \in \boldsymbol { S } _ { g }$ and $R ( s , a , s ^ { \prime } ) = { \bar { 0 } }$ for $s \in \mathcal { S } \backslash \mathcal { S } _ { g }$ , where the volume of $\mathcal { S } _ { g } \subset \bar { \mathcal { S } }$ is much smaller than the volume of $s$ . The state space $s$ usually is low-dimensional or a minimal description of the degrees of freedom of the system. In this work, we consider that the RL algorithm has only access to a (high-dimensional) observation $y \in \mathcal { V }$ of the scene (e.g., RGB images). In particular, this means that the policy has observations as input $a \sim \pi ( \cdot \mid y )$ . Since we assume that the underlying state $\boldsymbol { s } = \left( s _ { p } , s _ { s } \right)$ is fully observable from $y$ , we can treat $y$ like a state for an MDP.
+
+Reinforcement Learning with Learned Latent Scene Representations. The general idea of RL with learned latent scene representations is to learn an encoder $\Omega$ that maps an observation $y \in \mathcal { V }$ to a $k$ -dimensional latent vector $z = \Omega ( y ) \in \mathcal { Z } \subset \mathbb { R } ^ { k }$ of the scene. The actual RL components, e.g., the Q-function or policy, then operate on $z$ as its state description. For a policy $\pi$ , this means that the action $a \sim \pi ( \cdot \mid \bar { z } ) = \bar { \pi } ( \cdot \mid \Omega ( \bar { y } ) )$ is conditional on the latent vector $z$ instead of the observation $y$ directly. The dimension $k$ of the latent vector is typically (much) smaller than that of the observation space $\mathcal { V }$ , but larger than that of the state space $s$ .
+
+# 3.2 Neural Radiance Fields (NeRFs)
+
+The general idea of NeRF, originally proposed by [16], is to learn a function $f = ( \sigma , c )$ that predicts the emitted RGB color value $c ( x ) \in \bar { \mathbb { R } } ^ { 3 }$ and volume density $\sigma ( x ) \in \mathbb { R } _ { \geq 0 }$ at any 3D world coordinate $x \in \mathbb { R } ^ { 3 }$ . Based on $f$ , an image from an arbitrary view and camera parameters can be rendered by computing the color $C ( r ) \in \bar { \mathbb { R } } ^ { 3 }$ of each pixel along its corresponding camera ray $r ( \alpha ) = r ( 0 ) + \alpha \dot { d }$ through the volumetric rendering relation
+
+$$
+C ( r ) = \int _ { \alpha _ { n } } ^ { \alpha _ { f } } T _ { f } ( r , \alpha ) \sigma ( r ( \alpha ) ) c ( r ( \alpha ) ) \mathrm { d } \alpha \qquad \mathrm { w i t h } \qquad T _ { f } ( r , \alpha ) = \exp \left( - \int _ { \alpha _ { n } } ^ { \alpha } \sigma ( r ( u ) ) \mathrm { d } u \right) .
+$$
+
+Here, $r ( 0 ) \in \mathbb { R } ^ { 3 }$ is the camera origin, $d \in \mathbb { R } ^ { 3 }$ the pixel dependent direction of the ray and $\alpha _ { n } , \alpha _ { f } \in \mathbb { R }$ the near and far bounds within which objects are expected, respectively. The camera rays are determined from the camera matrix $K$ (intrinsics and extrinsics) describing the desired view.
+
+# 4 Learning State Representations for RL with NeRF Supervision
+
+This section describes our proposed framework, in which we use a latent state space for RL that is learned from NeRF supervision. For learning the latent space, we use an encoder-decoder where the decoder is a latent-conditioned NeRF, which may either be a global [42, 43, 44] or a compositional NeRF decoder [53]. To our knowledge, no prior work has used such NeRF-derived supervision for RL. In Sec. 4.1 we describe this proposition, Sec. 4.2 provides an overview of the encoder-decoder training, Sec. 4.3 and Sec. 4.4 introduce options for the NeRF decoder and encoder, respectively.
+
+![](images/0f6041cbf23c978c2232942230a9a8801040ddcd96efd4a643cd03910cb0e6b5.jpg)  
+Figure 1: State representation learning for RL with NeRFs. First, the encoder and NeRF decoder are trained with supervision from a multi-view reconstruction loss on an offline dataset. Then, the encoder’s weights are frozen, and the latent space is used as state input to train a policy with RL. ∗Masks of individual objects are only required for the compositional variant of our encoder.
+
+# 4.1 Using Latent-Conditioned NeRF for RL
+
+We propose the state representation $z$ on which an RL algorithm operates to be a latent vector produced by an encoder that maps images from multiple views to a latent $z$ , which is trained with a (compositional) latent-conditioned NeRF decoder. As will be verified in experiments, we hypothesize that this framework is beneficial for the downstream RL task, as it produces latent vectors that represent the actual 3D geometry of the objects in the scene, can handle multiple objects well, as well as fuse multiple views in a consistent way to deal with occlusions by providing shape completion, all of which is relevant to solve tasks where the geometry is important. There are two steps to our framework, as shown in Fig. 1. First, we train the encoder $^ +$ decoder from a dataset collected by random interactions with the environment, i.e., we do not yet need a trained policy. Second, we take the encoder trained in the first step, which we leave frozen, and use the latent space to train an RL policy. Note that we investigate two variants of the auto-encoder framework, a global one, where the whole scene is represented by one single latent vector, and a compositional one, where objects are represented by their own latent vector. For the latter, objects are identified by masks in the views.
+
+# 4.2 Overview: Auto-Encoder with Latent-Conditioned NeRF Decoder
+
+Assume that an observation $\boldsymbol { y } = \left( \boldsymbol { I } ^ { 1 : V } , \boldsymbol { K } ^ { 1 : V } , \boldsymbol { M } ^ { 1 : V } \right)$ of the scene consists of RGB images $I ^ { i } \in$ $\mathbb { R } ^ { 3 \times h \times w }$ , $i = 1 , \ldots , V$ taken from $V$ many camera views, their respective camera projection matrices $K ^ { i } \in \mathbb { R } ^ { 3 \times 4 }$ (including both intrinsics and extrinsics), and per-view image masks ${ \hat { M } } ^ { 1 : V }$ . For a global NeRF decoder, these are global non-background masks $\dot { M } _ { \mathrm { t o t } } ^ { i } \in \{ 0 , 1 \} ^ { \check { h } \times w }$ , and for a compositional NeRF decoder as in [53], these are sets of binary masks $M _ { j } ^ { i } \in \left\{ 0 , 1 \right\} ^ { h \times w }$ that identify the objects $j = 1 , \ldots , m$ in the scene in view $i$ . The global case is equivalent to $m = 1$ , $M _ { j = 1 } ^ { i } = M _ { \mathrm { t o t } } ^ { i }$ . The encoder $\Omega$ maps these posed image observations from the multiple views into a set of latent vectors $z _ { 1 : m }$ , where each $z _ { j }$ represents each object in the scene separately in the compositional case, or the single $z _ { 1 }$ all objects in the scene. This is achieved by querying $\Omega$ on the masks $M _ { j } ^ { 1 : V }$ , i.e.,
+
+$$
+z _ { j } = \Omega \left( { I } ^ { 1 : V } , { K } ^ { 1 : V } , { M } _ { j } ^ { 1 : V } \right) \in \mathbb { R } ^ { k }
+$$
+
+for object $j$ . The supervision signal to train the encoder is the image reconstruction loss
+
+$$
+\mathcal { L } ^ { i } = \left. I ^ { i } \circ M _ { \mathrm { t o t } } ^ { i } - D \left( \Omega \left( I ^ { 1 : V } , K ^ { 1 : V } , M _ { 1 : m } ^ { 1 : V } \right) , K ^ { i } \right) \right. _ { 2 } ^ { 2 }
+$$
+
+on the input view $i$ where the decoder $D$ renders an image $I = D ( z _ { 1 : m } , K )$ for arbitrary views specified by the camera matrix $K$ from the set of latent vectors $z _ { 1 : m }$ . Both the encoder and decoder
+
+are trained end-to-end at the same time. The target images for the decoder are the same in both the   
+global and compositional case: the global-maskedthe compositional case this can be computed with $\overline { { I ^ { i } \circ M _ { \mathrm { t o t } } ^ { i } } }$ is the element-wise product). In. By fusing the information from $M _ { \mathrm { t o t } } ^ { i } = \bigvee _ { j = 1 } ^ { m } \bar { M } _ { j } ^ { i }$   
+the scene from multiple views, this auto-encoder framework can learn latent vectors that represent   
+the 3D configurations (shape and pose) of the objects in the scene.
+
+# 4.3 Latent-Conditioned NeRF Decoder Details
+
+Global. The original NeRF formulation [16] learns a fully connected network $f$ that represents one single scene (Sec. 3.2). In order to create a decoder from NeRFs within an auto-encoder to learn a latent space, we condition the NeRF $f ( \cdot , z )$ on the latent vector $z \in \mathbb { R } ^ { k }$ [42, 43, 44]. While approaches such as [42, 43, 44] use the latent code to represent factors such as lighting or categorylevel generalization, in our case the latent code is intended to represent the scene variation, i.e., shape and configuration of objects, such that a downstream RL agent may use this as a state representation.
+
+Compositional. In the compositional case, the encoder produces a set of latent vectors $z _ { 1 : m }$ describing each object $j = 1 , \dots , m$ individually, this leads to $m$ many NeRFs $( \sigma _ { j } ( x ) , c _ { j } ( x ) ) = f _ { j } ( x ) \stackrel {  } { = }$ $f ( x , z _ { j } )$ , $j = 1 , \dots , m$ with their associated volume density $\sigma _ { j }$ and color value $c _ { j }$ . Note that while one could use different networks $f _ { j }$ with their own network weights for each object, we have a single network $f$ for all objects. This means that both the object’s pose as well as its shape and type are represented through the latent code $z _ { j }$ . In order to force those conditioned NeRFs to learn the 3D configuration of each object separately, we compose them into a global NeRF model with the composition formulas (proposed e.g., by [80, 81]): $\begin{array} { r } { \sigma ( x ) = \sum _ { j = 1 } ^ { m } \overline { { \sigma } } _ { j } ( x ) } \end{array}$ $\begin{array} { r } { c ( x ) = \frac { 1 } { \sigma ( x ) } \sum _ { j = 1 } ^ { m } \sigma _ { j } ( x ) c _ { j } ( x ) } \end{array}$ . As this composition happens in 3D space, the latent vectors will be learned such that they correctly represent the actual shape and pose of the objects in the scene with respect to the other objects, which we hypothesize may be useful for the downstream RL agent.
+
+# 4.4 Encoder Details
+
+The encoder $\Omega$ operates by fusing multiple views together to estimate the latent vector for the RL task. Since the scientific question of this work is to investigate whether a decoder built from NeRFs to train the encoder end-to-end is beneficial for RL, we consider two different encoder architectures. The first one is a 2D CNN that averages feature encodings from the different views, where each encoding is additionally conditioned on the camera matrix of that view. The second one is based on a learned 3D neural vector field that incorporates 3D biases by fusing the different camera views in 3D space through 3D convolutions and camera projection. This way, we are able to distinguish between the importance of 3D priors incorporated into the encoder versus the decoder.
+
+Per-image CNN Encoder (“Image encoder”). For the global version, we utilize the network architecture from [11] as an encoder choice. In order to work with multiple objects in the compositional case, we modify the architecture from [11] by taking the object masks into account as follows. For each object $j$ , the 2D CNN encoder computes
+
+$$
+z _ { j } = \Omega _ { \mathrm { C N N } } \left( I ^ { 1 : V } , K ^ { 1 : V } , M _ { j } ^ { 1 : V } \right) = h _ { \mathrm { M L P } } \left( \frac { 1 } { V } \sum _ { i = 1 } ^ { V } g _ { \mathrm { M L P } } \left( E _ { \mathrm { C N N } } \left( I ^ { i } \circ M _ { j } ^ { i } \right) , K ^ { i } \right) \right) .
+$$
+
+$E _ { \mathrm { C N N } }$ is a ResNet-18 [82] CNN feature extractor that determines a feature from the masked input image $I ^ { i } \circ M _ { j } ^ { i }$ of object $j$ for each view $i$ , which is then concatenated with the (flattened) camera matrix. The output of the network $g _ { \mathrm { M L P } }$ is hence the encoding of each view, including the camera information, which is averaged and then processed with $h _ { \mathrm { M L P } }$ , to produce the final latent vector. Note that in the global case, we set $m = 1$ , ${ M _ { j = 1 } ^ { i } = M _ { \mathrm { t o t } } ^ { i } }$ such that $\Omega _ { \mathrm { C N N } }$ produces a single latent vector.
+
+Neural Field 3D CNN Encoder (“Field encoder”). Several authors [43] have considered to incorporate 3D biases into learning an encoder by computing pixel-aligned features from queried 3D locations of the scene to fuse the information from the different camera views directly in 3D space. We utilize the encoder architecture from [53], where the idea is to learn a neural vector field $\mathring { \phi } \big [ I ^ { 1 : V } , M _ { j } ^ { 1 : V } \big ] : \mathbb { R } ^ { 3 }  \mathbb { R } ^ { E }$ over 3D space, conditioned on the input views and masks. The features of $\bar { \phi }$ are computed from projecting the query point into the camera coordinate system from the respective view. To turn $\phi$ into a latent vector, it is queried on a workspace set $\mathcal { X } _ { h } \ \backslash \ \backslash \ \mathbb { R } ^ { d _ { \mathcal { X } } \times h _ { \mathcal { X } } \times w _ { \mathcal { X } } }$ (a 3D grid) and then processed by a 3D convolutional network, i.e., $z _ { j } = E _ { \mathrm { 3 D C N N } } \left( \phi \left[ I ^ { 1 : V } , M _ { j } ^ { 1 : V } \right] ( \mathcal { X } _ { h } ) \right)$ This method differs from [43, 83, 60] by computing a latent vector from the pixel-aligned features.
+
+# 5 Baselines / Alternative State Representations
+
+In this section, we briefly describe alternative ways of training an encoder for RL, which we will investigate in the experiments as baselines and ablations. For details, refer to the appendix.
+
+Conv. Autoencoder. This baseline uses a standard CNN decoder based on deconvolutions instead of NeRF to reconstruct the image from the latent representation, similar to [1]. Therefore, with this baseline we investigate the influence of the NeRF decoder relative to CNN decoders. We follow the architecture of [11] for the deconvolution part for the global case. In the compositional case, single, global one. The image I = Ddeconv(gMLP( 1m Pmj=1 zj ), K) is rendered from z1:m by first averaging the latent vectors and then processing the averaged vector with a fully connected network $g _ { \mathrm { M L P } }$ , leading to an aggregated feature. This aggregated feature is concatenated with the (flattened) camera matrix $K$ describing the desired view and then rendered into the image with $D _ { \mathrm { d e c o n v } }$ . In the experiments, we utilize this decoder as the supervision signal to train the latent space produced by the 2D CNN encoder from Sec. 4.4. In the compositional version, the 2D CNN encoder (4) use the same object masks as the compositional NeRF-RL variant.
+
+Contrastive Learning. As an alternative to learning an encoder via a reconstruction loss, the idea of contrastive learning [84] is to define a loss function directly on the latent space that tries to pull latent vectors describing the same configurations together (called positive samples) while ones representing different system states apart (called negative samples). A popular approach to achieve this is with the InfoNCE loss [85, 64]. Let $y _ { i }$ and $\tilde { y } _ { i }$ be two different observations of the same state. Here, ˜· denotes a i i perturbed/augmented version of the observation. For a mini-batch of observations $\{ ( y _ { i } , \tilde { y } _ { i } ) \} _ { i = 1 } ^ { n }$ , after encoding those into their respective latent vectors $z _ { i } = \Omega ( y _ { i } )$ , $\tilde { z } _ { i } = \Omega ( \tilde { y } _ { i } )$ with the encoder $\Omega$ , the loss for that batch would use $( z _ { i } , \tilde { z } _ { i } )$ as a positive pair, and $( z _ { i } , \tilde { z } _ { \neq i } )$ as a negative pair, or some similar variation. A crucial question in contrastive learning is how the observation $y$ is perturbed/augmented into $\tilde { y }$ to generate positive and negative training pairs, described in the following.
+
+CURL. In CURL [5], the input image is randomly cropped to generate $y$ and $\tilde { y }$ . We closely follow the hyperparameters and design of [5]. CURL operates on a single input view and we choose a view for this baseline from which the state of the environment can be inferred as best as possible (Fig. 17).
+
+Multi-View CURL. This baseline investigates if the neural field 3D encoder (Sec. 4.4) can be trained with a contrastive loss. As this encoder operates on multiple input views we double the number of available camera views. Half of the views are the same as in the other experiments, the other half are captured from sightly perturbed camera angles. We use the same loss as CURL, but with different contrastive pairs – rather than from augmentation, the contrastive style is taken from TCN [68]: the positive pairs come from different views but at the same moment in time, while negative pairs come from different times. Therefore, this baseline can be seen as a multi-view adaptation of CURL [5].
+
+Direct State / Keypoint Representations. Finally, we also consider a direct, low-dimensional representation of the state. Since we are interested in generalizing over different object shapes, we consider multiple 3D keypoints that are attached at relevant locations of the objects by expert knowledge and observed with a perfect keypoint detector [8]. See Fig. 2b for a visualization of those keypoints. The keypoints both provide information about object shape and its pose. Furthermore, as seen in Fig. 2b, they have been chosen to reflect those locations in the environment relevant to solve the task. Additionally, we report results where the state is represented by the poses of the objects – as this cannot represent object shape, in this case we use a constant object shape for training and test.
+
+# 6 Experiments
+
+We evaluate our proposed method on different environments where the geometry of the objects in the scene is important to solve the task successfully. Please also refer to the video https://dannydriess.github.io/nerf-rl. Commonly, RL is trained and evaluated on a single environment, where only the poses are changed, but the involved object shapes are kept constant. Since latent-conditioned NeRFs have been shown to be capable of generalizing over geometry [43], we consider experiments where we require the RL agent to generalize over object shapes within some distribution. Answering the scientific question of this work requires environments with multi-view observations — and for the compositional versions object masks as well. These are not provided in standard RL benchmarks, which is the reason for choosing the environments investigated in this work. We use PPO [86] as the RL algorithm and four camera views in all experiments. Refer to the appendix for more details about our environments, parameter choices, network architectures, and training times.
+
+# 6.1 Environments
+
+Mug on Hook. In this environment, adopted from [87] and visualized in Fig. 2b, the task is to hang a mug on a hook. Both the mug and the hook shape are randomized. The actions are small 3D translations applied to the mug. This environment is challenging as we require the RL agent to generalize over mug and hook shapes and the tolerance between the handle opening and the hook is relatively small. Further, the agent receives a sparse reward only if the mug has been hung stably. This reward is calculated by virtually simulating a mug drop after each action. If the mug does not fall onto the ground from the current state, a reward of one is assigned, otherwise zero.
+
+Planar Pushing. The task in this environment, shown in Fig. 3b, is to push yellow box-shaped objects into the left region of the table and blue objects into the right region with the red pusher that can move in the plane, i.e., the action is two dimensional. This is the same environment as in [53] with the same four different camera views. Each run contains a single object on the table (plus the pusher). If the box has been pushed inside its respective region, a sparse reward of one is received, otherwise zero. The boxes in the environment have different sizes, two colors and are randomly initialized. In this environment, we cannot use keypoints for the multi-shape setting, as the reward depends on the object color; we evaluate the keypoints baseline only in the single shape case (Appendix).
+
+Door Opening. Fig. 4b shows the door environment, where the task is to open a sliding door with the red end-effector that can be translated in 3 DoFs as the action. To solve this task, the agent has to push on the door handle. As the handle position and size is randomized, the agent has to learn to interact with the handle geometry accordingly. Interestingly, as can be seen in the video in the supplementary material, the agent often chooses to push on the handle only at the beginning, as, afterwards, it is sufficient to push the door itself at its side. The agent receives a sparse reward if the door has been opened sufficiently, otherwise, zero reward is assigned.
+
+# 6.2 Results
+
+Figs 2a, 3a, 4a show success rates (averaged over 6 independent experiment repetitions and over 30 test rollouts per repetition per timestep) as a function of training steps. Also shown are the $6 8 \%$ confidence intervals. These success rates have been evaluated using randomized object shapes and initial conditions, and therefore reflect the agent’s ability to generalize over these.
+
+In all these experiments, a latent space trained with compositional NeRF supervision as the decoder consistently outperformed all other learned representations, both in terms of sample efficiency and asymptotic performance. Furthermore, our proposed framework with compositional NeRF even outperforms the expert keypoint representation. For the door environment, the 3D neural field encoder plus NeRF decoder (NeRF-RL comp. $^ +$ field) reaches nearly perfect success rates. For the other two environments, the compositional 2D CNN encoder plus NeRF decoder (NeRF-RL comp. $^ +$ image) was slightly better than with the neural field encoder but not significantly. This shows that the decoder built from compositional NeRF is relevant for the performance, not so much the choice of the encoder.
+
+Training the 3D neural field encoder with a contrastive loss as supervision signal for different camera views as positive/negative training pairs is not able to achieve significant learning progress in these scenarios (Multi-CURL). However, the other contrastive baseline, CURL, which has a different encoder and uses image cropping as data augmentation instead of additional camera views, is able to achieve decent performance and sample efficiency on the door environment, but not for the pushing environment. In the mug environment, CURL initially is able to make learning progress comparable to our framework, but never reaches a success rate above $59 \%$ and then becomes unstable. Similarly, the global CNN autoencoder baseline shows decent learning progress initially on the mug and pushing scenario (not for the door), but then becomes unstable (mug) or never surpasses $50 \%$ success rate
+
+<table><tr><td></td><td></td><td>encoder</td><td>decoder</td><td>comp.</td><td>NeRF</td><td>loss</td></tr><tr><td>NeRF- RL</td><td>comp.+field</td><td>3D CNN</td><td>comp.3D NeRF</td><td>·</td><td>√</td><td>image reconstr.: L2</td></tr><tr><td>(ours)</td><td>comp.+image global+image</td><td>2D CNN</td><td>comp.3D NeRF</td><td></td><td>！</td><td>image reconstr.: L2</td></tr><tr><td></td><td></td><td>2D CNN</td><td>global3DNeRF</td><td>X</td><td>√</td><td>image reconstr.: L2</td></tr><tr><td></td><td>Conv. Autoencoder, c</td><td>2D CNN</td><td>comp. 2D CNN</td><td></td><td>X</td><td>image reconstr.: L2</td></tr><tr><td></td><td>Conv. Autoencoder, g</td><td>2D CNN</td><td>2D CNN</td><td>&lt;xx&gt;</td><td>X</td><td>image reconstr.: L2</td></tr><tr><td></td><td>CURL</td><td>2D CNN</td><td>=</td><td></td><td>X</td><td>contrast: InfoNCE</td></tr><tr><td></td><td>Multi-CURL</td><td>3D CNN</td><td></td><td></td><td>X</td><td>contrast: InfoNCE</td></tr><tr><td>Keypoints</td><td></td><td colspan="5">chosen by expert knowledge and perfect extraction</td></tr></table>
+
+![](images/427fb0418253d91807f58566d0949d0a46f6d954a7b89526b437e24a8477e2e8.jpg)  
+Table 1: Overview of the different state representation learning frameworks.
+
+(a) Learning curve.
+
+![](images/0f7197ae1b39e7782caa288ae336ac227d4cde2f66f791616e524f5cfecde6e6.jpg)
+
+(b) Left: Blue coordinate frames denote the four camera poses. Red points are the expert keypoints. Right: NeRF renderings (different scenes).
+
+![](images/7e6d50f1d5dbad6e807c7343717f3c0c7d0d91e9510da19e6b6bad96efd12eef.jpg)  
+Figure 2: Mug on hook environment. (b) shows an example scene and NeRF renderings
+
+![](images/b139944183ef2475b94da0efb6892833cd0df8dd249757014b13d05cc40b0ca6.jpg)
+
+(b) Left: Blue coordinate frames denote the four camera poses. Yellow and blue areas are goal regions where the objects should be pushed to. Right: NeRF renderings.
+
+![](images/fa81140a6d4f2769491051398b47d5d1a71276ba377fb212d3704b8f2fbdaa06.jpg)  
+Figure 3: Pushing environment. (b) shows NeRF renderings for different scenes.   
+Figure 4: Door environment. (b) shows NeRF renderings for different scenes.
+
+(a) Learning curve.
+
+(pushing). Such variations in performance or instable learning across the different environments have not been observed with our method, which is stable in all cases.
+
+The compositional variant (NeRF-RL comp.) of our framework achieves the highest performance. Since the conv. comp. autoencoder baseline has worse performance than its global variant, compositionality alone is not the sole reason for the better performance of our state representation. Indeed, the global NeRF-RL $^ +$ image variant in the pushing env. is also better than all other baselines.
+
+In the appendix Sec. A.1, we find a positive correlation between NeRF reconstruction quality and RL performance. Furthermore, it turns out that the performance of our framework is not significantly affected when we pretrain the encoder with less data (Sec. A.2). In Sec. A.3, we investigate the influence of the number of input views on the RL performance. In the pushing scenario, only two or even one input view are sufficient for good performance. However, for tasks that require more 3D understanding such as the mug scenario, we observe a drop in performance when reducing the number of views from 4 to 2.
+
+# 7 Discussion
+
+Why NeRF provides better supervision. The NeRF training objective (1) strongly forces each $f ( \cdot , z _ { j } )$ to represent each object in its actual 3D configuration and relative to other objects in the scene (compositional case), including their shape. This implies that the latent vectors $z _ { j }$ have to contain this information, i.e., they are trained to determine the object type, shape and pose in the scene. In the global case, $z _ { 1 }$ has to represent the geometry of the whole secne. As the tasks we consider require policies to take the geometry of the objects into account, we hypothesize that a latent vector that is capable of parameterizing a NeRF to reconstruct the scene in the 3D space has to contain enough of the relevant 3D information of the objects also for the policy to be successful.
+
+Masks. In order for the auto-encoder framework to be compositional, it requires object masks. We believe that instance segmentation has reached a level of maturity [88] that this is a fair assumption to make. As we also utilize the individual masks for the compositional conv. autoencoder and the multi-view CURL baseline, which do not show good performance, it indicates that the masks are not the main reason that our state representation achieves higher performance. This is further supported by the fact that the global NeRF-RL variant which does not rely on individual object masks on the pushing scenario achieved a performance higher than all baselines, i.e., masks will increase the performance of NeRF-RL as they enable the compositional version, but they do not seem essential.
+
+Offline/Online. In this work, we focused on pretraining the latent representation offline from a dataset collected by random actions. During RL, the encoder is fixed and only the policy networks are learned. This has the advantage that the same representation can be used for different RL tasks and the dataset to train the representation not necessarily has to come from the same distribution. However, if a policy is needed to explore reasonable regions of the state space, collecting a dataset offline to learn a latent space that covers the state space sufficiently might be more challenging for an offline approach. This was not an issue for our experiments where data collection with random actions was sufficient. Indeed, we show generalization over different starting states of the same environment and with respect to different shapes (within distribution). Future work could investigate NeRF supervision in an online setup. Note that the reconstruction loss via NeRF is computationally more demanding than via a 2D CNN deconv. decoder or a contrastive term, making NeRF supervision as an auxiliary loss at each RL training step costly. One potential solution for this is to apply the auxiliary loss not at every RL training step, but with a lower frequency. Regarding computational efficiency, this is where contrastive learning has an advantage over our proposed NeRF-based decoder, as the encoding with CURL can be trained within half a day, whereas the NeRF auto-encoder took up to 2 days to train for our environments. However, when using the encoder for RL, there is no difference in inference time.
+
+Multi-View. The auto-encoder framework we propose can fuse the information of multiple camera views into a latent vector describing an object in the scene. This way, occlusions can be addressed and the agent can gain a better 3D understanding of the scene from the different camera angles. Having access to multiple camera views and their camera matrices is an additional assumption we make, although we believe the capability to utilize this information is an advantage of our method.
+
+# 8 Conclusion
+
+In this work, we have proposed the idea to utilize Neural Radiance Fields (NeRFs) to train latent spaces for RL. Our environments focus on tasks where the geometry of the objects in the scene is relevant for successfully solving the tasks. Training RL agents with the pretrained encoder that maps multiple views of the scene to a latent space consistently outperformed other ways of learning a state representation and even keypoints chosen by expert knowledge. Our results show that the 3D prior present in compositional NeRF as the decoder is more important than priors in the encoder.
+
+Broader Impacts. Our main contribution is a method to learn representations that improve the efficiency of vision-based RL, which could impact automation. As such, our work inherits general ethical risks of AI, like the question of how to address the potential of increased automation in society.
+
+# Acknowledgments
+
+The authors thank Russ Tedrake for initial discussions; Jonathan Tompson and Jon Barron for feedback on drafts; Vincent Vanhoucke for encouraging latent NeRFs.
+
+This research has been supported by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) under Germany’s Excellence Strategy – EXC 2002/1 “Science of Intelligence” – project number 390523135. Danny Driess thanks the International Max-Planck Research School for Intelligent Systems (IMPRS-IS) for the support. Ingmar Schubert acknowledges support by the German Academic Scholarship Foundation. Yunzhu Li acknowledges support by Amazon.com Services LLC, PO# #2D-06310236 and the Wistron Corporation.
+
+# References
+
+[1] C. Finn, X. Y. Tan, Y. Duan, T. Darrell, S. Levine, and P. Abbeel. Deep spatial autoencoders for visuomotor learning. In 2016 IEEE International Conference on Robotics and Automation (ICRA), pages 512–519. IEEE, 2016.   
+[2] R. Jonschkowski, R. Hafner, J. Scholz, and M. Riedmiller. Pves: Position-velocity encoders for unsupervised learning of structured state representations. arXiv preprint arXiv:1705.09805, 2017.   
+[3] D. Dwibedi, J. Tompson, C. Lynch, and P. Sermanet. Learning actionable representations from visual observations. In 2018 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 1577–1584. IEEE, 2018.   
+[4] T. D. Kulkarni, A. Gupta, C. Ionescu, S. Borgeaud, M. Reynolds, A. Zisserman, and V. Mnih. Unsupervised learning of object keypoints for perception and control. Advances in neural information processing systems, 32, 2019.   
+[5] M. Laskin, A. Srinivas, and P. Abbeel. Curl: Contrastive unsupervised representations for reinforcement learning. In International Conference on Machine Learning, pages 5639–5650. PMLR, 2020.   
+[6] L. Manuelli, Y. Li, P. Florence, and R. Tedrake. Keypoints into the future: Self-supervised correspondence in model-based reinforcement learning. arXiv preprint arXiv:2009.05085, 2020.   
+[7] M. Vecerik, J.-B. Regli, O. Sushkov, D. Barker, R. Pevceviciute, T. Rothörl, C. Schuster, R. Hadsell, L. Agapito, and J. Scholz. S3k: Self-supervised semantic keypoints for robotic manipulation via multi-view consistency. arXiv preprint arXiv:2009.14711, 2020.   
+[8] L. Manuelli, W. Gao, P. Florence, and R. Tedrake. kpam: Keypoint affordances for categorylevel robotic manipulation. arXiv preprint arXiv:1903.06684, 2019.   
+[9] V. Mnih, K. Kavukcuoglu, D. Silver, A. Graves, I. Antonoglou, D. Wierstra, and M. Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013.   
+[10] V. Mnih, K. Kavukcuoglu, D. Silver, A. A. Rusu, J. Veness, M. G. Bellemare, A. Graves, M. Riedmiller, A. K. Fidjeland, G. Ostrovski, et al. Human-level control through deep reinforcement learning. nature, 518(7540):529–533, 2015.   
+[11] Y. Li, S. Li, V. Sitzmann, P. Agrawal, and A. Torralba. 3d neural scene representations for visuomotor control. In Conference on Robot Learning, pages 112–123. PMLR, 2022.   
+[12] S. Lange and M. Riedmiller. Deep auto-encoder neural networks in reinforcement learning. In The 2010 International Joint Conference on Neural Networks (IJCNN), 2010.   
+[13] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin. Attention is all you need. Advances in neural information processing systems, 30, 2017.   
+[14] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.   
+[15] I. Akinola, J. Varley, and D. Kalashnikov. Learning precise 3d manipulation from multiple uncalibrated cameras. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 4616–4622. IEEE, 2020.   
+[16] B. Mildenhall, P. P. Srinivasan, M. Tancik, J. T. Barron, R. Ramamoorthi, and R. Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. In European conference on computer vision, pages 405–421. Springer, 2020.   
+[17] F. Dellaert and L. Yen-Chen. Neural volume rendering: Nerf and beyond, 2021.   
+[18] S. A. Eslami, D. Jimenez Rezende, F. Besse, F. Viola, A. S. Morcos, M. Garnelo, A. Ruderman, A. A. Rusu, I. Danihelka, K. Gregor, et al. Neural scene representation and rendering. Science, 360(6394):1204–1210, 2018.   
+[19] J. J. Park, P. Florence, J. Straub, R. Newcombe, and S. Lovegrove. Deepsdf: Learning continuous signed distance functions for shape representation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 165–174, 2019.   
+[20] L. Mescheder, M. Oechsle, M. Niemeyer, S. Nowozin, and A. Geiger. Occupancy networks: Learning 3d reconstruction in function space. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4460–4470, 2019.   
+[21] Z. Chen and H. Zhang. Learning implicit fields for generative shape modeling. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 5939–5948, 2019.   
+[22] V. Sitzmann, M. Zollhöfer, and G. Wetzstein. Scene representation networks: Continuous 3d-structure-aware neural scene representations. Advances in Neural Information Processing Systems, 32, 2019.   
+[23] Y. Xie, T. Takikawa, S. Saito, O. Litany, S. Yan, N. Khan, F. Tombari, J. Tompkin, V. Sitzmann, and S. Sridhar. Neural fields in visual computing and beyond. arXiv preprint arXiv:2111.11426, 2021.   
+[24] A. Tewari, J. Thies, B. Mildenhall, P. Srinivasan, E. Tretschk, Y. Wang, C. Lassner, V. Sitzmann, R. Martin-Brualla, S. Lombardi, et al. Advances in neural rendering. arXiv preprint arXiv:2111.05849, 2021.   
+[25] J. T. Barron, B. Mildenhall, M. Tancik, P. Hedman, R. Martin-Brualla, and P. P. Srinivasan. Mip-nerf: A multiscale representation for anti-aliasing neural radiance fields. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 5855–5864, 2021.   
+[26] J. T. Barron, B. Mildenhall, D. Verbin, P. P. Srinivasan, and P. Hedman. Mip-nerf 360: Unbounded anti-aliased neural radiance fields. arXiv preprint arXiv:2111.12077, 2021.   
+[27] M. Tancik, V. Casser, X. Yan, S. Pradhan, B. Mildenhall, P. P. Srinivasan, J. T. Barron, and H. Kretzschmar. Block-nerf: Scalable large scene neural view synthesis. arXiv preprint arXiv:2202.05263, 2022.   
+[28] M. Boss, R. Braun, V. Jampani, J. T. Barron, C. Liu, and H. Lensch. NeRD: Neural reflectance decomposition from image collections. https://arxiv.org/abs/2012.03918, 2020.   
+[29] P. Srinivasan, B. Deng, X. Zhang, M. Tancik, B. Mildenhall, and J. T. Barron. NeRV: Neural reflectance and visibility fields for relighting and view synthesis. https://arxiv.org/abs/2012.03927, 2020.   
+[30] X. Zhang, P. P. Srinivasan, B. Deng, P. Debevec, W. T. Freeman, and J. T. Barron. Nerfactor: Neural factorization of shape and reflectance under an unknown illumination. https://arxiv.org/abs/2106.01970, 2021.   
+[31] L. Liu, J. Gu, K. Z. Lin, T.-S. Chua, and C. Theobalt. Neural sparse voxel fields. In Advances in Neural Information Processing Systems (NeurIPS), volume 33, 2020.   
+[32] D. Lindell, J. Martel, and G. Wetzstein. AutoInt: Automatic integration for fast neural volume rendering. https://arxiv.org/abs/2012.01714, 2020.   
+[33] D. Rebain, W. Jiang, S. Yazdani, K. Li, K. M. Yi, and A. Tagliasacchi. DeRF: Decomposed radiance fields. https://arxiv.org/abs/2011.12490, 2020.   
+[34] T. Neff, P. Stadlbauer, M. Parger, A. Kurz, J. H. Mueller, C. R. A. Chaitanya, A. S. Kaplanyan, and M. Steinberger. DONeRF: Towards Real-Time Rendering of Compact Neural Radiance Fields using Depth Oracle Networks. Computer Graphics Forum, 40(4), 2021. ISSN 1467-8659. doi: 10.1111/cgf.14340. URL https://doi.org/10.1111/cgf.14340.   
+[35] S. J. Garbin, M. Kowalski, M. Johnson, J. Shotton, and J. Valentin. Fastnerf: High-fidelity neural rendering at 200fps. https://arxiv.org/abs/2103.10380, 2021.   
+[36] C. Reiser, S. Peng, Y. Liao, and A. Geiger. Kilonerf: Speeding up neural radiance fields with thousands of tiny mlps, 2021.   
+[37] A. Yu, R. Li, M. Tancik, H. Li, R. Ng, and A. Kanazawa. Plenoctrees for real-time rendering of neural radiance fields. In arXiv, 2021.   
+[38] S. Lombardi, T. Simon, G. Schwartz, M. Zollhoefer, Y. Sheikh, and J. Saragih. Mixture of volumetric primitives for efficient neural rendering, 2021.   
+[39] A. Yu, S. Fridovich-Keil, M. Tancik, Q. Chen, B. Recht, and A. Kanazawa. Plenoxels: Radiance fields without neural networks. arXiv preprint arXiv:2112.05131, 2021.   
+[40] V. Sitzmann, S. Rezchikov, W. T. Freeman, J. B. Tenenbaum, and F. Durand. Light field networks: Neural scene representations with single-evaluation rendering. In arXiv, 2021.   
+[41] T. Müller, A. Evans, C. Schied, and A. Keller. Instant neural graphics primitives with a multiresolution hash encoding. ACM Trans. Graph., 41(4):102:1–102:15, July 2022. doi: 10.1145/3528223.3530127. URL https://doi.org/10.1145/3528223.3530127.   
+[42] R. Martin-Brualla, N. Radwan, M. S. Sajjadi, J. T. Barron, A. Dosovitskiy, and D. Duckworth. Nerf in the wild: Neural radiance fields for unconstrained photo collections. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 7210–7219, 2021.   
+[43] A. Yu, V. Ye, M. Tancik, and A. Kanazawa. pixelnerf: Neural radiance fields from one or few images. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4578–4587, 2021.   
+[44] Q. Wang, Z. Wang, K. Genova, P. P. Srinivasan, H. Zhou, J. T. Barron, R. Martin-Brualla, N. Snavely, and T. Funkhouser. Ibrnet: Learning multi-view image-based rendering. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4690–4699, 2021.   
+[45] K. Zhang, G. Riegler, N. Snavely, and V. Koltun. NERF $^ { + + }$ : Analyzing and improving neural radiance fields. https://arxiv.org/abs/2010.07492, 2020.   
+[46] M. Niemeyer and A. Geiger. GIRAFFE: Representing scenes as compositional generative neural feature fields. https://arxiv.org/abs/2011.12100, 2020.   
+[47] M. Guo, A. Fathi, J. Wu, and T. Funkhouser. Object-centric neural scene rendering. https://arxiv.org/abs/2012.08503, 2020.   
+[48] W. Yuan, Z. Lv, T. Schmidt, and S. Lovegrove. Star: Self-supervised tracking and reconstruction of rigid objects in motion with neural rendering. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 13144–13152, 2021.   
+[49] Z. Wang, T. Bagautdinov, S. Lombardi, T. Simon, J. Saragih, J. Hodgins, and M. Zollhöfer. Learning compositional radiance fields of dynamic human heads. https://arxiv.org/abs/2012.09955, 2020.   
+[50] J. Ost, F. Mannan, N. Thuerey, J. Knodt, and F. Heide. Neural scene graphs for dynamic scenes. https://arxiv.org/abs/2011.10379, 2020.   
+[51] H.-X. Yu, L. J. Guibas, and J. Wu. Unsupervised discovery of object radiance fields. arXiv preprint arXiv:2107.07905, 2021.   
+[52] B. Yang, Y. Zhang, Y. Xu, Y. Li, H. Zhou, H. Bao, G. Zhang, and Z. Cui. Learning objectcompositional neural radiance field for editable scene rendering. In International Conference on Computer Vision (ICCV), October 2021.   
+[53] D. Driess, Z. Huang, Y. Li, R. Tedrake, and M. Toussaint. Learning multi-object dynamics with compositional neural radiance fields. arXiv preprint arXiv:2202.11855, 2022.   
+[54] H. Zhang, R. Wang, J. Zhang, C. Li, G. Yang, P. Spincemaille, T. Nguyen, and Y. Wang. Nerd: Neural representation of distribution for medical image segmentation. arXiv preprint arXiv:2103.04020, 2021.   
+[55] L. Yen-Chen, P. Florence, J. T. Barron, A. Rodriguez, P. Isola, and T.-Y. Lin. iNeRF: Inverting neural radiance fields for pose estimation. IROS, 2021.   
+[56] M. Adamkiewicz, T. Chen, A. Caccavale, R. Gardner, P. Culbertson, J. Bohg, and M. Schwager. Vision-only robot navigation in a neural radiance world. IEEE Robotics and Automation Letters, 7(2):4606–4613, 2022.   
+[57] J. Ichnowski, Y. Avigal, J. Kerr, and K. Goldberg. Dex-nerf: Using a neural radiance field to grasp transparent objects. arXiv preprint arXiv:2110.14217, 2021.   
+[58] L. Yen-Chen, P. Florence, J. T. Barron, T.-Y. Lin, A. Rodriguez, and P. Isola. NeRF-Supervision: Learning dense object descriptors from neural radiance fields. In IEEE Conference on Robotics and Automation (ICRA), 2022.   
+[59] K. Karunratanakul, J. Yang, Y. Zhang, M. J. Black, K. Muandet, and S. Tang. Grasping field: Learning implicit representations for human grasps. In 2020 International Conference on $3 D$ Vision (3DV), pages 333–344. IEEE, 2020.   
+[60] J.-S. Ha, D. Driess, and M. Toussaint. Learning neural implicit functions as object representations for robotic manipulation. arXiv preprint arXiv:2112.04812, 2021.   
+[61] A. Simeonov, Y. Du, A. Tagliasacchi, J. B. Tenenbaum, A. Rodriguez, P. Agrawal, and V. Sitzmann. Neural descriptor fields: Se (3)-equivariant object representations for manipulation. arXiv preprint arXiv:2112.05124, 2021.   
+[62] Y. Wi, P. Florence, A. Zeng, and N. Fazeli. Virdo: Visio-tactile implicit representations of deformable objects. arXiv preprint arXiv:2202.00868, 2022.   
+[63] D. Silver, A. Huang, C. J. Maddison, A. Guez, L. Sifre, G. Van Den Driessche, J. Schrittwieser, I. Antonoglou, V. Panneershelvam, M. Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016.   
+[64] T. Chen, S. Kornblith, M. Norouzi, and G. Hinton. A simple framework for contrastive learning of visual representations. In International conference on machine learning, pages 1597–1607. PMLR, 2020.   
+[65] K. He, H. Fan, Y. Wu, S. Xie, and R. Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 9729–9738, 2020.   
+[66] A. Srinivas, M. Laskin, and P. Abbeel. Curl: Contrastive unsupervised representations for reinforcement learning. arXiv preprint arXiv:2004.04136, 2020.   
+[67] B. You, O. Arenz, Y. Chen, and J. Peters. Integrating contrastive learning with dynamic models for reinforcement learning from images. Neurocomputing, 2022.   
+[68] P. Sermanet, C. Lynch, Y. Chebotar, J. Hsu, E. Jang, S. Schaal, S. Levine, and G. Brain. Time-contrastive networks: Self-supervised learning from video. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pages 1134–1141. IEEE, 2018.   
+[69] A. Kinose, M. Okada, R. Okumura, and T. Taniguchi. Multi-view dreaming: Multi-view world model with contrastive learning. arXiv preprint arXiv:2203.11024, 2022.   
+[70] K. Chen, Y. Lee, and H. Soh. Multi-modal mutual information (mummi) training for robust selfsupervised deep reinforcement learning. In 2021 IEEE International Conference on Robotics and Automation (ICRA), pages 4274–4280. IEEE, 2021.   
+[71] S. Nair, A. Rajeswaran, V. Kumar, C. Finn, and A. Gupta. R3m: A universal visual representation for robot manipulation. arXiv preprint arXiv:2203.12601, 2022.   
+[72] A. Stooke, K. Lee, P. Abbeel, and M. Laskin. Decoupling representation learning from reinforcement learning. In International Conference on Machine Learning, pages 9870–9879. PMLR, 2021.   
+[73] S. Parisi, A. Rajeswaran, S. Purushwalkam, and A. Gupta. The unsurprising effectiveness of pre-trained vision models for control. arXiv preprint arXiv:2203.03580, 2022.   
+[74] D. Yarats, A. Zhang, I. Kostrikov, B. Amos, J. Pineau, and R. Fergus. Improving sample efficiency in model-free reinforcement learning from images. arXiv preprint arXiv:1910.01741, 2019.   
+[75] A. Zhang, R. McAllister, R. Calandra, Y. Gal, and S. Levine. Learning invariant representations for reinforcement learning without reconstruction. arXiv preprint arXiv:2006.10742, 2020.   
+[76] K. Zakka, A. Zeng, P. Florence, J. Tompson, J. Bohg, and D. Dwibedi. Xirl: Cross-embodiment inverse reinforcement learning. In Conference on Robot Learning, pages 537–546. PMLR, 2022.   
+[77] T. Xiao, I. Radosavovic, T. Darrell, and J. Malik. Masked visual pre-training for motor control. arXiv preprint arXiv:2203.06173, 2022.   
+[78] Y. Seo, K. Lee, S. James, and P. Abbeel. Reinforcement learning with action-free pre-training from videos. arXiv preprint arXiv:2203.13880, 2022.   
+[79] T. Lesort, N. Díaz-Rodríguez, J.-F. Goudou, and D. Filliat. State representation learning for control: An overview. Neural Networks, 108:379–392, 2018.   
+[80] M. Niemeyer and A. Geiger. Giraffe: Representing scenes as compositional generative neural feature fields. In Proc. IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2021.   
+[81] K. Stelzner, K. Kersting, and A. R. Kosiorek. Decomposing 3d scenes into objects via unsupervised volume segmentation. arXiv preprint arXiv:2104.01148, 2021.   
+[82] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770– 778, 2016.   
+[83] S. Saito, Z. Huang, R. Natsume, S. Morishima, A. Kanazawa, and H. Li. Pifu: Pixel-aligned implicit function for high-resolution clothed human digitization. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 2304–2314, 2019.   
+[84] R. Hadsell, S. Chopra, and Y. LeCun. Dimensionality reduction by learning an invariant mapping. In 2006 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR’06), volume 2, pages 1735–1742. IEEE, 2006.   
+[85] A. Van den Oord, Y. Li, and O. Vinyals. Representation learning with contrastive predictive coding. arXiv e-prints, pages arXiv–1807, 2018.   
+[86] J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.   
+[87] D. Driess, J.-S. Ha, M. Toussaint, and R. Tedrake. Learning models as functionals of signeddistance fields for manipulation planning. In Conference on Robot Learning (CoRL), 2021.   
+[88] K. He, G. Gkioxari, P. Dollár, and R. Girshick. Mask r-cnn. In Proceedings of the IEEE international conference on computer vision, pages 2961–2969, 2017.   
+[89] A. Raffin, A. Hill, M. Ernestus, A. Gleave, A. Kanervisto, and N. Dormann. Stable baselines3. https://github.com/DLR-RM/stable-baselines3, 2019.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes]   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] See website.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See appendix.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See plots in main paper.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See appendix.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] In the paper and in the code.   
+(b) Did you mention the license of the assets? [Yes] In the code.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] See website.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] In the code.   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/dev/PKdNRKjwL4/PKdNRKjwL4.md

@@ -0,0 +1,535 @@
+# DAIR: DATA AUGMENTED INVARIANT REGULARIZATION
+
+Anonymous authors
+
+Paper under double-blind review
+
+# ABSTRACT
+
+While deep learning through empirical risk minimization (ERM) has succeeded at achieving human-level performance at a variety of complex tasks, ERM generalizes poorly to distribution shift. This is partly explained by overfitting to spurious features such as background in images or named entities in natural language. Synthetic data augmentation followed by empirical risk minimization (DA-ERM) is a simple and widely used solution to remedy this problem. In addition, consistency regularization could be applied to further promote model performance to be consistent on the augmented sample and the original one. In this paper, we propose data augmented invariant regularization (DAIR), a simple form of consistency regularization that is applied directly on the loss function rather than intermediate features. Through extensive empirical experiments, we show that DAIR consistently performs well in a variety of settings. We apply DAIR to multiple real-world learning problems, namely robust regression, visual question answering, robust deep neural network training, and neural task-oriented dialog modeling. Our experiments show that DAIR consistently outperforms ERM and DA-ERM with little marginal cost and sets new state-of-the-art results in several benchmarks.
+
+# 1 INTRODUCTION
+
+Deep neural networks are widely used in various applications ranging from computer vision to language processing. While deep learning has surpassed human-level performance in numerous tasks, neural networks are extremely vulnerable to overfitting to spurious correlations and therefore fail to generalize even under slight perturbations of the test distribution (Arjovsky et al., 2019). This observation motivated the research community to tackle the problem of domain generalization (see (Ribeiro et al., 2020) for a detailed literature review). Recent benchmark datasets, such as Rotated MNIST (Arjovsky et al., 2019), Colored MNIST (Arjovsky et al., 2019), PACS (Li et al., 2017), VLCS (Fang et al., 2013), Office-Home (Venkateswara et al., 2017), Terra Incognita (Beery et al., 2018) and DomainNet (Peng et al., 2019), have shown difficulties for the generalization of deep neural network models under distribution shifts, and have sparked invention of many new algorithmic frameworks to address domain generalization.
+
+A standard approach for improving out-of-distribution performance is to guarantee that learned models are invariant to certain transformations. For example, trained models for computer vision should generally be invariant to rotations, changes in color, or background.
+
+Geometric deep learning bakes such invariances into the neural network architecture. For example, convolutional layers (Lecun et al., 1998) are fundamentally preserving translations. There are other specifically designed networks to maintain invariances: Zaheer et al. (2017) studied the problem of designing models for machine learning tasks defined on sets and characterized the permutation invariant functions. Bloem-Reddy & Teh (2020) obtained generative functional representations of probability distributions that are invariant under the action of a compact group. Finzi et al. (2021) provided an algorithm for solving for the equivariant layers of matrix groups.
+
+Data augmentation promotes invariances in models by curating synthetic examples that exhibit the desired invariances. Tensmeyer & Martinez (2016) showed simple image transformations affect the CNN representations. Mixup (Zhang et al., 2017), CutMix (Yun et al., 2019) and Cutout (DeVries & Taylor, 2017) showed linear combination and random blocking features improves generalization of state-of-the-art neural network architectures. Volpi et al. (2018); Zhou et al. (2020) showed data augmentation with adversarial images could make the label classifier more robust to unknown domain shifts. Cubuk et al. (2018); Lim et al. (2019) introduced a procedure which automatically searches for improved data augmentation policies. Zhou et al. (2020) showed data augmentation with adversarial images could make the label classifier more robust to unknown domain shifts. Nam et al. (2021)
+
+improved domain generalization by reducing the intrinsic style bias of CNNs through training a separate network for randomizing the style of images and generating augmented data during training.
+
+Consistency regularization can be further applied on top of data augmentation to enhance invariance by enforcing similarities on the model. Engstrom et al. (2018); Kannan et al. (2018); Zhang et al. (2019) utilized consistency regularization to train robust neural networks against adversarial attacks. This has been applied to unsupervised learning (Sinha & Dieng, 2021), self-supervised learning (Chen et al., 2020; von Kügelgen et al., 2021), and semi-supervised learning to exploit unlabeled data (Bachman et al., 2014; Laine & Aila, 2016; Sohn et al., 2020; Xie et al., 2020).
+
+Besides the directions mentioned above, researchers have proposed numerous algorithmic solutions to impose invariance and improve domain generalization such as DANN (Ganin et al., 2016), IRM (Ghifary et al., 2015), DRO (Sagawa et al., 2019), MLDG (Li et al., 2018a), CORAL (Sun & Saenko, 2016), MMD (Li et al., 2018b) and CDANN (Li et al., 2018c) and REx (Krueger et al., 2021). The approaches listed above are more complex than simple training mechanisms such as empirical risk minimization (ERM) and hence they cannot be readily applied to involved tasks with non-trivial model architectures. For example, in generative language models imposing a constraint on the intermediate data representations is non-trivial, which is required by CORAL (Sun & Saenko, 2016). Recently, Gulrajani & Lopez-Paz (2020) demonstrated that ERM may even outperform many such complex methods in real-world scenarios, while ERM itself is known to generalizes poorly to distribution shift. For example, in learning neural dialog models, Qian et al. (2021) showed up to $2 9 \%$ performance drop due to the memorization of named entities. Ribeiro et al. (2020) showed that both commercial and state-of-art language models fail on up to $7 6 . 4 \%$ of the generalization tests.
+
+In this paper, we propose a consistency regularization technique, called data augmented invariant regularization (DAIR). DAIR is applicable when data augmentation results in pairs of data samples expecting consistent performance, it specifically penalizes the inconsistency of loss on augmented samples with respect to the original ones. This is in contrast to many feature consistency regularizers that apply on an intermediate embedding space. As a result, DAIR only requires marginal additional cost on top of data augmentation, and is simple and broadly applicable to a wide host of supervised and unsupervised learning tasks, including generative models. We introduce the DAIR formulation, motivate it, and theoretically prove some of its properties in Section 2. We empirically evaluate DAIR on a variety of problem setups ranging from defense against adversarial attacks to domain generalization in the presence of environment shift in Section 3, where our experimental results show that DAIR is competitive with or even outperforms state-of-the-art algorithms specifically designed for imposing invariance in these problems.
+
+# 2 DAIR: DATA AUGMENTED INVARIANT REGULARIZATION
+
+For a data sample $z = ( x , y )$ , let $\ell ( z ; \theta )$ be its parametric loss function, where $\theta$ is the set of model parameters (e.g., network weights). The popular Empirical Risk Minimization (ERM) framework trains the model by minimizing the expected value of the following loss over the training data:
+
+$$
+f _ { \mathrm { E R M } } ( z ; \theta ) = \ell ( z ; \theta ) .
+$$
+
+We assume that we have access to a (potentially randomized) data augmenter function $A ( \cdot )$ . Examples for $A$ include (random) rotation, change of background, or change of entity names. Such augmenters aim at capturing the transformations against which we wish to be invariant to. Given a sample $z$ , let $\widetilde { z } = ( \widetilde { x } , \widetilde { y } ) \overset { \cdot } { = } A ( z )$ denote an augmented sample. Previous work has used both original and e e eaugmented examples during training, which leads to the following standard objective function, called Data Augmented Empirical Risk Minimization (DA-ERM):
+
+$$
+f _ { \mathrm { D A - E R M } } ( \boldsymbol { z } , \widetilde { \boldsymbol { z } } ; \boldsymbol { \theta } ) = \frac { 1 } { 2 } \ell ( \boldsymbol { z } ; \boldsymbol { \theta } ) + \frac { 1 } { 2 } \ell ( \widetilde { \boldsymbol { z } } ; \boldsymbol { \theta } ) .
+$$
+
+While DA-ERM has been successful in many applications, one natural question is whether we can further improve upon it using the knowledge that the performance on augmented samples should be consistent with the original ones. Consistency regularization further penalizes DA-ERM for any such inconsistency at the feature/loss level: fConsistency ${ } _ { , \mathcal { D } , \lambda } ( z , \widetilde { z } ; \theta ) = f _ { \mathrm { D A - E R M } } ( z , \widetilde { z } ; \theta ) + \lambda \mathcal { D } ( z , \widetilde { z } ; \theta )$ , where $\mathcal { D } ( z , \widetilde { z } ; \theta )$ e e e is a proper divergence between the original sample representation and the augmented esample representation, and where the goal of the regularizer applied at some intermediate feature space is to maintain the performance of the model on $z$ and $\tilde { z }$ consistent. In this paper, we focus on a specific type of such regularization, called data augmented invariant regularization (DAIR):
+
+$$
+\begin{array} { l } { f _ { \mathrm { D A I R } , \mathcal { R } , \lambda } ( z , \widetilde { z } ; \boldsymbol { \theta } ) = f _ { \mathrm { D A - E R M } } ( z , \widetilde { z } ; \boldsymbol { \theta } ) + \lambda \mathcal { D } ( z , \widetilde { z } ; \boldsymbol { \theta } ) } \\ { = \displaystyle \frac { 1 } { 2 } \ell ( z ; \boldsymbol { \theta } ) + \frac { 1 } { 2 } \ell ( \widetilde { z } ; \boldsymbol { \theta } ) + \lambda \mathcal { R } ( \ell ( z ; \boldsymbol { \theta } ) , \ell ( \widetilde { z } ; \boldsymbol { \theta } ) ) , } \end{array}
+$$
+
+where the regularization is directly applied to the loss. The idea behind DAIR is to simply promote $\ell ( z ; \theta ) \approx \ell ( \bar { \tilde { z } } ; \theta )$ , and ignore the features or even the rest of the possible outcomes of $y$ and simply foecus on the current sample’s loss. Hence, DAIR is a relatively weak form of consistency regularization only enforcing an original sample and an augmented one to be equally likely under the learned model (assuming loss is a log-likelihood function). This weaker form of consistency is suitable for problems where feature consistency may not be conceptually meaningful. For instance, in language modeling when a pair of sentences differ in their corresponding named entities, it is not clear why we should enforce their embeddings to be similar, however, loss consistency is still meaningful promoting the probability of label given input to be the same on the original and the augmented samples.
+
+We remark that DAIR requires pairing information between original and augmented samples, which may not always be available (e.g., DomainBed (Gulrajani & Lopez-Paz, 2020)). However, we show that this simple approach is still broadly applicable to various real-world problems regardless of model architecture, and is indeed competitive with state-of-the-art methods for imposing invariance. As it turns out, we are particularly interested in a particular form of the DAIR regularizer:
+
+$$
+\begin{array} { r } { \mathcal { R } _ { \mathrm { s q } } ( \ell ( \boldsymbol { z } ; \boldsymbol { \theta } ) , \ell ( \widetilde { \boldsymbol { z } } ; \boldsymbol { \theta } ) ) : = \left( \sqrt { \ell ( \boldsymbol { z } ; \boldsymbol { \theta } ) } - \sqrt { \ell ( \widetilde { \boldsymbol { z } } ; \boldsymbol { \theta } ) } \right) ^ { 2 } , } \end{array}
+$$
+
+(SQ Regularizer)
+
+and we call this variant DAIR-SQ. Note that $\mathcal { R } _ { \mathrm { s q } }$ has the same scale as the loss function $\ell$ , making it easier to tune $\lambda$ . Empirically we observe that the optimal $\lambda$ for all the experiments mentioned later in the paper falls in [0.2, 100], across various tasks (from regression to sequence-to-sequence generative modeling). Further justification on DAIR-SQ will be provided through the rest of this section.
+
+Finally, in most (real-world) applications performance is measured through 0-1 metrics other than the loss function. For example, we are usually concerned with accuracy in image classification while we optimize cross-entropy loss. Let $F ( z ; { \dot { \theta } } ) \in \{ 0 , 1 \}$ denote a 0-1 evaluation performance metric of interest, e.g., accuracy. Given the sample $z$ (or $\widetilde { z }$ ), the model performance is captured by $F ( z ; \theta )$ (or $F \big ( \widetilde z ; \theta \big ) .$ ). For any $z$ such that $F ( z ; \theta ) = 1$ e, we define the corresponding consistency metric as:
+
+$$
+\mathbf { C M } ( z , \widetilde { z } ; \theta ) = \mathbb { I } \{ F ( \widetilde { z } ; \theta ) = 1 \ | \ F ( z ; \theta ) = 1 \} .
+$$
+
+(Consistency Metric)
+
+Notice that similarly to the original performance metric, which is only used for model evaluation, we use the consistency metric at evaluation time only.
+
+# 2.1 WHAT DOES DAIR OFFER BEYOND DA-ERM?
+
+To motivate DAIR, we consider a toy example through which we demonstrate that DAIR can fundamentally outperform DAERM, even in the limit of infinite training samples (no overfitting due to finite samples). Consider a linear regression problem where at the training time the input is ${ \bf x } _ { \mathrm { t r a i n } } = ( x , s = y )$ and the label $y$ , i.e., ${ z _ { \mathrm { t r a i n } } = ( \mathbf { x } _ { \mathrm { t r a i n } } , y ) }$ . Here, $x \sim \mathcal { N } ( 0 , \sigma _ { x } ^ { 2 } )$ , and $y = x + \varepsilon$ , where $\varepsilon$ is independent of $x$ and $\varepsilon \sim \mathcal N ( 0 , \sigma _ { \varepsilon } ^ { 2 } )$ . In this example, the target is explicitly provided as a spurious feature to the learner at the training time. At test time, the spurious feature is absent, i.e., ${ \bf x } _ { \mathrm { t e s t } } \bar { = } ( x , s = 0 )$ .
+
+![](images/37ff7b4047532ad15e9fd410ec41fd4e57f14950a2927133f2c12745fa9aace2.jpg)  
+Figure 1: The plot of the optimal, ERM, DA-ERM and DAIR-SQ $\lambda = 1 0 0$ ).
+
+Clearly, in this toy example, the optimal regressor is $w ^ { \star } =$ $( w _ { 1 } ^ { \star } , \dot { w _ { 2 } ^ { \star } } ) ^ { \top } = ( 1 , \mathbf { \dot { 0 } } ) ^ { \top }$ . However, absent the knowledge of the spurious feature vanilla ERM will learn $w _ { \mathrm { E R M } } \approx ( \mathbf { \bar { 0 } } , 1 ) ^ { \top }$ , completely overfitting the spurious feature. We assume that the learner has access to a data augmentation module that generates $\widetilde { z } = A ( z ; a , \sigma _ { n } ^ { 2 } ) = ( \mathbf { x } _ { \mathrm { a u g } } , y )$ , such that $\mathbf { x } _ { \mathrm { a u g } } = ( x , s = a y + n )$ where $n \sim \mathcal N ( 0 , \sigma _ { n } ^ { 2 } )$ . The augmented edata will encourage the learned model to become invariant to the spurious feature. In Figure 1, we perform simulations with $a = 0 . 5 , \ \sigma _ { x } ^ { 2 } = 1 , \ \sigma _ { \varepsilon } ^ { 2 } = 0 . 2 5 , \ \sigma _ { n } ^ { 2 } = 0 . { \overset { . } { 1 } }$ and plot four lines associated with each regressor with the slope of their respective $w _ { 1 }$ . We ignore $w _ { 2 }$ as the second spurious feature is absent at test time and hence $w _ { 2 }$ does not impact test performance. The optimal regressor is shown as the blue line, with a slope of 1. ERM (red line) completely fails due to the overfitting to the spurious feature. DA-ERM (orange line) significantly improves over ERM but still is far from optimal performance. DAIR-SQ (purple line) almost recovers the optimal solution. This is not a coincidence. We prove that DAIR-SQ is optimal for a class of linear regression problems, while DA-ERM does not approach optimal performance even in the limit of infinite samples. In other words, DAIR can lead to better generalizing models beyond simply offering better sample complexity.
+
+Proposition 1. Consider the class of linear regression problems described above with a spurious feature (highly correlated with the output). Assume that the learner has access to a data augmentation module that perturbs the spurious feature. Then, for any value of a and $\sigma _ { n }$ , DAIR-SQ achieves optimal test error as number of samples grows and $\lambda \to \infty$ . On the other hand, DA-ERM cannot recover optimal performance even in the limit of infinite training data unless $\sigma _ { n } \to \infty$ .
+
+The proof of Proposition 1 is relegated to Appendix A. One can show that simple data independent regularization methods (e.g. weight decay) cannot help close the gap between the performance of DA-ERM and DAIR (see Proposition 2) in Appendix A. While we only analyzed DAIR-SQ, we believe the content of this proposition extends to other variants of DAIR as well. Note that when $\sigma _ { n }  \infty$ , DA-ERM could also recover $w ^ { \star }$ . One can interpret that as $\sigma _ { n }  \infty$ , the augmenter becomes stronger and forces $w _ { 2 }$ to vanish. On the other hand, DAIR recovers $w ^ { \star }$ with a much weaker augmenter. This is crucial since in real-world applications, designing strong augmentation schemes requires careful design. We will expand on this in Section 2.2.
+
+# 2.2 VARIANTS OF DAIR VS OTHER CONSISTENCY REGULARIZATION TECHNIQUES
+
+In this section, we empirically compare ERM, DA-ERM and some variants of consistency regularization, including two DAIR variants on two classification tasks using CNNs. Let $\mathbf { q } ( z ; \theta )$ be the output of the model right after the softmax layer. If we treat the loss function as (un-normalized) negative log-likelihood of the output distribution, and let $\mathbf { q } ( z ; \theta ) \propto e ^ { - \ell ( z ; \theta ) }$ . In addition to DAIR variants, we consider the regularizer to be any proper divergence between the output distributions $\mathbf { q } ( z ; \theta )$ and $\mathbf { q } ( \widetilde { z } ; \theta )$ , such as $\mathcal { L } _ { 2 }$ distance or KL divergence, which will promote ${ \bf q } ( z ; \theta ) \approx { \bf q } ( \tilde { z } ; \theta )$ .
+
+Rotated MNIST (Ghifary et al., 2015) is a dataset where MNIST digits are rotated. We work with two different sets of degrees of rotation for Rotated MNIST. The first one is Weak Rotation where the digits are rotated uniformly at random $[ 0 , \frac { \pi } { 6 } )$ radians. In Strong Rotation the digits are rotated uniformly at random $[ 0 , 2 \pi )$ radians. To evaluate the robustness of the methods, we further add label noise at training time where the label is replaced with a digit chosen from $\{ 0 , \ldots , 9 \}$ uniformly at random with a certain probability. No label noise is added at test time. Detailed setup is in Appendix D.
+
+In the first experiment, we use Weak Rotation for data augmentation while at test time we use Strong Rotation. Thus, some test time rotations have not been observed at training time. Figure 2 shows the test performance of all algorithms (averaged over three runs) as a function of $\lambda$ . As can be seen, ERM (with no data augmentation) does not generalize to rotated test images and performs poorly. DA-ERM offers significant performance improvement over ERM. When $\lambda$ is very small all variants of consistency regularization are virtually the same as DA-ERM. DAIR-SQ and KL regularizer outperform other regularizers and are the only two variants that offer improvement over DA-ERM as $\lambda$ increases. As the label noise level becomes larger, DAIR-SQ is more robust than KL and offers the best performance.
+
+![](images/ff2325b8e9d7c29aab0305dc9247174d5a9f3390bec1ca15502adb11cba70914.jpg)  
+Figure 2: Test accuracy as a function of $\lambda$ for different noise levels for Weak Rotation augmentation.
+
+Besides DAIR-SQ and KL regularizer, it is noteworthy that the other consistency regularization variants did not offer improvement over DA-ERM and they converged to poor local minima with
+
+$1 0 \%$ test accuracy (random) for large $\lambda$ . We were not able to remedy this by tuning of their step size. See Section 2.3 for further justification of this phenomenon. We also observe that the performance of both DAIR-SQ and KL regularizer achieves a sweet spot for some finite $\lambda$ , i.e., the performance starts to drop for large values of $\lambda$ . This is not theoretically expected and can be attributed to the practical issues with solving the consistency regularization problem. We further investigate this phenomenon in Appendix B and provide some explanations.
+
+The setup for the second experiment is the same as the first one, except we also use Strong Rotation in training for augmentation, so there is no distribution shift for DA-ERM. As can be seen in Figure 3, data augmentation achieves very good performance in this case and none of the DAIR regularizers offer any improvement beyond data augmentation. We suspect this to be true in general; if the data augmentation is well-devised and optimized the resulting model could become invariant to the desired transformations at test time. This also agrees with findings of Section 2.1, where observed that with strong augmentation, DA-ERM could potentially result in similar performance as DAIR. Additional experiments on consistency metric can be found in Appendix E.1.
+
+![](images/bdb7d222e1905737f9904da789543cd178fd13b8c630ff08e7aea1b44a429156.jpg)  
+Figure 3: Test accuracy as a function of $\lambda$ for different noise levels for Strong Rotation augmentation.
+
+Colored MNIST (Arjovsky et al., 2019) is a binary classification task built on the MNSIT dataset. Digits 0-4 are labeled 1; whereas digits 5-9 are labeled 0. Additionally, $25 \%$ label noise is added, i.e., the labels are flipped with probability 0.25, both at train and test time, capping the achievable test accuracy to $7 5 \%$ . In this dataset, each digit is RGB colored. During training, label 1 is given the color green with probability 0.9 and red with probability 0.1. On the other hand, label 0 is given red color with probability 0.9 and green with probability 0.1. This introduces a high degree of spurious correlation between color and the label. Thus, ERM is expected to significantly overfit to color for predicting the label.
+
+At test time, the correlation with color is reversed for digits. Hence, vanilla ERM is expected to perform worse than $50 \%$ coin flip at test time. We explore two data augmentation schemes in this experiment. For the Adversarial Augmentation (Adv. Aug.) setup, the augmented images will have their color flipped (from red to green or vice versa) with probability 0.1. For the Random Augmentation (Rnd. Aug.) setup, the augmented images are colored uniformly at random. Detailed description of the setup and additional experiments can be found in Appendix D and Appendix E.1, respectively.
+
+![](images/cbdd0d4b43f587362bd68082869f2997330d07ee9684001a51b0a4a1b2cc583a.jpg)  
+Figure 4 suggests that DAIR-SQ and KL consistency regularization achieve $\sim 7 2 \%$ test accuracy using both augmentation schemes, outperforming the stateof-the-art $6 8 \%$ test accuracy reported by invariant risk minimization (IRM) (Arjovsky et al., 2019), and almost reaching the $7 5 \%$ cap. We note however that this comparison may be unfair because IRM does not have access to any pairing information between the original and the augmented samples. As we observe in the next section, such information is readily available in several real-world benchmarks and DAIR can   
+Figure 4: Test accuracy vs $\lambda$ on Colored MNIST for Adversarial Color augmentation and Random Color augmentation.
+
+exploit it to achieve new state-of-the-art results. We also notice that neither variant of DA-ERM achieves test performance better than $50 \%$ coin flip in this experiment, while Adversarial Augmentation seems to fare better than Random Augmentation.
+
+Following the experiments, we conclude that DAIR-SQ is more stable and robust than other ones followed by KL divergence consistency regularization. Additionally, DAIR-SQ enjoys the simplicity and computational efficiency, especially when the cardinality of the output is large, e.g., language models where output vector dimension is the same as the vocabulary size. As opposed to KL divergence, DAIR-SQ is also readily applicable to regression with uncountable output.
+
+# 2.3 FURTHER JUSTIFICATION OF DAIR-SQ AND PRACTICAL CONSIDERATIONS
+
+While we have already compared DAIR-SQ with several consistency regularization alternatives, we want to specifically focus on a closely related DAIR variant called DAIR-L1, i.e., $\mathcal { R } _ { 1 } ( \ell ( z ; \theta ) , \ell ( \widetilde { z } ; \theta ) ) \ : = \ : | \ell ( z ; \theta ) - \ell ( \widetilde { z } ; \theta ) |$ . As we already observed in Section 2.2, DAIR-L1 eie ether outright failed or was unstable on majority of the experiments we have performed so far. The following lemma further investigates the discrepancy between DAIR-SQ and DAIR-L1:
+
+Lemma 1. For any non-negative loss function $\ell$ ,
+
+$$
+\mathscr { R } _ { 1 } ( z , \widetilde { z } ; \theta ) - \mathscr { R } _ { s q } ( z , \widetilde { z } ; \theta ) = 2 \sqrt { \operatorname* { m i n } \{ \ell ( z ; \theta ) , \ell ( \widetilde { z } ; \theta ) \} \mathscr { R } _ { s q } ( z , \widetilde { z } ; \theta ) } \geq 0 .
+$$
+
+Thus, $\mathcal { R } _ { 1 } ( z , \widetilde { z } ; \theta ) \ge \mathcal { R } _ { s q } ( z , \widetilde { z } ; \theta )$ with equality iff $\ell ( \widetilde { z } ; \theta ) = 0$ or $\ell ( z ; \theta ) = 0$ or $\ell ( \tilde { z } ; \theta ) = \ell ( z ; \theta ) .$
+
+The proof of Lemma 1 appears in Appendix A. The difference is depicted in Figure 5. This suggests that $\bar { \mathcal { R } } _ { \mathrm { s q } } ( z , \tilde { z } ; \theta )$ incurs a much smaller penalty when $\ell ( z ; \theta )$ e is large. On the other hand, when $\ell ( z ; \theta ) \approx 0$ the regularizer is much stronger and almost equivalent to $\mathcal { R } _ { 1 }$ . Why does this matter? At the beginning of training when the network is not yet trained, the loss values on the original samples are large, and the $\mathcal { R } _ { \mathrm { s q } }$ regularizer is weak letting the training to proceed towards a good solution for the original samples. As the network is being trained on original samples and their loss is vanishing, the regulairzer starts to force the network to become invariant on the augmented samples.
+
+We empirically verify this conjecture on Colored MNIST with Adversarial Augmentation. Figure 6 depicts the classification loss and regularization of the first 10 and last 140 iterations. One observes that at the beginning of training, regularization term of DAIR-SQ impacts the training dynamics less while DAIR-L1 starts optimizing the regularizer right away, which dominates the entire training procedure and therefore leads the model to a poor local minimum. The left panel of Figure 6 confirms that the classification loss of DAIR-L1 remains large and unchanged (that of a random classifier).
+
+![](images/d13b1a3ae0ef6fa198dcc4a8c7e47b61cdb6e7f9b3a6584e42c53a20aa62ccf6.jpg)  
+Figure 5: The plot of $\mathcal { R } _ { 1 } ^ { - } ( z , \widetilde { z } ; \theta ) - \mathcal { R } _ { \mathrm { s q } } ( z , \widetilde { z } ; \theta )$ .
+
+![](images/9a7f8b8452c2d6010fbe3a709355924dbd8c027d269c7610b70ac6c53a46411c.jpg)  
+Figure 6: Training DA-ERM loss and (SQ Regularizer) for first 10 and last 140 iterations on Colored MNIST with Adv Aug for DAIR $( \lambda = 1 0 0 )$ ). The regularizer loss on DA-ERM grows large as it is uncontrolled. DAIR-L1 is optimizing an L1 regularizer, but for unified illustration we evaluate it using (SQ Regularizer).
+
+This same property of DAIR-SQ also weakens the regularizer on training samples with high losses at the later stages of training. These samples are likely noisy, which makes DAIR-SQ more robust to noisy samples, as we already observed in Section 2.2.
+
+# 2.4 THE IMPACT OF PARTIAL AUGMENTATION
+
+We explore the impact of partial augmentation, where we only augment a certain fraction of the training samples. The experiment revisits noiseless Rotated MNIST with weak rotation data augmentation and Colored MNIST with Adversarial augmentation. This experiment emulates situations where an augmentation function is only applicable to certain examples or where augmentation is expensive and we would like to decrease the augmentation cost.
+
+![](images/83e9c144417d088b7469b969e9e8eb7eccabb0a04be254a76cd736d1948bf2ac.jpg)  
+Figure 7: Test accuracy vs fraction of augmented samples on Rotated MNIST.
+
+In Figure 7, we report the experiment results for DA-ERM and DAIR-SQ by applying augmentation only { $10 \%$ , $20 \%$ , $30 \%$ , $50 \%$ , $100 \%$ } of the training samples, averaged on three runs. In Rotated MNIST experiment, as can be seen, DAIR-SQ with augmentation on only $20 \%$ of the samples performs similar to full augmentation. On the other hand, DA-ERM is more sensitive to partial augmentation and is subject to a steeper performance drop. This could be viewed as further evidence that DAIR-SQ could reach its best performance using weak augmenter functions. It is also noteworthy that in this example, DAIR-SQ with only $10 \%$ partial augmentation still outperforms DA-ERM with $100 \%$ augmentation. One can draw similar conclustion in the Colored MNIST experiment as only $10 \%$ augmentation gives comparable performance to full augmentation.
+
+# 3 EXPERIMENTS ON REAL-WORLD TASKS
+
+# 3.1 ROBUST REGRESSION: SIMULTANEOUS DOMAIN SHIFT AND LABEL NOISE
+
+In this experiment, we consider a regression task to minimize the root mean square error (RMSE) of the predicted values on samples from the Drug Discovery dataset. The task is to predict the bioactivities given a set of chemical compounds (binary features). We follow the setup of Li et al. (2021) to introduce random noise to corrupt the targets. Furthermore, similar to Colored MNIST, we add a spurious binary feature to the original setup. At training time, the spurious feature is set to 1 if a particular target is above the median of the all the targets in the training samples, and 0 otherwise. At test time, this condition is reversed leading to poor generalization. We compare using ERM, DA-ERM and DAIR-SQ formulations under $0 \%$ , $20 \%$ and $40 \%$ noise levels on three baselines: $\mathcal { L } _ { 2 }$ loss, Huber loss, and negatively tilted loss (Li et al., 2021), which is called tilted empirical risk minimization (TERM) and is designed for robust regression. For each of these baselines, we perform data augmentation by randomly assigning the spurious feature as 0 or 1 with equal probability. Finally, we apply the DAIR-SQ regularizer to each of these loss functions with $\lambda = 1 0$ .
+
+<table><tr><td rowspan="3">Algorithms</td><td colspan="10">Test RMSE (Drug Discovery dataset)</td></tr><tr><td colspan="3">0%Noise</td><td colspan="3">20% Noise</td><td colspan="3">40%Noise</td><td>Clean</td></tr><tr><td>=</td><td>DA-</td><td>DAIR</td><td>-</td><td>DA-</td><td>DAIR</td><td>1</td><td>DA-</td><td>DAIR</td><td>-</td></tr><tr><td>L2loss</td><td>1.97 (0.00)</td><td>1.36 (0.00)</td><td>1.23 (0.00)</td><td>4.33 (0.04)</td><td>2.52 (0.05)</td><td>2.04 (0.06)</td><td>5.30 (0.04)</td><td>3.47 (0.07)</td><td>2.99 (0.09)</td><td>1.23 (0.00)</td></tr><tr><td>Huber (Huber,1964)</td><td>1.84 (0.00)</td><td>1.27 (0.00)</td><td>1.24 (0.00)</td><td>2.93 (0.05)</td><td>1.50 (0.02)</td><td>1.39 (0.02)</td><td>4.40 (0.07)</td><td>2.18 (0.04)</td><td>1.70 (0.05)</td><td>1.16 (0.00)</td></tr><tr><td>TERM (Li et al.,021)</td><td>1.74 (0.00)</td><td>1.26 (0.00)</td><td>1.25 (0.00)</td><td>1.87 (0.01)</td><td>1.27 (0.01)</td><td>1.27 (0.01)</td><td>2.01 (0.02)</td><td>1.33 (0.01)</td><td>1.31 (0.01)</td><td>1.23 (0.00)</td></tr></table>
+
+Table 1: Test RMSE for varying degrees of label noise for ERM, DA-ERM, and DAIR using different losses.
+
+The results of this experiment are reported in Table 1. In the last column of the table we report results on the clean dataset without any spurious features for comparison purposes. As can be seen, without data augmentation all methods fall prey to spurious features and perform poorly, especially as the noise level is increased. It is noteworthy that while TERM is not designed for domain shift, it slightly outperforms the other baselines in the presence of spurious features showing that TERM has some inherent robustness to the domain shift. By adopting data augmentation, testing error decreases but is still quite large as compared to the Clean ERM setup for high values of noise. Notably, DAIR is able to reduce the testing error across all objectives and noise levels with the gap between DAIR and other approaches increasing with the degree of noise. For the $0 \%$ noise setup, DAIR is able to almost recover the Clean ERM accuracy for all three objectives. The gains achieved with DAIR are prominent for $\mathcal { L } _ { 2 }$ and Huber, but marginal for TERM. Finally, data augmentation/DAIR combined with TERM can simultaneously handle domain shift and noisy labels as can be seen in this table.
+
+# 3.2 INVARIANT VISUAL QUESTION ANSWERING
+
+Visual Question Answering (VQA) has diverse applications ranging from visual chatbots to assistants for the visually impaired. In such real-world settings, it is desirable for VQA models to be robust to variations in the input modalities. In this spirit, recent works (Agarwal et al., 2020; Shah et al., 2019; Ray et al., 2019) have studied the robustness and consistency of VQA models under linguistic and visual variations. In this paper, we focus on the InVariant VQA (IV-VQA) dataset which contains semantically edited images corresponding to a subset of the original images from VQA v2 (Goyal et al., 2017). For each image in this subset, IV-VQA contains one or more edited images constructed by removing an object which is irrelevant to answering the question. A robust model should be invariant to such edits by making the same predictions on the edited image.
+
+We choose the attention based SAAA (Kazemi & Elqursh, 2017) model to match the original setup from Agarwal et al. (2020). Using DAIR, we enforce consistency in predictions between the original and edited samples. Wherever the edited image is not available, the DAIR formulation reduces to ERM. We use the standard VQA accuracy along with the consistency metrics proposed in Agarwal et al. (2020) to compare our results against the ERM setup and the DA-ERM approach discussed in Agarwal et al. (2020).
+
+The results are reported in Table 2. We measure the accuracy on the original VQA v2 ‘val’ set and the consistency metrics across edited IV-VQA instances and their corresponding real instances from VQA v2 ‘val’ set. The consistency metrics measure the three types of flips namely, pos neg, neg $ \mathrm { p o s }$ and neg neg. A pos neg
+
+Table 2: Accuracy and Consistency metrics on VQA v2 val & IV-VQA test set.   
+
+<table><tr><td>Algorithm</td><td>ERM(%) (Kazemi &amp; Elqursh,2017)</td><td>DA-ERM(%) (Agarwal et al., 2020)</td><td>DAIR-SQ (%)</td></tr><tr><td>VQA v2 val</td><td>57.10</td><td>57.30</td><td>57.54</td></tr><tr><td>Predictions flipped</td><td>11.84</td><td>11.68</td><td>10.37</td></tr><tr><td>pos →neg</td><td>4.58</td><td>4.40</td><td>3.80</td></tr><tr><td>neg→pos</td><td>5.17</td><td>5.14</td><td>4.65</td></tr><tr><td>neg→neg</td><td>2.08</td><td>2.14</td><td>1.91</td></tr></table>
+
+flip indicates that the answer predicted with the original image was correct but was wrong with the corresponding edited image. A neg neg flip indicates that the answer changes from original to edited image but is wrong for both. The accuracy of DAIR on the VQA v2 ‘val’ set is higher as compared to others, while improving over all baselines by a minimum of $1 . 3 \%$ under the ‘Predictions flipped’ metric which is the sum of the three types of flips. This improvement is significant given that the model needs to predict the answer correctly from 3000 candidate answers. While applying DAIR to this task, we observe a trade-off between the VQA accuracy on ‘val’ and the ‘Predictions flipped’ percentage controlled by the $\lambda$ parameter. By increasing $\lambda$ , the ‘Predictions flipped’ percentage decreases, and drops to as low as $7 \%$ when $\lambda$ is at 10, albeit sacrificing the VQA accuracy by $5 \%$ . Thus, for moderate values of $\lambda$ , DAIR is able to maintain the predictive power while enforcing consistency across variations in the visual space.
+
+# 3.3 TRAINING ROBUST DEEP NETWORKS AGAINST ADVERSARIAL ATTACKS
+
+In this section, we demonstrate that our regularizer can be applied to train robust neural networks and it achieves comparable or better results than baseline models from state-of-the-art approaches which are specifically designed for this task. In our approach, the augmented examples $\widetilde { z }$ can be generated by a certain strong attack, such as Projected Gradient Descent (PGD) (Madry et al., 2018) or CW (Carlini & Wagner, 2017).We conduct our experiments on CIFAR-10 dataset and compare our approach with several other state-of-the-art baselines.
+
+The performance of our algorithm against FGSM and variants of PGD, is summarized in Table 3, which shows that our results are competitive with the baselines. We report the performance of DAIR-SQ in Table 3 based on the configurations that give the best Clean accuracy (row 3) and the best Robust accuracy against PGD20 (row 6). The trade-off curve shown in Figure 8 suggests that by sweeping the value of $\lambda$ , DAIR-SQ can achieve a better clean accuracy but a slightly lower PGD20 accuracy, and dominates most of the baseline, while it achieves a similar performance with TRADES. Note that the formulation in TRADES is equivalent to consistency regularization with KL divergence between the logits of the original and adversarial images. As opposed to our setup, the regularizer term in TRADES is also used in solving the maximization problem to generate adversarial images, whereas we only use the original loss for generating the adversarial examples.
+
+We also report the accuracy consistency metric (CM) in this experiment in Table 3. CM captures the consistency of accuracy on PGD20 attack compared to clean examples. We observe that DAIR-SQ outperforms all baselines, which is in line with its best generalization to different attacks.
+
+Table 3: CIFAR-10 test accuracies under no attack (clean), FGSM, and PGD20 attacks, and accuracy consistency metric between original and PGD20 attack.   
+
+<table><tr><td>#</td><td>Algorithm</td><td>Clean (%)</td><td>FGSM(%)</td><td>PGD20 (%)</td><td>CM(%)</td></tr><tr><td></td><td>PGD Training (Madry et al.,2018)</td><td>82.89</td><td>55.38</td><td>48.40</td><td></td></tr><tr><td>2</td><td>APART (Li et al.,2020)</td><td>82.45</td><td>55.33</td><td>48.95</td><td>60.05</td></tr><tr><td>3</td><td>DAIR-SQ (λ= 6)</td><td>83.04</td><td>57.57</td><td>50.68</td><td>62.66</td></tr><tr><td>4</td><td>TRADES+ ATTA (Zheng et al.,2020)</td><td>78.98</td><td>55.58</td><td>52.30</td><td>60.56</td></tr><tr><td></td><td>TRADES (Zhang et al.,2019)</td><td>81.67</td><td>57.78</td><td>52.90</td><td>63.14</td></tr><tr><td>6</td><td>DAIR-SQ (入= 16.7)</td><td>81.29</td><td>58.58</td><td>53.37</td><td>67.51</td></tr></table>
+
+![](images/cf39a85e76c65ecfd4935129e65175bbf96fc309b1db2ed3ebb5cedfc03d8234.jpg)  
+Figure 8: PGD20/Clean Acc. trade-off by sweeping $\lambda$ .
+
+# 3.4 NEURAL TASK-ORIENTED DIALOG MODELING
+
+Virtual digital assistants that engage in conversations with human users are rapidly gaining popularity. These devices require the modelling of task-oriented dialog systems that can communicate with users through natural language to accomplish a wide range of tasks. One of the main objectives in task-oriented dialog systems is the Dialog State Tracking (DST), which refers to keeping track of the user goals as the conversation progresses. Among task-oriented dialog datasets, MultiWOZ (Budzianowski et al., 2018) has gained the most popularity owing to the availability of $1 0 \mathrm { k } +$ realistic dialogs across 8 different domains, and has been improved several times (Wu et al., 2019; Eric et al., 2019; Zang et al., 2020; Han et al., 2021; Qian et al., 2021).
+
+Recently, SimpleTOD (Hosseini-Asl et al., 2020) achieved state-of-the-art results on MultiWOZ using a neural end-to-end modeling approach. However, Qian et al. (2021) observed that the performance of SimpleTOD drops significantly when the test set named entities (which are places in the UK) are replaced with new ones never observed during training (with new entities all based in the US), perhaps due to the memorization of named entities during training. We leverage DAIR-SQ to promote invariance of the dialog policy to named entities in the dialog flow. Here, the data augmentation scheme is a simple one. We replace named entities in the training set with their randomly scrambled version. For example, “cambridge” could be turned into “bmcedrgia.” Details on training data, augmentation schemes and hyper-parameters can be found in Appendix H.
+
+The results are presented in Table 4, where performance is measured in Joint Goal Accuracy (JGA). JGA is a binary metric, and is equal to 1 if the predictions of all dialog states in a turn are correct. As such it is a difficult metric to get right too. As can be seen, both DA-ERM and DAIR outperform SimpleTOD (Hosseini-Asl et al., 2020) on MultiWOZ 2.2 w/ SGD entities (Qian et al., 2021). Perhaps, more surprisingly, DAIR also outperforms SimpleTOD on the original MultiWOZ 2.2 test set with no distribution shift, which we attribute to better robustness to the named entity memorization problem observed by Qian et al. (2021). Finally, we also observe that DAIR significantly improves the JGA consistency metric compared to the DA-ERM baseline.
+
+Table 4: Joint Goal Accuracy (JGA) for different approaches on the SimpleTOD model. DAIR achieves state-of-the-art results on the original MultiWOZ 2.2 test set (Zang et al., 2020) and well as the MultiWOZ 2.2 test set w/ named entities replaced with SGD (Qian et al., 2021).   
+
+<table><tr><td></td><td>MultiWOZ 2.2 Test JGA</td><td>MultiWOZ 2.2 Test JGA w/ SGD entities</td><td>CM</td></tr><tr><td>SimpleTOD (Hosseini-Asl et al.,2020)</td><td>0.5483</td><td>0.4844</td><td>1</td></tr><tr><td>SimpleTOD (DA-)</td><td>0.5915 (0.055)</td><td>0.5311 (0.0074)</td><td>0.8354</td></tr><tr><td>SimpleTOD (DAIR)</td><td>0.5998 (0.0030)</td><td>0.5609 (0.0074)</td><td>0.8902</td></tr></table>
+
+# 4 CONCLUSION
+
+In this paper, we proposed a simple yet effective consistency regularization technique, called data augmented invariant regularization (DAIR). DAIR is applicable when data augmentation is used to promote performance invariance across pairs of original and augmented samples, and it enforces the loss to be similar on the original and the augmented samples. As such, DAIR requires access to pairs of original and augmented examples. We also provided motivation and justification for DAIR, and particularly showed that it can recover the optimal solution in a certain regression task where data augmentation alone is insufficient. We also compared DAIR with several other consistency regularizers on several toy problems and showed that it is more stable and results in better performance. We empirically evaluated DAIR in four real-world machine learning tasks, namely robust regression, invariant visual question answering, training robust deep neural networks, and task-oriented dialog modeling. This is a major benefit of DAIR as some of other consistency regularizers cannot be applied broadly. Empirically, DAIR performed well on all these tasks and set new state-of-the-art results in these benchmarks.
+
+Several problems remain open for future research: An in-depth theoretical understanding of the properties of DAIR that lead to its superior empirical performance on broad applications is an important open question. Further, automated hyperparameter tuning techniques for the strength of the regularizer is another avenue for future research. Finally, while we showed that DAIR boosts existing performance metrics, such as accuracy, the interplay of DAIR with other metrics, especially group fairness, is another important area for future research.
+
+# REFERENCES
+
+Vedika Agarwal, Rakshith Shetty, and Mario Fritz. Towards causal VQA: Revealing and reducing spurious correlations by invariant and covariant semantic editing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2020.
+
+Martin Arjovsky, Léon Bottou, Ishaan Gulrajani, and David Lopez-Paz. Invariant risk minimization. arXiv preprint arXiv:1907.02893, 2019.
+
+Philip Bachman, Ouais Alsharif, and Doina Precup. Learning with pseudo-ensembles. Advances in neural information processing systems, 27:3365–3373, 2014.
+
+Sara Beery, Grant Van Horn, and Pietro Perona. Recognition in terra incognita. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 456–473, 2018.
+
+Benjamin Bloem-Reddy and Yee Whye Teh. Probabilistic symmetries and invariant neural networks. J. Mach. Learn. Res., 21:90–1, 2020.
+
+Paweł Budzianowski, Tsung-Hsien Wen, Bo-Hsiang Tseng, Inigo Casanueva, Stefan Ultes, Osman Ramadan, and Milica Gašic. Multiwoz–a large-scale multi-domain wizard-of-oz dataset for ´ task-oriented dialogue modelling. arXiv preprint arXiv:1810.00278, 2018.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks, 2017.
+
+Yining Chen, Colin Wei, Ananya Kumar, and Tengyu Ma. Self-training avoids using spurious features under domain shift. arXiv preprint arXiv:2006.10032, 2020.
+
+Ekin D Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V Le. Autoaugment: Learning augmentation policies from data. arXiv preprint arXiv:1805.09501, 2018.
+
+Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.
+
+Logan Engstrom, Andrew Ilyas, and Anish Athalye. Evaluating and understanding the robustness of adversarial logit pairing. arXiv preprint arXiv:1807.10272, 2018.
+
+Mihail Eric, Rahul Goel, Shachi Paul, Abhishek Sethi, Sanchit Agarwal, Shuyag Gao, and Dilek Hakkani-Tur. Multiwoz 2.1: Multi-domain dialogue state corrections and state tracking baselines. arXiv preprint arXiv:1907.01669, 2019.
+
+Chen Fang, Ye Xu, and Daniel N Rockmore. Unbiased metric learning: On the utilization of multiple datasets and web images for softening bias. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1657–1664, 2013.
+
+Marc Finzi, Max Welling, and Andrew Gordon Wilson. A practical method for constructing equivariant multilayer perceptrons for arbitrary matrix groups. arXiv preprint arXiv:2104.09459, 2021.
+
+Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, François Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. The journal of machine learning research, 17(1):2096–2030, 2016.
+
+Muhammad Ghifary, W Bastiaan Kleijn, Mengjie Zhang, and David Balduzzi. Domain generalization for object recognition with multi-task autoencoders. In Proceedings of the IEEE international conference on computer vision, pp. 2551–2559, 2015.
+
+Yash Goyal, Tejas Khot, Douglas Summers-Stay, Dhruv Batra, and Devi Parikh. Making the V in VQA matter: Elevating the role of image understanding in Visual Question Answering. In Conference on Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Ishaan Gulrajani and David Lopez-Paz. In search of lost domain generalization. ICLR, 2020.
+
+Ting Han, Ximing Liu, Ryuichi Takanobu, Yixin Lian, Chongxuan Huang, Dazhen Wan, Wei Peng, and Minlie Huang. Multiwoz 2.3: A multi-domain task-oriented dialogue dataset enhanced with annotation corrections and co-reference annotation, 2021.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks, 2016.
+
+Ehsan Hosseini-Asl, Bryan McCann, Chien-Sheng Wu, Semih Yavuz, and Richard Socher. A simple language model for task-oriented dialogue. NeurIPS, 2020.
+
+Peter J. Huber. Robust estimation of a location parameter. Annals of Mathematical Statistics, 35: 492–518, 1964.
+
+Harini Kannan, Alexey Kurakin, and Ian Goodfellow. Adversarial logit pairing. arXiv preprint arXiv:1803.06373, 2018.
+
+V. Kazemi and A. Elqursh. Show, ask, attend, and answer: A strong baseline for visual question answering. ArXiv, abs/1704.03162, 2017.
+
+David Krueger, Ethan Caballero, Joern-Henrik Jacobsen, Amy Zhang, Jonathan Binas, Dinghuai Zhang, Remi Le Priol, and Aaron Courville. Out-of-distribution generalization via risk extrapolation (REx). In Marina Meila and Tong Zhang (eds.), Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pp. 5815–5826. PMLR, 18–24 Jul 2021. URL https://proceedings.mlr.press/v139/ krueger21a.html.
+
+Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. arXiv preprint arXiv:1610.02242, 2016.
+
+Y. Lecun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. doi: 10.1109/5.726791.
+
+Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Ves Stoyanov, and Luke Zettlemoyer. Bart: Denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension. arXiv preprint arXiv:1910.13461, 2019.
+
+Da Li, Yongxin Yang, Yi-Zhe Song, and Timothy M Hospedales. Deeper, broader and artier domain generalization. In Proceedings of the IEEE international conference on computer vision, pp. 5542–5550, 2017.
+
+Da Li, Yongxin Yang, Yi-Zhe Song, and Timothy Hospedales. Learning to generalize: Meta-learning for domain generalization. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018a.
+
+Haoliang Li, Sinno Jialin Pan, Shiqi Wang, and Alex C Kot. Domain generalization with adversarial feature learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5400–5409, 2018b.
+
+Tian Li, Ahmad Beirami, Maziar Sanjabi, and Virginia Smith. Tilted empirical risk minimization. ICLR, 2021.
+
+Ya Li, Xinmei Tian, Mingming Gong, Yajing Liu, Tongliang Liu, Kun Zhang, and Dacheng Tao. Deep domain generalization via conditional invariant adversarial networks. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 624–639, 2018c.
+
+Zichao Li, Liyuan Liu, Chengyu Dong, and Jingbo Shang. Overfitting or underfitting? understand robustness drop in adversarial training, 2020.
+
+Sungbin Lim, Ildoo Kim, Taesup Kim, Chiheon Kim, and Sungwoong Kim. Fast autoaugment. Advances in Neural Information Processing Systems, 32:6665–6675, 2019.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In International Conference on Learning Representations, 2018.
+
+A. H. Miller, W. Feng, A. Fisch, J. Lu, D. Batra, A. Bordes, D. Parikh, and J. Weston. Parlai: A dialog research software platform. arXiv preprint arXiv:1705.06476, 2017.
+
+Hyeonseob Nam, HyunJae Lee, Jongchan Park, Wonjun Yoon, and Donggeun Yoo. Reducing domain gap by reducing style bias. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 8690–8699, 2021.
+
+Xingchao Peng, Qinxun Bai, Xide Xia, Zijun Huang, Kate Saenko, and Bo Wang. Moment matching for multi-source domain adaptation. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 1406–1415, 2019.
+
+Kun Qian, Ahmad Beirami, Zhouhan Lin, Ankita De, Alborz Geramifard, Zhou Yu, and Chinnadhurai Sankar. Annotation inconsistency and entity bias in MultiWOZ. The 22nd Annual Meeting of the Special Interest Group on Discourse and Dialogue (SIGDIAL), July 2021.
+
+Abhinav Rastogi, Xiaoxue Zang, Srinivas Sunkara, Raghav Gupta, and Pranav Khaitan. Towards scalable multi-domain conversational agents: The schema-guided dialogue dataset, 2020.
+
+Arijit Ray, Karan Sikka, Ajay Divakaran, Stefan Lee, and Giedrius Burachas. Sunny and dark outside?! improving answer consistency in vqa through entailed question generation. In EMNLP/IJCNLP, 2019.
+
+Marco Tulio Ribeiro, Tongshuang Wu, Carlos Guestrin, and Sameer Singh. Beyond accuracy: Behavioral testing of NLP models with CheckList. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pp. 4902–4912, Online, July 2020. Association for Computational Linguistics. doi: 10.18653/v1/2020.acl-main.442. URL https://aclanthology.org/2020.acl-main.442.
+
+Shiori Sagawa, Pang Wei Koh, Tatsunori B Hashimoto, and Percy Liang. Distributionally robust neural networks for group shifts: On the importance of regularization for worst-case generalization. arXiv preprint arXiv:1911.08731, 2019.
+
+Meet Shah, Xinlei Chen, Marcus Rohrbach, and Devi Parikh. Cycle-consistency for robust visual question answering. In 2019 Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
+
+Samarth Sinha and Adji B Dieng. Consistency regularization for variational auto-encoders. arXiv preprint arXiv:2105.14859, 2021.
+
+Kihyuk Sohn, David Berthelot, Chun-Liang Li, Zizhao Zhang, Nicholas Carlini, Ekin D Cubuk, Alex Kurakin, Han Zhang, and Colin Raffel. Fixmatch: Simplifying semi-supervised learning with consistency and confidence. arXiv preprint arXiv:2001.07685, 2020.
+
+Baochen Sun and Kate Saenko. Deep CORAL: Correlation alignment for deep domain adaptation. In European conference on computer vision, pp. 443–450. Springer, 2016.
+
+Christopher Tensmeyer and Tony Martinez. Improving invariance and equivariance properties of convolutional neural networks. 2016.
+
+Hemanth Venkateswara, Jose Eusebio, Shayok Chakraborty, and Sethuraman Panchanathan. Deep hashing network for unsupervised domain adaptation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 5018–5027, 2017.
+
+Riccardo Volpi, Hongseok Namkoong, Ozan Sener, John Duchi, Vittorio Murino, and Silvio Savarese. Generalizing to unseen domains via adversarial data augmentation. arXiv preprint arXiv:1805.12018, 2018.
+
+Julius von Kügelgen, Yash Sharma, Luigi Gresele, Wieland Brendel, Bernhard Schölkopf, Michel Besserve, and Francesco Locatello. Self-supervised learning with data augmentations provably isolates content from style. arXiv preprint arXiv:2106.04619, 2021.
+
+Chien-Sheng Wu, Andrea Madotto, Ehsan Hosseini-Asl, Caiming Xiong, Richard Socher, and Pascale Fung. Transferable multi-domain state generator for task-oriented dialogue systems, 2019.
+
+Qizhe Xie, Minh-Thang Luong, Eduard Hovy, and Quoc V Le. Self-training with noisy student improves imagenet classification. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10687–10698, 2020.
+
+Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 6023���6032, 2019.
+
+Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Russ R Salakhutdinov, and Alexander J Smola. Deep sets. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems, 2017.
+
+Xiaoxue Zang, Abhinav Rastogi, Srinivas Sunkara, Raghav Gupta, Jianguo Zhang, and Jindong Chen. Multiwoz $2 . 2 : \mathrm { A }$ dialogue dataset with additional annotation corrections and state tracking baselines, 2020.
+
+Hongyang Zhang, Yaodong Yu, Jiantao Jiao, Eric Xing, Laurent El Ghaoui, and Michael Jordan. Theoretically principled trade-off between robustness and accuracy. In International Conference on Machine Learning, 2019.
+
+Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017.
+
+Haizhong Zheng, Ziqi Zhang, Juncheng Gu, Honglak Lee, and Atul Prakash. Efficient adversarial training with transferable adversarial examples. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.
+
+Kaiyang Zhou, Yongxin Yang, Timothy Hospedales, and Tao Xiang. Deep domain-adversarial image generation for domain generalisation. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pp. 13025–13032, 2020.
+
+# A PROOFS
+
+Proof of Proposition 1. First let us present the DA-ERM solution:
+
+$$
+\begin{array} { r l } { f _ { \mathrm { D A \cdot E B M } } ( w ) = \mathbb { E } \left[ ( w _ { 1 } x + w _ { 2 } y - y ) ^ { 2 } + ( w _ { 1 } x + w _ { 2 } ( a y + n ) - y ) ^ { 2 } \right] } \\ & { = \mathbb { E } \left[ w _ { 1 } ^ { 2 } x ^ { 2 } + ( w _ { 2 } - 1 ) ^ { 2 } y ^ { 2 } + 2 w _ { 1 } ( w _ { 2 } - 1 ) x y \right] } \\ & { \quad + \mathbb { E } \left[ w _ { 1 } ^ { 2 } x ^ { 2 } + ( w _ { 2 } a - 1 ) ^ { 2 } y ^ { 2 } + w _ { 2 } ^ { 2 } n ^ { 2 } \right] } \\ & { \quad + \mathbb { E } \left[ 2 w _ { 1 } ( w _ { 2 } a - 1 ) x y + 2 w _ { 1 } w _ { 2 } x n + 2 w _ { 2 } ( w _ { 2 } a - 1 ) y n \right] } \\ & { = w _ { 1 } ^ { 2 } \sigma _ { x } ^ { 2 } + ( w _ { 2 } - 1 ) ^ { 2 } ( \sigma _ { x } ^ { 2 } + \sigma _ { \varepsilon } ^ { 2 } ) + 2 w _ { 1 } ( w _ { 2 } - 1 ) \sigma _ { x } ^ { 2 } } \\ & { \quad + w _ { 1 } ^ { 2 } \sigma _ { x } ^ { 2 } + ( w _ { 2 } a - 1 ) ^ { 2 } ( \sigma _ { x } ^ { 2 } + \sigma _ { \varepsilon } ^ { 2 } ) + w _ { 2 } ^ { 2 } \sigma _ { n } ^ { 2 } } \\ & { \quad + 2 w _ { 1 } ( w _ { 2 a } - 1 ) \sigma _ { x } ^ { 2 } } \\ & { = ( w _ { 1 } + w _ { 2 } - 1 ) ^ { 2 } \sigma _ { x } ^ { 2 } + ( w _ { 2 } - 1 ) ^ { 2 } \sigma _ { \varepsilon } ^ { 2 } } \\ & { \quad + ( w _ { 1 } + w _ { 2 } a - 1 ) ^ { 2 } \sigma _ { x } ^ { 2 } + ( w _ { 2 } a - 1 ) ^ { 2 } \sigma _ { \varepsilon } ^ { 2 } + w _ { 2 } ^ { 2 } \sigma _ { n } ^ { 2 } . } \end{array}
+$$
+
+Hence, the solution of $w _ { \mathrm { D A - E R M } } ^ { \star } = \arg \operatorname* { m i n } _ { w }$ fDA-ERM(w) is given by
+
+$$
+\begin{array} { r l r } & { } & { 2 w _ { 1 } ^ { \star } + ( 1 + a ) w _ { 2 } ^ { \star } - 2 = 0 , } \\ & { } & { ( w _ { 1 } ^ { \star } + w _ { 2 } ^ { \star } - 1 ) \sigma _ { x } ^ { 2 } + ( w _ { 2 } ^ { \star } - 1 ) \sigma _ { \varepsilon } ^ { 2 } + a ( w _ { 1 } ^ { \star } + w _ { 2 } ^ { \star } a - 1 ) \sigma _ { x } ^ { 2 } + a ( w _ { 2 } ^ { \star } a - 1 ) \sigma _ { \varepsilon } ^ { 2 } + w _ { 2 } ^ { \star } \sigma _ { n } ^ { 2 } = 0 . } \end{array}
+$$
+
+Subsequently,
+
+$$
+w _ { \mathrm { D A - E R M } } ^ { \star } = \left( \begin{array} { c } { \frac { a ^ { 2 } ( \sigma _ { x } ^ { 2 } + \sigma _ { \varepsilon } ^ { 2 } ) - 2 a ( \sigma _ { x } ^ { 2 } + \sigma _ { \varepsilon } ^ { 2 } ) + \sigma _ { x } ^ { 2 } + \sigma _ { \varepsilon } ^ { 2 } + 2 \sigma _ { n } ^ { 2 } } { a ^ { 2 } ( \sigma _ { x } ^ { 2 } + 2 \sigma _ { \varepsilon } ^ { 2 } ) - 2 a \sigma _ { x } ^ { 2 } + \sigma _ { x } + 2 ( \sigma _ { \varepsilon } ^ { 2 } + \sigma _ { n } ^ { 2 } ) } } \\ { \frac { 2 ( a + 1 ) \sigma _ { \varepsilon } ^ { 2 } } { a ^ { 2 } ( \sigma _ { x } ^ { 2 } + 2 \sigma _ { \varepsilon } ^ { 2 } ) - 2 a \sigma _ { x } ^ { 2 } + \sigma _ { x } ^ { 2 } + 2 ( \sigma _ { \varepsilon } ^ { 2 } + \sigma _ { n } ^ { 2 } ) } } \end{array} \right) .
+$$
+
+$$
+\begin{array} { r l } & { w _ { \mathrm { D A I R } } ^ { \star } = \arg \underset { w } { \operatorname* { m i n } } f _ { \mathrm { D A I R } } ( w ) } \\ & { \qquad = \arg \underset { w } { \operatorname* { m i n } } \mathbb { E } \left[ ( w _ { 1 } x + w _ { 2 } y - y ) ^ { 2 } + ( w _ { 1 } x + w _ { 2 } ( a y + n ) - y ) ^ { 2 } \right] } \\ & { \qquad + \left[ \lambda ( | w _ { 1 } x + w _ { 2 } y - y | - | w _ { 1 } x + w _ { 2 } ( a y + n ) - y | ) ^ { 2 } \right] . } \end{array}
+$$
+
+When $\lambda \to \infty$ , we have $w _ { \mathrm { D A I R } , 2 } ^ { \star } = 0$ and hence:
+
+$$
+\boldsymbol { w _ { \mathrm { D A I R } } ^ { \star } } = \left( \begin{array} { l } { 1 } \\ { 0 } \end{array} \right) .
+$$
+
+We then evaluate the testing loss assuming the spurious feature is absent, i.e., ${ \bf x } _ { \mathrm { t e s t } } = ( x , s = 0 )$
+
+$$
+\begin{array} { r l } & { \ell _ { \mathrm { D A I R } } ( \mathbf { x } _ { \mathrm { t e s t } } ; \boldsymbol { w } _ { \mathrm { D A I R } } ^ { \star } ) = \mathbb { E } \left[ ( { \boldsymbol w } _ { \mathrm { D A I R } } ^ { \star } { \boldsymbol \mathsf { T } } _ { \mathbf { x } _ { \mathrm { t e s t } } } - y ) ^ { 2 } \right] } \\ & { \qquad = \mathbb { E } \left[ ( x - ( x + \varepsilon ) ) ^ { 2 } \right] } \\ & { \qquad = \sigma _ { \varepsilon } ^ { 2 } . } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { \ell _ { \mathrm { D A \cdot E R M } } ( \mathbf { x } _ { \mathrm { t e s t } } ; w _ { \mathrm { D A \cdot E R M } } ^ { \star } ) = \mathbb { E } \left[ \big ( w _ { \mathrm { D A \cdot E R M } } ^ { \star } \mathsf { T } _ { \mathbf { x } _ { \mathrm { t e s t } } } - y \big ) ^ { 2 } \right] } \\ & { \phantom { \ell _ { \mathrm { D A \cdot E R M } } } = \mathbb { E } \left[ \left( \frac { a ^ { 2 } ( \sigma _ { x } ^ { 2 } + \sigma _ { \varepsilon } ^ { 2 } ) - 2 a ( \sigma _ { x } ^ { 2 } + \sigma _ { \varepsilon } ^ { 2 } ) + \sigma _ { x } ^ { 2 } + \sigma _ { \varepsilon } ^ { 2 } + 2 \sigma _ { n } ^ { 2 } } { a ^ { 2 } ( \sigma _ { x } ^ { 2 } + 2 \sigma _ { \varepsilon } ^ { 2 } ) - 2 a \sigma _ { x } ^ { 2 } + \sigma _ { x } + 2 ( \sigma _ { \varepsilon } ^ { 2 } + \sigma _ { n } ^ { 2 } ) } x - ( x + \varepsilon ) \right) ^ { 2 } \right] } \\ & { \phantom { \ell _ { \mathrm { D A \cdot E R M } } } = \sigma _ { \varepsilon } ^ { 2 } + \frac { \left( a + 1 \right) ^ { 4 } \sigma _ { \varepsilon } ^ { 4 } \sigma _ { x } ^ { 2 } } { \left( a ^ { 2 } ( \sigma _ { x } ^ { 2 } + 2 \sigma _ { \varepsilon } ^ { 2 } ) - 2 a \sigma _ { x } ^ { 2 } + \sigma _ { x } + 2 ( \sigma _ { \varepsilon } ^ { 2 } + \sigma _ { n } ^ { 2 } ) \right) ^ { 2 } } } \\ & { \phantom { \ell _ { \mathrm { D A \cdot E R } } } \geq \ell _ { \mathrm { D A \cdot } } } \end{array}
+$$
+
+Proposition 2. It is not hard to check that even using the weight decay regularizer $\scriptstyle { \frac { \gamma } { 2 } } \left( w _ { 1 } ^ { 2 } + w _ { 2 } ^ { 2 } \right)$ would not close the gap between the performance of DA-ERM and DAIR. In particular, this regularizer would result in
+
+$$
+w _ { D A . E R M . W D } ^ { \star } = \left( \begin{array} { c } { { \frac { a ^ { 2 } ( \sigma _ { \varepsilon } ^ { 2 } + \sigma _ { x } ^ { 2 } ) - 2 a ( \sigma _ { \varepsilon } ^ { 2 } + \sigma _ { x } ^ { 2 } ) + 2 \gamma + \sigma _ { \varepsilon } ^ { 2 } + 2 \sigma _ { n } ^ { 2 } + \sigma _ { x } ^ { 2 } } { a ^ { 2 } ( \gamma ( \sigma _ { \varepsilon } ^ { 2 } + \sigma _ { x } ^ { 2 } ) + 2 \sigma _ { \varepsilon } ^ { 2 } + \sigma _ { x } ^ { 2 } ) - 2 a \sigma _ { x } ^ { 2 } + \gamma ^ { 2 } + \gamma ( \sigma _ { \varepsilon } ^ { 2 } + \sigma _ { n } ^ { 2 } + \sigma _ { x } ^ { 2 } + 2 ) + 2 \sigma _ { \varepsilon } ^ { 2 } + 2 \sigma _ { n } ^ { 2 } + \sigma _ { x } ^ { 2 } } } } \\ { { } } \\ { { \frac { ( a + 1 ) ( \gamma ( \sigma _ { \varepsilon } ^ { 2 } + \sigma _ { x } ^ { 2 } ) + 2 \sigma _ { \varepsilon } ^ { 2 } ) } { a ^ { 2 } ( \gamma ( \sigma _ { \varepsilon } ^ { 2 } + \sigma _ { x } ^ { 2 } ) + 2 \sigma _ { \varepsilon } ^ { 2 } + \sigma _ { x } ^ { 2 } ) - 2 a \sigma _ { x } ^ { 2 } + \gamma ^ { 2 } + \gamma ( \sigma _ { \varepsilon } ^ { 2 } + \sigma _ { n } ^ { 2 } + \sigma _ { x } ^ { 2 } + 2 ) + 2 \sigma _ { \varepsilon } ^ { 2 } + 2 \sigma _ { n } ^ { 2 } + \sigma _ { x } ^ { 2 } } } } \end{array} \right) ,
+$$
+
+which is not equal to $w ^ { \star } = ( 1 , 0 )$ unless $\sigma _ { n } ^ { 2 } \to \infty$ and $\gamma = 0$ .
+
+Proof of Proposition 2. The proof follows the same idea of Proposition 1 and therefore it is omitted here.
+
+Proof of Lemma 1. We proceed as follows:
+
+$$
+\begin{array} { r } { \mathcal { R } _ { 1 } ( z , \widetilde { z } ; \theta ) - \mathcal { R } _ { \mathrm { s q } } ( z , \widetilde { z } ; \theta ) = 2 \sqrt { \operatorname* { m i n } \{ \ell ( z ; \theta ) , \ell ( \widetilde { z } ; \theta ) \} } \left| \sqrt { \ell ( \widetilde { z } ; \theta ) } - \sqrt { \ell ( z ; \theta ) } \right| , } \end{array}
+$$
+
+We break it into two cases: if $\ell ( \tilde { z } ; \theta ) > \ell ( z ; \theta )$ :
+
+$$
+\begin{array} { r l } & { \mathcal { R } _ { 1 } ( z , \widetilde { z } ; \theta ) - \mathcal { R } _ { \mathrm { s q } } ( z , \widetilde { z } ; \theta ) = \ell ( \widetilde { z } ; \theta ) - \ell ( z ; \theta ) - ( \sqrt { \ell ( \widetilde { z } ; \theta ) } - \sqrt { \ell ( z ; \theta ) } ) ^ { 2 } } \\ & { \qquad = \ell ( \widetilde { z } ; \theta ) - \ell ( z ; \theta ) - \ell ( \widetilde { z } ; \theta ) - \ell ( z ; \theta ) + 2 \sqrt { \ell ( \widetilde { z } ; \theta ) } \sqrt { \ell ( z ; \theta ) } } \\ & { \qquad = - 2 \ell ( z ; \theta ) + 2 \sqrt { \ell ( \widetilde { z } ; \theta ) } \sqrt { \ell ( z ; \theta ) } } \\ & { \qquad = 2 \sqrt { \ell ( z ; \theta ) } ( \sqrt { \ell ( \widetilde { z } ; \theta ) } - \sqrt { \ell ( z ; \theta ) } ) . } \end{array}
+$$
+
+If $\ell ( \tilde { z } ; \theta ) \leq \ell ( z ; \theta )$ :
+
+$$
+\begin{array} { r l } & { \mathcal { R } _ { 1 } ( z , \widetilde { z } ; \theta ) - \mathcal { R } _ { \mathrm { s q } } ( z , \widetilde { z } ; \theta ) = \ell ( z ; \theta ) - \ell ( \widetilde { z } ; \theta ) - ( \sqrt { \ell ( \widetilde { z } ; \theta ) } - \sqrt { \ell ( z ; \theta ) } ) ^ { 2 } } \\ & { \qquad = \ell ( z ; \theta ) - \ell ( \widetilde { z } ; \theta ) - \ell ( \widetilde { z } ; \theta ) - \ell ( z ; \theta ) + 2 \sqrt { \ell ( \widetilde { z } ; \theta ) } \sqrt { \ell ( z ; \theta ) } } \\ & { \qquad = - 2 \ell ( \widetilde { z } ; \theta ) + 2 \sqrt { \ell ( \widetilde { z } ; \theta ) } \sqrt { \ell ( z ; \theta ) } } \\ & { \qquad = 2 \sqrt { \ell ( \widetilde { z } ; \theta ) } ( \sqrt { \ell ( z ; \theta ) } - \sqrt { \ell ( \widetilde { z } ; \theta ) } ) . } \end{array}
+$$
+
+If we combine the two cases, we have:
+
+$$
+\mathcal { R } _ { 1 } ( z , \widetilde { z } ; \theta ) - \mathcal { R } _ { \mathrm { s q } } ( z , \widetilde { z } ; \theta ) = 2 \sqrt { \operatorname* { m i n } \{ \ell ( z ; \theta ) , \ell ( \widetilde { z } ; \theta ) \} } \left| \sqrt { \ell ( \widetilde { z } ; \theta ) } - \sqrt { \ell ( z ; \theta ) } \right| .
+$$
+
+# B PRACTICAL CONSIDERATIONS WHEN DAIR IS USED IN TRAINING
+
+In this section, we investigate the reason why we see a sweet spot for the performance of DAIR-SQ as a function of $\lambda$ . As shown in Figure 2, we see a sweet spot for $\lambda$ , where the performance takes its maximum and starts to decrease for larger values of $\lambda$ . There are a few explanations for this performance degradation.
+
+1. It is observed that a large $\lambda$ requires a relatively longer time for convergence. To show empirically this is true, we added another example in Appendix B.1. Theoretically, this is in line with the classical results in the optimization literature where larger Lipschitz constants (resulting from adding a regularizer) slows down the convergence rate. Thus, as we are training all models for a certain number of epochs, we will end up with underfitting.   
+2. A larger $\lambda$ is more likely to guide the optimization trajectory towards a spurious poor local minimum with poor generalization performance, when the optimization trajectory is non-convex. We have experimentally verified this in Section 2.3 (Figure 6) as the reason for the poor performance of DAIR-L1 in Figure 2.   
+3. With a finite number of samples our regularizer does not necessarily lead to the best possible performance in the infinite sample setting (with weak domain shift). Hence, we might expect to observe the classical approximation-estimation tradeoff. This is especially true in real-world scenarios where one might expect that the difficulty of the example may not necessarily be preserved through data augmentation, and hence forcing the loss to be equal on both samples might be detrimental to the overall performance, which may lead to a practical sweet spot for $\lambda$ .
+
+We dig into the experiment in Figure 2 specifically and try to understand which case is the responsible for the sweet spot in Figure 2. We extend the number of training epochs from 40 to 160, and report the accuracy for $\lambda \in \{ \bar { 1 . 4 3 } , 8 . 8 5 , 1 6 . 2 3 , 1 0 0 \}$ .1 Table 5 suggests that, when we increase the number of training epochs, the sweet spot of $\lambda$ moves from 8.85 to 16.23 and in fact we can achieve an even better performing model with accuracy 89.22 as compared to the previously reported 85.89, while the performance does not change much for the smaller values of $\lambda$ . We also observe a big performance boost for larger values of $\lambda$ . This suggests that in this experiment the sweet spot for $\lambda$ is caused by capping the training epochs to a finite value. Having said that, we believe that we are practically interested in using DAIR with marginal computational overhead over ERM and hence we would expect to observe such sweet spot in performance in practice as $\lambda \to \infty$ .
+
+<table><tr><td>入</td><td>Acc at Epoch 40</td><td>Acc at Epoch 160</td></tr><tr><td>1.43</td><td>79.09</td><td>80.19</td></tr><tr><td>8.85</td><td>85.89</td><td>86.60</td></tr><tr><td>16.23</td><td>82.66</td><td>89.22</td></tr><tr><td>100</td><td>46.95</td><td>69.37</td></tr></table>
+
+Table 5: Testing accuracy of Rotated MNIST, Weak Augmentaion. We see the accuracy increases as we extend the number of training epochs.
+
+B.1 ADDITIONAL EVIDENCE ON GROWING COST OF TRAINING WITH THE REGULARIZATION STRENGTH
+
+We also provide further evidence for the growing cost of training with $\lambda$ on a toy problem where we can reliably measure the gradient norm and ensure convergence. We study the following simple binary logistic classification problem which mirrors the MNIST experiments: at the training time the input is $\bar { \mathbf { x } } _ { \mathrm { t r a i n } } = ( x , s = 2 y \bar { - 1 } + t _ { 1 } )$ and the label $y$ , i.e., $z _ { \mathrm { t r a i n } } = ( { \bf x } _ { \mathrm { t r a i n } } , y )$ . Here, $x \sim \mathsf { \bar N } ( 0 , \sigma _ { x } ^ { 2 } )$ , and $\begin{array} { r } { P ( y = 1 | x ) = \frac { 1 } { 1 + e ^ { - x } } } \end{array}$ , where $t _ { 1 }$ is independent of $x$ and $t _ { 1 } \sim \mathcal { N } ( 0 , \sigma _ { 1 } ^ { 2 } )$ . In this example, we intentionally provide feature $s$ which is highly correlated with the label during training. Again, clearly, $w ^ { \star } \dot { = } ( 1 , 0 ) ^ { \top }$ , but $w _ { \mathrm { E R M } } ^ { \star }$ will converge to $( 0 , 1 ) ^ { \top }$ due to the overfitting to the spurious feature. We introduce an augmenter which generates the augmented example such as $\mathbf { x } _ { \mathrm { a u g } } = ( x , s =$ $2 y - 1 + t _ { 1 } + t _ { 2 } )$ where $t _ { 2 } \sim \mathcal { N } ( 0 , \sigma _ { 2 } ^ { 2 } )$ . We use this data augmenter for DAIR training and test on ${ \bf x } _ { \mathrm { t e s t } } = ( x , s = 1 - 2 y )$ . We summarize the steps need for convergences and the testing accuracy in Table 6 as well. We can find that the required number of iteration to convergence increases as $\lambda$ increase.
+
+For this tiny toy example, there is a factor of $1 0 \mathrm { x }$ increase in the required number of iterations when $\lambda$ is chosen to be 10,000 as opposed to 0.5. Note that this is using ADAM and the gap is significantly larger if we use vanilla gradient descent; as we were not able to even converge in $\bar { 1 0 ^ { 8 } }$ steps. This is provided as further evidence for the practical sweet spot for DAIR as $\lambda \to \infty$ .
+
+<table><tr><td>入</td><td>Iterations to Converge</td></tr><tr><td>0.5</td><td>81.35 ± 6.07</td></tr><tr><td>1</td><td>91.05 ± 2.53</td></tr><tr><td>2</td><td>89.10 ± 2.41</td></tr><tr><td>5</td><td>101.65 ± 2.87</td></tr><tr><td>10</td><td>107.70 ± 5.77</td></tr><tr><td>100</td><td>151.75 ± 4.28</td></tr><tr><td>1,000</td><td>195.85 ± 4.54</td></tr><tr><td>10,000</td><td>802.60 ± 7.58</td></tr></table>
+
+Table 6: Iteration needed for the logistic model to converge with different $\lambda$ . The model is converged when the $\mathcal { L } _ { 2 }$ norm of the gradient is less than $\mathrm { 1 0 ^ { - 7 } }$ .
+
+# C MODEL ARCHITECTURE AND TRAINING PARAMETERS FOR MNIST EXPERIMENTS
+
+We use a Convolutional Neural Network (CNN) with three convolutional layers followed by two fully connected layers. The last layer output size for Colored MNIST experiments is set to 1, and 10 for the Rotated MNIST experiments. For training we follow a two stage schedule with a learning rate of 0.005 for the first 20 epochs and a learning rate of 0.0005 for the next 20. We choose a batch size of 64 for all experiments. The architectural details and training parameters can be found in Table 7 and Table 8.
+
+Table 7: Model Architecture, $C = 1$ for Colored MNIST and $C = 1 0$ for Rotated MNIST.   
+
+<table><tr><td>Layer Type</td><td>Shape</td></tr><tr><td>Convolution + ReLU</td><td>4×4×6</td></tr><tr><td>Max Pooling</td><td>2×2</td></tr><tr><td>Convolution +ReLU</td><td>4×4×16</td></tr><tr><td>Max Pooling</td><td>2×2</td></tr><tr><td>Convolution + ReLU</td><td>4×4×96</td></tr><tr><td>Fully Connected +ReLU</td><td>64</td></tr><tr><td>Fully Connected</td><td>C</td></tr></table>
+
+Table 8: Training parameter of MNIST experiments.   
+
+<table><tr><td colspan="2">Parameter</td></tr><tr><td>Learning Rate</td><td>0.005 0.0005</td></tr><tr><td>Epochs</td><td>First 20 Second 20</td></tr><tr><td>Batch-size</td><td>64</td></tr></table>
+
+# D COLORED MNIST & ROTATED MNIST SETUP
+
+We apply the proposed loss function (DAIR) on the following two datasets: Colored MNIST and Rotated MNIST. We compare the performance of DAIR with plain data augmentation, and invariant risk minimization (IRM) as a strong baseline. One crucial difference between our work and IRM is is the motivation. IRM is designed to take two examples from two different environments and learn representations that are invariant to the environment, e.g., in cases where we are aggregating multiple datasets. On the other hand, we are interested in promoting invariance when we have a single dataset. As such, we artificially generate the second environment in IRM using data augmentation. For a given example $z$ , we design an augmenter $A ( \cdot )$ and use it to generate additional samples that adhere to the invariance we have in mind. Hence, IRM will be applied in the same way that examples from different environments are augmenting pairs.
+
+Our Colored MNIST is an extension of the original Colored MNIST Arjovsky et al. (2019). The label is a noisy function of both digit and color. The digit has a correlation of 0.75 with the label and a certain correlation with the label depending on the color scheme. Besides the two colors in the original dateset, we introduce fully random colored scheme to the dateset, which is the best augmenter one can think of. The three color schemes are detailed in Table 9.
+
+Our Rotated MNIST is a variant of the original Rotated MNIST (Ghifary et al., 2015). The original dataset contains images of digits rotated $d$ degrees, where $d \in \mathcal { D } \triangleq \{ 0 , 1 5 , 3 0 , 4 5 , 6 0 , 7 5 \}$ . Similarly, we introduce the random degree scheme here to serve as the best possible augmenter. To further exploit the potential of the proposed algorithm, we make this dataset more difficult by introducing more challenging degree scheme; The rotation schemes are summarized in Table 10.
+
+Note all the augmented images are generated on the fly. Examples of images from some transformation schemes are shown in Figures 9 to 14.
+
+Table 9: Color schemes in Colored MNIST. Random color means that the value of each channel of the image is uniformly random chosen from 0 to 255.   
+
+<table><tr><td>Scheme</td><td>2</td><td>Color丨y = 0</td></tr><tr><td>C1</td><td>with p = 0.8, z = y with p = 0.2, z =1- y</td><td>Red Green</td></tr><tr><td>C2</td><td>with p = 0.9, z = y with p = 0.1, z =1- y</td><td>Red Green</td></tr><tr><td>C3</td><td>with p = 0.1, z = y</td><td>Red</td></tr><tr><td>C4</td><td>with p =0.9,z =1- y z=2</td><td>Green Random</td></tr></table>
+
+Table 10: Rotation schemes in Rotated MNIST. $[ a , b ]$ means that degrees are unformly random chosen between $a$ and $^ { b }$ .   
+
+<table><tr><td>Scheme</td><td>Rotation</td></tr><tr><td>R1</td><td>0°</td></tr><tr><td>R2</td><td>90°</td></tr><tr><td>R3</td><td>0°,180°</td></tr><tr><td>R4</td><td>90°,270°</td></tr><tr><td>R5</td><td>[0°,360°]</td></tr><tr><td>R6</td><td>[22.5°,67.5°],[202.5°,247.5°]</td></tr></table>
+
+Table 11: Training procedure of Colored MNIST.   
+
+<table><tr><td>Setup Name</td><td>Train</td><td>Aug</td><td>Test</td><td>入</td></tr><tr><td>Adv. Aug.</td><td>C1</td><td>C2</td><td>C3</td><td>1000</td></tr><tr><td>Rnd. Aug.</td><td>C1</td><td>C4</td><td>C3</td><td>100</td></tr></table>
+
+Table 12: Training procedure of Rotated MNIST   
+
+<table><tr><td>Setup</td><td>Train</td><td>Aug</td><td>Test</td><td>入</td></tr><tr><td> Strong Aug.</td><td>R1</td><td>R5</td><td>R2</td><td>1</td></tr><tr><td>Weak Aug.</td><td>R4</td><td>R6</td><td>R3</td><td>10</td></tr></table>
+
+![](images/7c3eea9e5df87a855fe1867e7772ee5a9548d0a35e4bd2c67d761633059def3e.jpg)  
+Figure 9:   
+C2 Figure 10: C3   
+Figure 11: C4   
+Figure 12: R4   
+Figure 13: R5 Figure 14: R6
+
+Setup: We train a model consisted of three convolutional layers and two fully connected layers with 20,000 examples. For each dataset we are defining several different schemes on how the dataset could be modified: Table 9 (Colored MNIST) and Table 10 (Rotated MNIST). Then, we define several setups. Each setup is consisted of one original dataset, one augmentation dataset, and one test dataset, each of which is selected among the defined schemes. These setups are provided in Table 11 (Colored MNIST) and Table 12 (Rotated MNIST). For each setup, we train the model with the following four algorithms and compare their performances: ERM, DA-ERM, DAIR and Invariant Risk Minimization (IRM). Each experiment is repeated for 10 times; the mean and the standard derivation are reported. The value of $\lambda$ are chosen base on the validation results. Detailed architectures and training parameters can be found in Appendix C.
+
+# D.1 COLORED MNIST
+
+We conduct two sets of experiments for this dataset: Adversarial Augmentation Setup (Table 11) follows the exact same color schemes from the original Colored MNIST Arjovsky et al. (2019). For Random Augmentation Setup, we train the model with the strongest possible augmenter: uniformly random color. The entire procedure is summarized in Table 11.
+
+# D.2 ROTATED MNIST
+
+We start with the strongest augmenter case. One may notice that there is a chance that the augmented images bear the same rotation degrees as the testing set. To make the task more difficult, we will use R6 as the augmented test to test how the trained model generalize to entirely unseen domain. The training procedure is summarized in Table 12.
+
+# E ADDITIONAL RESULTS ON COLORED MNIST & ROTATED MNIST
+
+# E.1 COLORED MNIST
+
+We show additional results on Colored MNIST and Rotated MNIST in Tables 13 and 14. Note that each algorithm has been tuned for best performance. As mentioned in Section 2.2, DAIR outperforms DA-ERM, ERM and other baseline models on classification accuracy. For accuracy consistency, we use the training scheme as the original scheme and the testing scheme as the augmentation scheme. We further compare DAIR with IRM (Arjovsky et al., 2019), DRO (Sagawa et al., 2019), and REx (Krueger et al., 2021). In doing so, we feed all original examples as one environment and all augmented examples as a second environment to these baselines. While we can see that DAIR outperforms all baselines, we caution that the comparison may not be fair in that DAIR exploits pairing information between original and augmented samples, which is not used by the other baselines.
+
+Table 13: Accuracy and Accuracy Consistency Metric (CM) on Colored MNIST with Adversarial Augmentation.   
+
+<table><tr><td>Algorithm</td><td>Accuracy</td><td>CM</td></tr><tr><td>ERM</td><td>32.70± 0.45</td><td>77.76 ± 1.01</td></tr><tr><td>DA-ERM</td><td>40.91 ± 0.45</td><td>84.60 ±0.60</td></tr><tr><td>DAIR</td><td>72.58 ± 0.11</td><td>99.39 ±0.11</td></tr><tr><td>IRM (Arjovsky et al., 2019)</td><td>66.90</td><td>1</td></tr><tr><td>DRO (Sagawa et al., 2019)</td><td>37.40</td><td></td></tr><tr><td>REx (Krueger et al., 2021)</td><td>68.70</td><td></td></tr></table>
+
+<table><tr><td>Algorithm</td><td>Accuracy</td><td>CM</td></tr><tr><td>ERM</td><td>32.70 ± 0.45</td><td>63.50 ± 1.92</td></tr><tr><td>DA-ERM</td><td>29.61 ±0.80</td><td>88.15 ± 0.18</td></tr><tr><td>DAIR</td><td>73.10 ± 0.12</td><td>99.88 ± 0.01</td></tr></table>
+
+Table 14: Accuracy and Accuracy Consistency Metric (CM) on Colored MNIST with Random Augmentation.
+
+# E.2 ROTATED MNIST
+
+We report the accuracy consistency on Rotated MNIST (weak augmentation) in Table 15. The original training scheme here is Scheme R4 (Table 10), i.e., $9 0 ^ { \circ }$ and $2 7 0 ^ { \circ }$ rotated images, and the augmentation scheme for training is R6 (weak rotation). At test time, we test with R1 (no rotation) and we also use the augmentation scheme of $1 8 0 ^ { \circ }$ rotation to test the accuracy consistency metric. Note that neither the un-rotated or $1 8 0 ^ { \circ }$ rotated images have been observed at training time. Hence, the setup is difficult for ERM which struggles to generalize. As can be seen, since the digit 0 is “almost” circularly symmetric, ERM actually does a decent job at classifying 0, however it significantly struggles with all other digits. We see that DAIR outperforms ERM and DA-ERM by a large margin. We observe that digits 6 and 9 are challenging to get right (as one would expect for them to be difficult to tell apart). While we see $2 - 3 \%$ drop on the consistency for digits 6 and 9 (when rotating them by $1 8 0 ^ { \circ }$ ), the drop is smaller than expected perhaps due to the fact that the neural network learns to classify these digits based on features that are harder to get for humans.
+
+<table><tr><td rowspan="2">Digit</td><td colspan="2">ERM</td><td colspan="2">DA-ERM</td><td colspan="2">DAIR</td></tr><tr><td>Acc.</td><td>CM</td><td>Acc.</td><td>CM</td><td>Acc.</td><td>CM</td></tr><tr><td>0</td><td>86.19 ± 01.48</td><td>94.95 ± 01.53</td><td>95.61 ± 00.66</td><td>98.43 ± 00.21</td><td>98.44± 00.07</td><td>99.31 ± 00.15</td></tr><tr><td>1</td><td>00.15 ±00.08</td><td>11.11 ± 11.11</td><td>82.79 ± 03.38</td><td>98.54± 00.43</td><td>96.09 ± 00.71</td><td>97.59 ± 01.28</td></tr><tr><td>2</td><td>29.84± 00.51</td><td>57.91 ± 02.76</td><td>76.68 ± 03.54</td><td>82.70± 03.27</td><td>86.21 ± 00.82</td><td>93.21 ± 01.32</td></tr><tr><td>3</td><td>00.63 ± 00.53</td><td>76.47 ± 23.53</td><td>78.84± 02.60</td><td>89.24 ± 01.26</td><td>86.60 ± 02.24</td><td>94.26 ± 00.36</td></tr><tr><td>4</td><td>01.97 ± 00.90</td><td>23.38 ± 13.49</td><td>51.09 ± 03.30</td><td>78.15 ± 02.73</td><td>79.67 ± 01.26</td><td>92.42 ± 00.41</td></tr><tr><td>5</td><td>05.53 ± 00.32</td><td>39.91 ± 04.59</td><td>65.02 ± 02.42</td><td>84.68 ± 03.71</td><td>83.26 ± 02.51</td><td>95.11 ± 01.46</td></tr><tr><td>6</td><td>00.66 ± 00.37</td><td>51.79 ± 25.13</td><td>67.43 ± 03.82</td><td>83.41 ± 05.74</td><td>84.79 ± 01.17</td><td>92.78 ± 01.71</td></tr><tr><td>7</td><td>16.67 ± 02.75</td><td>18.28 ± 06.65</td><td>56.29 ± 07.26</td><td>81.67 ± 06.90</td><td>78.11 ± 02.10</td><td>95.03 ± 01.21</td></tr><tr><td>8</td><td>10.92 ± 05.47</td><td>22.54 ± 05.46</td><td>74.50 ± 01.10</td><td>89.12 ± 01.69</td><td>90.55 ± 01.13</td><td>95.35 ± 00.47</td></tr><tr><td>9</td><td>17.08 ± 07.70</td><td>11.56 ± 00.62</td><td>69.54 ± 04.18</td><td>86.78 ± 01.08</td><td>80.84 ± 01.18</td><td>93.21 ± 01.39</td></tr><tr><td>All</td><td>16.85 ± 1.08</td><td>64.14± 2.69</td><td>71.98 ± 1.70</td><td>88.28±0.27</td><td>86.57 ± 0.55</td><td>94.98 ± 0.29</td></tr></table>
+
+Table 15: Rotated MNIST with $9 0 ^ { \circ }$ or $2 7 0 ^ { \circ }$ rotated original images and Weak Augmentation during training. The test scheme is un-rotated original images. Consistency metric (CM) is computed between un-roated images and ones with $1 8 0 ^ { \circ }$ rotation. It can be seen that CM is relatively small for 6 and 9 but the drop is smaller than expected suggesting that CNNs learn from features different from how humans perceive the digits.
+
+# F SETUP AND ADDITIONAL RESULTS FOR VISUAL QUESTION ANSWERING
+
+All the approaches included in this paper use the original VQA v2 ‘train’ split for training, along with the IV-VQA ‘train’ split for augmentation in the DAIR and DA-ERM(Agarwal et al., 2020) settings. The ERM setup (Kazemi & Elqursh, 2017), represents a vanilla SAAA model trained on the VQA v2 ‘train’ split. For the data augmentation methods, if an image from VQA v2 contains its corresponding edited versions in IV-VQA, we randomly select one of them to serve as an augmentation during training. We modify the official code released by Agarwal et al. (2020) to suit our formulation. All the methods are trained for 40 epochs with a learning rate of 0.001 and a batch size of 48. The baseline approaches that we compare with are trained and evaluated by us, using the same training setup as DAIR.
+
+Table 16: Accuracy-Consistency Tradeoff on VQA v2 val and IV-VQA test set controlled by $\lambda$   
+
+<table><tr><td>入</td><td>VQA v2 val (%)</td><td>Predictions flipped (%)</td><td>pos→ neg(%)</td><td>neg→ pos (%)</td><td>neg→ neg (%)</td></tr><tr><td>0.37</td><td>58.52</td><td>11.92</td><td>4.48</td><td>5.28</td><td>2.17</td></tr><tr><td>0.72</td><td>58.21</td><td>11.28</td><td>4.13</td><td>5.08</td><td>2.07</td></tr><tr><td>1.39</td><td>57.54</td><td>10.37</td><td>3.80</td><td>4.65</td><td>1.91</td></tr><tr><td>2.68</td><td>56.24</td><td>9.68</td><td>3.56</td><td>4.39</td><td>1.73</td></tr><tr><td>5.18</td><td>54.19</td><td>8.75</td><td>3.40</td><td>3.66</td><td>1.69</td></tr><tr><td>10</td><td>51.32</td><td>7.94</td><td>3.01</td><td>3.40</td><td>1.53</td></tr></table>
+
+Table 16 indicates a tradeoff between the accuracy on the VQA v2 ‘val’ set and the consistency metrics. As the $\lambda$ value increases, the consistency between the predictions increases, while the accuracy on original examples decreases. For instance, A $\lambda$ value of 10 strongly boosts consistency thus lowering the ‘Predictions flipped’ percentage to only $7 . 9 \%$ but sacrifices the predictive power causing the accuracy to drop to $5 1 . 3 \%$ .
+
+# G DETAILS ON TRAINING ROBUST NEURAL NETWORKS
+
+For all algorithms reported in Table 3, we use Pre-Activation ResNet-18 (He et al., 2016), with a last-layer output size of 10 as the classification model. For training the DAIR model, the adversarial examples are generated by $\mathcal { L } _ { \infty }$ based PGD attack with 11 iterations, $\varepsilon$ (attack strength) set to 8/255 and attack step size to 2/255. We evaluate all the models against the standard FGSM attack and PGD attack with 20 iterations of same perturbation sizes.
+
+# H DETAILS ON NEURAL TASK-ORIENTED DIALOG MODELING
+
+We provide details on the benchmark that we used in this experiment. Qian et al. (2021) proposed a new test set for MultiWOZ 2.2, called MultiWOZ 2.2 with SGD entities, where named entities are replaced with those from Schema Guided Dialog dataset (Rastogi et al., 2020) and showed that SimpleTOD (Hosseini-Asl et al., 2020) endures more than $8 \%$ performance drop on the new test set. Examples from the dataset are shown in Table 18. To address this problem, we define a new data augmentation scheme for DAIR and DA-ERM by replacing the named entities from the MultiWOZ 2.2 training set with randomly scrambled versions of the named entities. For example, “warkworth house” could be turned into “easrtokow hhrwu” (see Table 18). In all of our experiments, we utilize the SimpleTOD model (Hosseini-Asl et al., 2020) and we apply DAIR to enforce invariance between the named entities in the training examples and the scrambled entities from their corresponding augmented samples. The model is trained with ParlAI (Miller et al., 2017) fine-tuned with the pre-trained BART (Lewis et al., 2019). Training hyper-parameters can be found in Table 17.
+
+Table 17: Hyper-parameters used in training SimpleTOD.   
+
+<table><tr><td>Parameter</td><td>Value</td></tr><tr><td>入</td><td>0.5</td></tr><tr><td>Epochs</td><td>4</td></tr><tr><td>Batchsize</td><td>6</td></tr><tr><td>Optimizer</td><td>AdamW</td></tr><tr><td>Learning rate</td><td>10-5</td></tr></table>
+
+<table><tr><td>User:</td><td>can you help me book a reservation at the easr- tokow hhrwu hotel?</td></tr><tr><td>Agent:</td><td>yes i could! how many peo- ple are staying,and what days would fyou like to stay?</td></tr><tr><td>User:</td><td>it&#x27;s just for me,and i&#x27;l be staying for three nights starting from tuesday.</td></tr><tr><td>DS:</td><td>hotel-bookday:tuesday hotel-bookpeople:l hotel-bookstay:3 hotel-name: easrtokow hhrwu</td></tr></table>
+
+<table><tr><td>User:</td><td>can you help me book a reservation at the clarion inn &amp; suites atlanta down- town hotel?</td></tr><tr><td>Agent:</td><td>yes i could! how many peo- ple are staying,and what days would fyou like to stay?</td></tr><tr><td>User:</td><td>it&#x27;s just for me,and ill be staying for three nights starting from tuesday.</td></tr><tr><td>DS:</td><td>hotel-bookday:tuesday hotel-bookpeople:l hotel-bookstay:3</td></tr><tr><td></td><td>hotel-name: clarion inn &amp; suites atlanta downtown</td></tr></table>
+
+Table 18: Left: sample from the original MultiWOZ dataset. Middle: augmented sample generated by scrambling. Right: synthetic sample with name entities from SGD. Comparing left and the middle example, we are generating new named entities (marked in red) by scrambling. Comparing left and the right example, the only difference is the named entity from different dataset, which is marked in red. Note that the SGD named entities are not exposed to the model during training. Only the original named entities and scrambled named entities from MultiWOZ are used during training.   
+
+<table><tr><td>User:</td><td>can you help me book a reservation at the wark- worth house hotel?</td></tr><tr><td>Agent:</td><td>yes i could! how many peo- ple are staying,and what days would fyou like to stay?</td></tr><tr><td>User:</td><td>it&#x27;s just for me,and i&#x27;ll be staying for three nights starting from tuesday.</td></tr><tr><td>DS:</td><td>hotel-bookday:tuesday hotel-bookpeople:1 hotel-bookstay:3 hotel-name: warkworth house</td></tr></table>

parse/dev/QUyasQGv1Nl/QUyasQGv1Nl.md

@@ -0,0 +1,527 @@
+# Hyperbolic Contrastive Learning for Visual Representations beyond Objects
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Despite the rapid progress in visual representation learning driven by self-/un  
+2 supervised methods, both objects and scenes have been primarily treated using the   
+3 same lens. In this paper, we focus on learning representations for objects and scenes   
+4 explicitly in the same space. Motivated by the observation that visually similar   
+5 objects are close in the representation space, we argue that the scenes and objects   
+6 should further follow a hierarchical structure based on their compositionality. To   
+7 exploit such a structure, we propose a contrastive learning framework where a   
+8 Euclidean loss is used to learn object representations and a hyperbolic loss is used to   
+9 regularize scene representations according to the hierarchy. This novel hyperbolic   
+10 objective encourages the scene-object hypernymy among the representations by   
+11 optimizing the magnitude of their norms. We show that when pretraining on   
+12 the COCO and OpenImages datasets, the hyperbolic loss improves downstream   
+13 performance across multiple datasets and tasks, including image classification,   
+14 object detection, and semantic segmentation. We also show that the properties of   
+15 the learned representations allow us to solve various vision tasks that involve the   
+16 interaction between scenes and objects in a zero-shot way.
+
+# 17 1 Introduction
+
+18 Our visual world is diverse and structured. Imagine taking a close-up of a box of cereal in the morning.   
+19 If we zoom out slightly, we may see different nearby objects such as a bowl of milk, a cup of hot   
+20 coffee, today’s newspaper, or reading glasses. Zooming out further, we will probably recognize that   
+21 these items are placed on a dining table with the kitchen as background rather than inside a bathroom.   
+22 Such scene-object structure is diverse, yet not completely random. In this paper, we aim at learning   
+23 visual representations of both the cereal box (objects) and the entire dining table (scenes) in the same   
+24 space while preserving such hierarchical structures.   
+25 Un-/self-supervised learning has become a standard method to learn visual representations [27, 12,   
+26 25, 13, 6, 7, 49]. Although these methods attain superior performance over the supervised pretraining   
+27 on object-centric datasets such as ImageNet [25, 6], inferior results are observed on images depicting   
+28 multiple objects such as OpenImages or COCO [67]. Several methods have been proposed to mitigate   
+29 this issue [67, 68, 37, 1], but all focus on learning improved object representations or dense pixel   
+30 representations, instead of explicitly modeling the representations for scene images. The object   
+31 representations learned by these methods present a natural topology [66]. That is, the objects from   
+32 visually similar classes lie close to each other in the representation space. However, it is not clear   
+33 how the representations of scene images should fit into that topology. Naively applying existing   
+34 contrastive learning results in sub-optimal topology of scenes and objects as well as unsatisfactory   
+35 performance as we will show in the experiment. To this end, we argue that a hierarchical structure   
+36 can be naturally adopted. Considering scenes as the composition of different kinds of objects, we   
+37 can construct a forest structure to describe such relationships, where the root nodes are the visually   
+38 similar objects, and the scene images consisting of them are placed as the descendants. We call this   
+39 structure the object-centric scene hierarchy.   
+40 The intermediate modeling difficulty induced by   
+41 this structure is the combinatorial explosion. A   
+42 finite number of objects can lead to exponentially   
+43 many kinds of scenes due to the composition. Hy  
+44 perbolic space is known for its provably better   
+45 capacity in modeling infinite trees compared with   
+46 Euclidean space [21, 26, 34]. Therefore, we pro  
+47 pose to employ a hyperbolic objective to regularize   
+48 the scene representations. Our framework builds   
+49 upon MoCo [27], which has been shown to learn   
+50 good object representations. To learn representa  
+51 tions of scenes, we sample the co-occurring scene  
+52 object pairs as the positive pairs, and objects that   
+53 are not part of that scene as the negative samples,   
+54 and use these pairs to compute an auxiliary hyper  
+55 bolic contrastive objective. Our model is trained   
+56 to reduce the distance between positive pairs and   
+57 push away the negative pairs in a hyperbolic space.   
+58 Contrastive learning models generally compute   
+59 their objectives on a hypersphere [27, 12]. By   
+60 discarding the norm information, these models   
+61 effectively circumvent the shortcut of minimizing   
+62 objectives by tuning the norms and obtain better   
+63 downstream performance. At the same time, they also lose control of the representative power in the   
+64 magnitude of the norm and leave the images disorganized. However, in hyperbolic space, it is the   
+65 magnitude of the norm that is used to model the hypernymy of the hierarchical structure [43, 58, 51].   
+66 When projecting the representations to the hyperbolic space, the norm information is preserved and   
+67 used to determine the Riemannian distance, which eventually affects our loss. Since the hyperbolic   
+68 space is diffeomorphic and conformal to the Euclidean, our hyperbolic contrastive loss is completely   
+69 differentiable and complementary to the original contrastive objective.   
+70 When training simultaneously with the original contrastive objective for objects and our proposed   
+71 hyperbolic contrastive objective for scenes, the resulting representation space exhibits the desired   
+72 hierarchical structure while keeping the object clustering topology intact as shown in Figure 1. We   
+73 demonstrate the effectiveness of the learned representations on several downstream tasks, from image   
+74 classification to object detection. We also show that the properties possessed by the representations   
+75 allow us to perform various vision tasks in a zero-shot way, from label uncertainty quantification to   
+76 out-of-context object detection. Our contributions are summarized below:
+
+![](images/96870909088416fd93a5e67bc7b1906249d2485857d3c54b0673ef7e69092e29.jpg)  
+Figure 1: Illustration of the representation space learned by our models. Object images of the same class tend to gather near the center around similar directions, while the scene images are far away in these directions with larger norms.
+
+1. We propose to learn representations for both object and scene images simultaneously using un-/self-supervised methods. We identify an object-centeric scene hierarchy that the representations are expected to follow. 2. We propose a framework with a novel hyperbolic contrastive loss to regularize the scene representations with positive and negative pairs sampled from the hierarchy. 3. We show that the magnitude of representation norms effectively reflect the scene-objective hypernymy, and such representations transfer better to multiple downstream tasks.
+
+# 84 2 Method
+
+85 In this section, we elaborate our approach to learn visual representations of object and scene images.   
+86 We start with describing the hierarchical structure between objects and scenes.   
+88 From simple object co-occurrence statistics [20, 39] to finer object relationships [29, 31], using   
+89 hierarchical relationships between objects and scenes to understand images is not new. Previous   
+90 studies primarily work on an instance-level hierarchy by dividing an image into its lower-level   
+91 elements recursively - a scene contains multiple objects, an object has different parts, and each part   
+92 may consist of even lower-level features [47, 46, 15]. While this is intuitive, it describes a hierarchical   
+93 structure contained in the individual images. In our task, we would like to work on the structure from   
+94 the view of the entire dataset to learn a representation space shared by objects and scenes. To this   
+95 end, we argue that it is more natural to consider an object-centric hierarchy.   
+96 It is known that when training an image classifier, though not being optimized directly, the objects   
+97 from visually similar classes often lie close to each other in the representation space [66], which has   
+98 become the cornerstone of contrastive learning [27, 12]. Motivated by this observation, we believe   
+99 that the representation of each scene image should also be close to the object clusters it consists of.   
+100 However, they require a much larger volume due to the exponential number of possible compositions.   
+101 Another way to think about the object-centric hierarchy is through the generality and specificity as   
+102 often discussed in the language literature [40, 43]. An object concept is general when standing alone   
+103 in the visual world, and it will become specific when a certain context is given. For example, “a desk”   
+104 is thought to be a more general concept than “a desk in a classroom with a boy sitting on it”.   
+105 Therefore, we propose to study an object-centric hierarchy across the entire dataset. Formally,   
+106 given a set of images $\boldsymbol { S } = \{ \bar { s } _ { 1 } , s _ { 2 } , \cdots , s _ { n } \}$ , $\mathcal { O } _ { i } ~ = ~ \{ o _ { i } ^ { 1 } , \dot { o } _ { i } ^ { 2 } , \cdot \cdot \cdot ~ , o _ { i } ^ { n _ { i } } \}$ are the object bounding   
+107 boxes contained in the image $s _ { i }$ . We define the regions of scene $\mathcal { R } _ { i } ^ { \setminus } = \{ r _ { i } ^ { 1 } , r _ { i } ^ { 2 } , \cdots , r _ { i } ^ { m _ { i } } \}$ rmi } to be   
+108 partial areas of the image $s _ { i }$ that contain multiple objects such that $r _ { i } ^ { j } ~ = ~ \cup _ { k } o _ { i } ^ { k }$ , where $o _ { i } ^ { k } \in$   
+109 $\mathcal { O } _ { i }$ and object $k$ is in the region $j$ . We define the object-centric forest $T = ( V , E )$ to be that $V =$   
+110 $S \cup \mathcal { O } \cup \mathcal { R }$ , where $\mathcal { R } = \mathcal { R } _ { 1 } \cup \cdot \cdot \cdot \cup \mathcal { R } _ { n }$ and $\mathcal { O } = \mathcal { O } _ { 1 } \cup \cdots \cup \mathcal { O } _ { n }$ . For $u , v \in V$ , $e = \left( u , v \right)$ is an edge   
+111 of $T$ if $u \subseteq v$ or $v \subseteq u$ . Note that the natural scene images $s$ are always put as the leaf nodes.
+
+# 112 2.2 Representation Learning beyond Objects
+
+113 To describe our proposed model that is built on this hierarchy, we begin with a brief review of   
+114 the hyperbolic space and its several properties that will be used in our model. For comprehensive   
+115 introductions to the Riemannian geometry and hyperbolic space, we refer the readers to [32, 17].
+
+# 2.2.1 Hyperbolic Space
+
+117 A hyperbolic space $( \mathbb { H } ^ { m } , g )$ is a complete, connected Riemannian manifold with constant negative   
+118 sectional curvature. These special manifolds are all isometric to each other with the isometries   
+119 defined as $O ^ { + } ( m , 1 )$ . Among these isometries, there are five common models that previous studies   
+120 often work on [5]. In this paper, we choose the Poincaré ball $\mathbb { D } ^ { n } : = \left\{ p \in \mathbb { R } ^ { n } \mid \| p \| ^ { 2 } < r ^ { 2 } \right\}$ as our   
+121 basic model [43, 58, 22], where $r > 0$ is the radius of the ball. The Poincaré ball is coupled with   
+122 a Riemannian metric $\begin{array} { r } { g _ { \mathbb { D } } ( p ) = \frac { 4 } { ( 1 - \| p \| ^ { 2 } / r ^ { 2 } ) ^ { 2 } } g _ { \mathbb { E } } } \end{array}$ , where $p \in \mathbb { D } ^ { n }$ and $g _ { \mathbb { E } }$ is the canonical metric of the   
+123 Euclidean space. For $p , q \in \mathbb { D }$ , the Riemannian distance on the Poincaré ball induced by its metric $g _ { \mathbb { D } }$   
+124 is defined as follows:
+
+$$
+d _ { \mathbb { D } } ( p , q ) = 2 r \operatorname { t a n h } ^ { - 1 } \left( \frac { \lVert - p \oplus q \rVert } { r } \right) ,
+$$
+
+125 where $\oplus$ is the Möbius addition and it is clearly differentiable. In addition, the Poincaré ball can be   
+126 viewed as a natural counterpart of the hypersphere as it allows all directions, unlike the other models   
+127 such as the halfspace or hemisphere models that have constraints on the directions. The hyperbolic   
+128 space is globally differomorphic to the Euclidean space, which is stated in the theorem below:   
+29 Theorem 1. (Cartan–Hadamard). For every point $p \in \mathbb { H } ^ { n }$ the exponential map $\exp _ { p } : T _ { p } \mathbb { H } ^ { n } \approx$   
+30 $\mathbb { R } ^ { n } \to \mathbb { H } ^ { n }$ is a smooth covering map. Since $\mathbb { H } ^ { n }$ is simply connected, it is diffeomorphic to $\mathbb { R } ^ { n }$ .
+
+Specifically, for 131 $p \in \mathbb { D } ^ { n }$ and $v \in T _ { p } \mathbb { D } ^ { n } \approx \mathbb { R } ^ { n }$ , the exponential map of the Poincaré ball $\exp _ { p }$ : 132 $T _ { p } { \mathbb { D } } ^ { n } \to { \mathbb { D } } ^ { n }$ is defined as
+
+$$
+\exp _ { p } ( v ) : = p \oplus \left( \operatorname { t a n h } \left( { \frac { r \| v \| } { r ^ { 2 } - \| p \| ^ { 2 } } } \right) { \frac { r v } { \| v \| } } \right) ,
+$$
+
+![](images/5e015b8327887fcbc10904e8cf2df0d7d26edd85e0c52e41b97edbfcc0c12579.jpg)  
+Figure 2: Our Hyperbolic Contrastive Learning (HCL) framework has two branches: given a scene image, two object regions are cropped to learn the object representations with a loss defined in the Euclidean space focusing on the representation directions. A scene region as well as a contained object region are used to learn the scene representations with a loss defined in the hyperbolic space that affects the representation norms.
+
+133 The exponential map gives us a way to map the output of a network, which is in the Euclidean space,   
+134 to the Poincaré ball. In practice, to avoid numerical issues, we clip the maximal norm of $v$ with $r - \varepsilon$   
+135 before the projection, where $\varepsilon > 0$ . During the backpropagation, we perform RSGD [4] by scaling   
+136 the gradients with $g _ { \mathbb { D } } ( p ) ^ { - 1 }$ . Intuitively, this forces the optimizer to take a smaller step when $p$ is   
+137 closer to the boundary. The scaling factor is lower bounded by $\mathcal { O } ( \varepsilon ^ { 2 } )$ .   
+138 The immediate consequence of the negative curvature is that for any point $\pmb { p } \in \mathbb { H } ^ { m }$ , there are no   
+139 conjugate points along any geodesic starting from $\pmb { p }$ . Therefore, the volume grows exponentially   
+140 faster in hyperbolic space than in Euclidean space. Such a property makes it suitable to embed the   
+141 hierarchical structure that has constant branching factors and exponential number of nodes. This is   
+142 formally stated in the theorem below:
+
+Theorem 2. [21, 26] Given a Poincaré ball $\mathbb { D } ^ { n }$ with an arbitrary dimension $n \geq 2$ and any set of points $p _ { 1 } , \cdot \cdot \cdot , p _ { m } \in \mathbb { D } ^ { n }$ , there exists a finite weighted tree $( T , d _ { T } )$ and an embedding $f : T \to { \mathbb { D } } ^ { n }$ such that for all $i , j ,$
+
+$$
+\left| d _ { T } \left( f ^ { - 1 } \left( x _ { i } \right) , f ^ { - 1 } \left( x _ { j } \right) \right) - d _ { \mathbb { D } } \left( x _ { i } , x _ { j } \right) \right| = \mathcal { O } ( \log ( 1 + \sqrt { 2 } ) \log ( m ) )
+$$
+
+143 Intuitively, the theorem states that any tree can be embedded into a Poincaré disk ${ \it n } = 2$ ) with   
+144 low distortion. On the contrary, it is known that the Euclidean space with unbounded number of   
+145 dimensions is not able to achieve such a low distortion [34]. One useful intuition [51] to help   
+146 understand the advantage of the hyperbolic space is given two points $p , q \in \mathbb { D } ^ { n }$ s.t. $\| p \| = \| q \|$ ,
+
+$$
+\begin{array} { r } { d _ { \mathbb { D } } ( p , q ) \to d _ { \mathbb { D } } ( p , 0 ) + d _ { \mathbb { D } } ( 0 , q ) , ~ \mathrm { a s } ~ \| p \| = \| q \| \to r } \end{array}
+$$
+
+This property basically reflects the fact that the shortest path in a tree is the path through the earliest common ancestor, and it is reproduced in the Poincaré when points are both close to the boundary.
+
+# 2.2.2 Hyperbolic Contrastive Learning
+
+150 With the theoretical benefits of the hyperbolic space stated above, we propose a contrastive learning   
+151 framework as shown in Figure 2. We adopt two losses to learn the object and scene representations.   
+152 First, as shown in the top branch of Figure 2, we crop two views of a jittered and slightly expanded   
+153 object region as the positive pairs and feed into the base and momentum encoders to calculate the   
+154 object representations. We denote the output after the normalization to be $\mathbf { z } _ { \mathrm { e u c } } ^ { 1 }$ and $\mathbf { z } _ { \mathrm { e u c } } ^ { 2 }$ . Considering   
+155 the computational cost of large batch sizes, we follow MoCo [27, 14] to leverage a memory bank to   
+156 store the negative representations $z _ { \mathrm { e u c } } ^ { n }$ which are the features $\mathbf { z } _ { \mathrm { e u c } } ^ { 2 }$ from the previous batches. The   
+157 Euclidean loss for this image is then calculated as:
+
+$$
+\mathcal { L } _ { \mathrm { e u c } } = - \log \frac { \exp \left( { \bf z } _ { \mathrm { e u c } } ^ { 1 } \cdot { \bf z } _ { \mathrm { e u c } } ^ { 2 } / \tau \right) } { \exp \left( { \bf z } _ { \mathrm { e u c } } ^ { 1 } \cdot { \bf z } _ { \mathrm { e u c } } ^ { 2 } / \tau \right) + \sum _ { n } \exp \left( { \bf z } _ { \mathrm { e u c } } ^ { 1 } \cdot { \bf z } _ { \mathrm { e u c } } ^ { n } / \tau \right) } ,
+$$
+
+158 where $\tau$ is a temperature parameter.
+
+159 While this loss aims at learning object representations, we also design a hyperbolic contrastive   
+160 objective to learn the representations for scene images. We sample the positive region pairs $u$ and $v$   
+161 from object-centric scene hierarchy $T$ such that $( u , \bar { v } ) \in E$ . In other words, as shown in the bottom   
+162 branch of Figure 2, the objects contained in one region are required to be a subset of the objects in   
+163 the other. We sample the negative samples of $u$ to be $\mathcal { N } _ { u } = \{ v \bar { | } ( u , v ) \notin E \}$ . However, building and   
+164 sampling from the entire hierarchy explicitly is slow and memory consuming. Instead, according to   
+165 the assumption that there are exponentially more scenes than object classes in practice, given a scene   
+166 image $s$ , we always sample $u \in { \mathcal { R } } \cup \{ s \}$ to be a scene region, $v \in \mathcal { O }$ to be an object that occurs in $u$   
+167 and $\mathcal { N } _ { u }$ to be the other objects that are not in $u$ .   
+168 The pair of scene and object images are fed into the base and momentum encoders that share the   
+169 weights with the Euclidean branch. However, instead of normalizing the output of the encoders, we   
+170 use the exponential map defined in the equation (2) to project these features in the Euclidean space to   
+171 the Poincaré ball, which are denoted as $\mathbf { \dot { z } } _ { \mathrm { h y p } } ^ { 1 }$ and $\mathbf { z } _ { \mathrm { h y p } } ^ { 2 }$ . Further, we replace the inner product in the   
+172 cross-entropy loss with the negative hyperbolic distance as defined in equation (1). We calculate the   
+173 hyperbolic contrastive loss as follows:
+
+$$
+\mathcal { L } _ { \mathrm { h y p } } = - \log \frac { \exp \left( - d _ { \mathbb { D } } ( \mathbf { z } _ { \mathrm { h y p } } ^ { 1 } , \mathbf { z } _ { \mathrm { h y p } } ^ { 2 } ) / \tau \right) } { \exp \left( - d _ { \mathbb { D } } ( \mathbf { z } _ { \mathrm { h y p } } ^ { 1 } , \mathbf { z } _ { \mathrm { h y p } } ^ { 2 } ) / \tau \right) + \sum _ { n } \exp \left( - d _ { \mathbb { D } } ( \mathbf { z } _ { \mathrm { h y p } } ^ { 1 } , \mathbf { z } _ { \mathrm { h y p } } ^ { n } ) / \tau \right) } ,
+$$
+
+174 When minimizing the distances of all the positive pairs, With the intuition from Equation (3), it would   
+175 be beneficial to put the nodes near the root close to the center to achieve a overall lower loss. The   
+176 overall loss function of our model is as follows:
+
+$$
+\begin{array} { r } { \mathcal { L } = \mathcal { L } _ { \mathrm { e u c } } + \lambda \mathcal { L } _ { \mathrm { h y p } } , } \end{array}
+$$
+
+177 where $\lambda$ is an scaling parameter to control the trade-off between hyperbolic and Euclidean losses.
+
+# 3 Experiments
+
+# 3.1 Implementation Details
+
+180 Pre-training phase. We pre-train our method on two datasets: COCO [33] and a subset of Open  
+181 Images [41]. Both of these datasets are multi-object datasets; OpenImages [41] ( $\mathrm { \sim 2 1 2 k }$ images)   
+182 contains 12 objects on average per image and COCO $( \sim 1 1 8 \mathbf { k } )$ contains 6 objects on average. We   
+183 experiment with both the ground truth bounding box (GT) and using selective search [60] following   
+184 the previous method [67] (SS) to acquire objects. For the optimizer setups and augmentation recipes,   
+185 we follow the standard protocol described in MoCo-v2 [14] unless denoted otherwise. We find that a   
+186 base learning rate of 0.3 works better for us as compared to 0.03. We adopt the linear learning rate   
+187 scaling receipt that $l r = 0 . 3 \times \mathrm { B a t c h S i z e / 2 5 6 }$ [24] and batch size of 128 by default on 4 NVIDIA   
+188 p6000 gpus. To ensure fair comparison, we also pre-train the baselines with a learning rate of 0.3.   
+189 We train our models on both datasets for 200 epochs. For the hyperparameters of our hyperbolic   
+190 objective, we use $r = 4 . 5$ , $\lambda = 0 . 1$ , and $\varepsilon = 1 e ^ { - 5 }$ . More details on the OpenImages dataset as well   
+191 as training setups can be found in Appendix A.   
+192 Downstream tasks. We evaluate our pre-trained models on image classification, object-detection   
+193 and semantic segmentation. For classification, we show linear evaluation (lineval) accuracy, i.e we   
+194 freeze the backbone and only train the final fc layer. We test on VOC [19], ImageNet-100 [57] and   
+195 ImageNet-1k [16] datasets. To test the discriminative capacity of the representations on both objects   
+196 and scenes, we create a dataset by mixing the ImageNet-100 and a subset of Place-205 [70] datasets,   
+197 which we refer to as the INPMix dataset. More details of this dataset can be found in Appendix A.   
+198 For object detection and semantic segmentation, we show results on the COCO and Pascal VOC   
+199 trainval2017 datasets. For VOC object detection, COCO object detection and COCO semantic   
+200 segmentation, we closely follow the common protocols listed in Detectron2 [65].
+
+Table 1: Classification results with linear evaluation. Our model improves scene-level classification on the VOC [19] and INPMix [70] datasets, and object-level classification on ImageNet-100 [57] and ImageNet-1k [16] datasets.   
+
+<table><tr><td></td><td>Pre-train dataset</td><td>Bbox type</td><td>vOC</td><td>IN-100</td><td>INPMix ]</td><td>IN-1k</td></tr><tr><td rowspan="3">MoCo-v2 HCL/Lhyp HCL/Lhyp</td><td>COCO</td><td>1</td><td>64.79</td><td>64.84</td><td>41.83</td><td>51.17</td></tr><tr><td>COCO</td><td>SS</td><td>73.13</td><td>73.84</td><td>51.28</td><td>54.21</td></tr><tr><td>COCO</td><td>GT</td><td>75.55</td><td>76.22</td><td>51.25</td><td>54.52</td></tr><tr><td>HCL HCL</td><td>COCO CoCo</td><td>SS GT</td><td>74.19 76.51</td><td>75.16 76.74</td><td>51.35 51.63</td><td>55.03 55.63</td></tr><tr><td>MoCo-v2 HCL/Lhyp</td><td>OpenImages OpenImages</td><td>1 GT</td><td>69.95 73.79</td><td>72.80 77.36</td><td>49.59 52.96</td><td>54.12 57.57</td></tr><tr><td>HCL HCL</td><td>OpenImages OpenImages</td><td>Ss GT</td><td>74.31 75.40</td><td>78.14 79.08</td><td>53.21 53.82</td><td>58.12 58.51</td></tr></table>
+
+Table 2: Object detection and Semantic Segmentation results. Our model improves on both tasks on COCO [33] and VOC [19] datasets.   
+
+<table><tr><td>Detection</td><td>Dataset</td><td>AP AP50</td><td>AP75</td></tr><tr><td>MoCo-v2 HCL/Lhyp</td><td>COCO COCO</td><td>34.6 53.5 36.1 55.2</td><td>37.0 37.9</td></tr><tr><td>HCL</td><td>COCO</td><td>37.0 56.1</td><td>39.8</td></tr><tr><td>MoCo-v2 HCL - Lhyp</td><td>VOC VOC</td><td>51.5 79.4 53.7 80.5</td><td>56.1 59.4</td></tr><tr><td>HCL</td><td>VOC</td><td>54.4 81.4</td><td>60.2</td></tr><tr><td>Segmentation</td><td>Dataset</td><td>APs AP1</td><td>APm</td></tr><tr><td>MoCo-v2</td><td>COCO</td><td>30.4 50.1</td><td>32.3</td></tr><tr><td>HCL/Lhyp HCL</td><td>COCO COCO</td><td>31.5 52.0 32.5 52.9</td><td>33.8 34.6</td></tr></table>
+
+# 201 3.2 Main Results
+
+This section discusses our main results on the downstream image classification, object detection, and semantic segmentation tasks. As the goal of this paper is not to present another state-of-the-art self-supervised learning method, we primarily compare with the backbone model MoCo-v2 [27]. Another important baseline we consider is our model without the hyperbolic loss $\mathcal { L } _ { \mathrm { h y p } }$ ; therefore only the object representations are learned, which we denote as $\mathrm { H C L } / \mathcal { L } _ { \mathrm { h y p } }$ .
+
+Image classification. As shown in Table 1, HCL improves image classification on both scene-level datasets (VOC and INPMix) and object-level datasets (ImageNet). When pretraining on OpenImages, HCL improves ImageNet lineval accuracy by $0 . 9 4 \%$ and VOC lineval classification accuracy by 1.61 mAP. We observe similar improvements when pretraining on COCO. HCL improves accuracy whether we use ground truth object bounding boxes or boxes generated by selective search. In general, we observe a larger improvement of using HCL on OpenImages than COCO, which supports our observation that HCL would improve more on the dataset with more objects per images.
+
+Object detection and semantic segmentation. Table 2 reports the object detection and semantic segmentation results using Mask R-CNN, following [14]. It shows consistent improvements over the baselines on VOC object detection, COCO object detection, and COCO semantic segmentation.
+
+# 3.3 Properties of Models Trained with HCL
+
+The visual representations learned by HCL have several useful properties. In this section, we evaluate the representation norm as an measure of the label uncertainty for image classification datasets, and evaluate the object-scene similarity in terms of out-of-context detection.
+
+# 221 3.3.1 Label Uncertainty Quantification
+
+![](images/29174cdbb819ae786f1da3fe1072ee6de44b437a9f463e2c5d430cda7ea3300c.jpg)  
+Figure 4: Average representation norms of images with different number of labels in ImageNet-ReaL [3].
+
+Table 3: NDCG scores of the image rankings based on the different indicators and models, and evaluated by the the number of labels per image.   
+
+<table><tr><td>Method</td><td>Indicator</td><td>Datasets IN-Real</td><td>COCO</td></tr><tr><td>MoCo</td><td>Entropy</td><td>0.633</td><td>0.791</td></tr><tr><td>Supervised</td><td>Entropy</td><td>0.671</td><td>0.793</td></tr><tr><td>HCL</td><td>Norm</td><td>0.655</td><td>0.839</td></tr><tr><td>Ensemble</td><td>Entropy+Norm</td><td>0.717</td><td>0.823</td></tr></table>
+
+222 ImageNet [16] is an image classification dataset consisting of object-centered images, each of which   
+223 has a single label. As the performance on this dataset gradually saturated, the original labels have   
+224 been scrutinized more carefully [50, 59, 54, 3, 61]. Prevailing labeling issues in the validation set   
+225 have been recently identified [59, 54, 3], including labeling errors, multi-label images with only a   
+226 single label provided, and so on. Although Beyer et al. [3] provide reassessed labels for the entire   
+227 validation set, relabeling the entire training set can be infeasible.
+
+![](images/c8fe2b0a28d33e4b9a02fa4316d901a44e6461421c75f8b18f1ae24dd60ea2a5.jpg)  
+Figure 3: Images from ImageNet training set. The 5 images on the left have the smallest representation norms among all the images from the same class, and the 5 on the right have the largest norms.
+
+Our learned representations provide a potential automatic way to identify images with multiple labels from datasets like ImageNet. Specifically, we first show in Figure 4 that there is a strong correlation between the representation norms and the number of labels per image according to the reassessed labels. For each class of the ImageNet training set, we rank the images according to their norms. The extreme images of some classes are shown in Figure 3 and also Appendix. Images with smaller norms tend to capture a single object, while those with larger norms are likely to depict a scene.
+
+To quantitatively evaluate this property, we report the NDCG metric on the ranked images as shown in Table 3. NDCG assesses how often the scene images are ranked at the top. As a baseline, we rank the images based on the entropy of the class probability predicted by a classifier, which is a widely adopted label uncertainty indicator [11, 45]. We use both MoCo-v2 and supervised ResNet-50 as the classifier. As shown in Table 3, using norms with HCL achieves similar rank quality as using entropy with the supervised ResNet-50 on the ImageNet-ReaL dataset. In addition, when combining two ranks using simple ensemble methods such as Borda count, the score is further improved to 0.717. This shows that the entropy and the norm might look at different aspects of the multi-label issue. For example, the entropy indicator can be affected by the bias of the model and the norm indicator can be wrong on the images with multiple objects from the same class. In addition, our method is dataset agnostic and does not need further training. To demonstrate this benefit, we report the same metric on the COCO validation, where we also have the number of labels for each image. Our method achieves much better NDCG scores than the supervised ResNet-50 as shown in Table 3. This finding can be potentially useful to guide label reassessment, or provide an extra signal for model training.
+
+# 3.3.2 Out-of-Context Detection
+
+Our hyperbolic loss $\mathcal { L } _ { \mathrm { h y p } }$ essentially encourages the model to capture the similarity between the object and scene. We further investigate this property on detecting the out-of-context objects, which can be useful in designing data augmentation for object detection [18]. We are especially interested in the out-of-context images with conflicting backgrounds. To this end, we use the out-of-context images proposed in the SUN09 dataset [15]. We first compute the representation of each object as well as the entire scene image with that object masked out. We then calculate the hyperbolic distance between the representations mapped to the Poincaré ball. Some example images from this dataset as well as the distance of each contained object are shown in Figure 5. We find that the out-of-context objects generally have a large distance, i.e. smaller similarity, to the overall scene image. To quantify this finding, we compute the mAP of the object ranking on each image and obtain 0.61 for HCL. As a comparison, the MoCo similarity gives mAP $= 0 . 5 2$ and the random ranking gives $\mathrm { m A P } = 0 . 4 4$ .
+
+![](images/f42028b92989bbbf8c805aef7506a778e82534c6ac63f498867e4359a09a5ddc.jpg)  
+Figure 5: Out-of-context images from the SUN09 dataset [15]. The bounding box of each object, as well as its hyperbolic distance to the scene are displayed. The regular objects are in blue and the out-of-context objects are in purple. Note that the out-of-context objects tend to have large distances.
+
+# 260 4 Main Ablation Studies
+
+261 In this section, we report the results of several important ablation studies with respect to HCL.   
+262 All the models are trained on the subset of the OpenImages dataset and linearly evaluated on the   
+263 ImageNet-100 and our INPMix datasets. The top-1 accuracy is reported.
+
+<table><tr><td>Optim. 入</td><td>IN-100</td><td>IPS</td></tr><tr><td>RSGD 0.1</td><td>79.08</td><td>53.82</td></tr><tr><td>RSGD 0.5</td><td>0</td><td>0</td></tr><tr><td>SGD 0.1</td><td>70.16</td><td>48.47</td></tr><tr><td>SGD 0.5</td><td>74.18</td><td>42.75</td></tr></table>
+
+Table 4: Ablation on the similarity measure and hierarchy center.   
+
+<table><tr><td>Dist.</td><td>Center</td><td>IN-100</td><td>IPS</td></tr><tr><td>1</td><td>-</td><td>77.36</td><td>52.96</td></tr><tr><td>Hyp.</td><td>Scene</td><td>79.08</td><td>53.82</td></tr><tr><td>Hyp.</td><td>Object</td><td>76.96</td><td>52.74</td></tr><tr><td>Euc.</td><td>Scene</td><td>76.68</td><td>52.58</td></tr></table>
+
+Table 5: Ablation on the losses trade-off.   
+
+<table><tr><td>入</td><td>IN-100</td><td>IPS</td></tr><tr><td>0.01</td><td>77.70</td><td>53.43</td></tr><tr><td>0.1</td><td>79.08</td><td>53.82</td></tr><tr><td>0.2 0.5</td><td>78.64 0</td><td>53.84 0</td></tr></table>
+
+Table 6: Ablation on the RSGD versus SGD optimizers.
+
+Similarity measure and the center of the scene-object hierarchy. We propose to use the negative hyperbolic distance as the similarity measure of the scene-object pairs. As an alternative, one can use cosine similarity on the hypersphere as the measure just like the original contrastive objective. However, this is basically minimizing the similarity between a single object and multiple objects. These objects are probably from different classes and hence conflict with the original objective. As shown in Table 4, replacing the negative hyperbolic distance with the Euclidean similarity impairs downstream performance. The resulting accuracy is even worse than the model without any loss function on the scene-object pairs. In terms of the hierarchy, we also test the assumption of scenecentric hierarchy [46, 47] by sampling the negative pairs as the objects and unpaired scenes. However, we notice a significant decrease in the downstream accuracy with this modification in Table 4.
+
+Trade-off between the Euclidean and hyperbolic losses. We adopt the Euclidean loss to learn object-object similarity and the hyperbolic loss to learn object-scene similarity. A hyperparameter $\lambda$ is used to control the trade-off between them. As shown in Table 4, we find that a smaller $\lambda = 0 . 0 1$ leads to marginal improvement. However, we also observe that larger λs can lead to unstable and even stalled training. With careful inspection, we find that in the early stage of the training, the gradient provided by the hyperbolic loss can be inaccurate but strong, which pushes the representations to be close to the boundary. As a result, the Riemannian SGD causes the gradient to be small and the training is consequently stuck at some the early point.
+
+Optimizer. With the observation above, we ask whether RSGD is still necessary for practical usage. We replace the RSGD optimizer with SGD. To avoid the numerical issue when the representations are too close to the boundary, we increase $\varepsilon$ from $1 e ^ { - 5 }$ to $1 e ^ { - 1 }$ . We first notice that this allows larger $\lambda$ to be used as opposed to the RSGD. However, SGD always yields inferior performance to RSGD. Therefore, it shows that the accurate gradient provided by RSGD is still necessary.
+
+# 5 Related Work
+
+88 Representation Learning with Hyperbolic Space. Representations are typically learned in Eu  
+89 clidean space. Hyperbolic space has been adopted for its expressiveness in modeling tree-like   
+290 structures existing in various domains such as language [58, 21, 51, 43, 44], graphs [2, 8, 9, 48], and   
+291 vision [30, 10, 56]. The corresponding deep neural network modules have been designed to boost the   
+292 progress of such applications [9, 22, 35, 55]. The hierarchical structure presented in the datasets can   
+293 come from multiple factors, motivating the use of hyperbolic space. 1) Generality: the hypernym  
+294 hyponym property is a natural feature of words (e.g. WordNet [40]) and the hyperbolic space is   
+295 extensively exploited to learn word embeddings that preserve that property [58, 21, 51, 43, 44].   
+296 Some image datasets also adopt the classes from WordNet for labeling, e.g. ImageNet [16], and   
+297 consequently inherits the hierarchy in its labeling system. [36, 69, 38] take advantage of hyperbolic   
+298 space to capture such information in the visual embeddings. 2) Uncertainty: Several studies have   
+299 found that applying hyperbolic neural network modules to different tasks leads to a natural modeling   
+300 of the uncertainty [23, 30, 56]. 3) Compositionality: The compositionality of different basic elements   
+301 can form a natural hierarchy. We focus on learning the representations that capture the hierarchy   
+302 between the objects and scenes. The hierarchical representations learned in the hyperbolic space have   
+303 been applied to various tasks with the aforementioned motivations such as image classification [30]   
+304 or segmentation [64, 23], zero-/few-shot learning [38, 36], action recognition [38], and video pre  
+305 diction [56]. In this paper, we aim at learning image representations for general purposes that can   
+306 transfer to various downstream tasks.
+
+Self-Supervised Learning on Scenes. Self-Supervised Learning (SSL) has made great strides in closing the performance with supervised methods [12, 14] when pretrained on the object-centric datasets like ImageNet. However, recent works have shown that SSL are limited on the multiobject datasets like COCO [52, 63] and OpenImages [41]. Several works have tried to address this issue by proposing different techniques. Dense-CL [63] works on pre-average pool features and uses dense features on pixel level to show improved performance on dense tasks such as semantic segmentation. DetCon [28] uses unsupervised semantic segmentation masks to generate features for the corresponding objects in the two views. CAST [53] uses GradCAM [52] to figure out same objects across views and applies contrastive loss on these features. PixContrast [68] uses pixel-to-propagation consistency pretext task to build features for both dense downstream tasks and discriminative downstream tasks. Pixel-to-Pixel Contrast [62] uses pixel-level contrastive learning to build better features for semantic segmentation. Self-EMD [37] uses earth mover distance with BYOL [25] for pretraining on the COCO dataset. ORL [67] uses selective search to generate object proposals, then applies object-level contrastive loss to enforce object-level consistency. ContraCAM [42] removes the scene bias issue by doing self-supervised object localization and performing contrastive loss on them. One of the reasons below-par performance of SSL methods can be attributed to treating scenes and objects using similar techniques, which often results in similar representations. In our work, instead of treating them in the same functionality, we use a hyperbolic loss, which builds representation that disambiguates scenes and objects based on the norm of the embeddings. Our method not only separates scenes and objects, but also helps us in improving downstream tasks such as image classification.
+
+# 6 Closing Remarks
+
+Conclusion We present HCL, a contrastive learning framework that learns visual representation for both objects and scenes in the same representation space. The major novelty of our method is a hyperbolic contrastive objective built on an object-centric scene hierarchy. We show the effectiveness of HCL on several benchmarks including image classification, object detection, and semantic segmentation. We also demonstrate the useful properties of the representations under several zero-shot settings from detecting out-of-context objects to quantifying the label uncertainty in the datasets like ImageNet. More generally, we hope this paper can encourage studies towards building a more holistic visual representation space and draw attention to the non-Euclidean representation learning.
+
+Limitations Our model is shown to improve the classification performance on the ImageNet dataset, but not much on the more fine-grained classification tasks as shown in Appendix B.2. We conjecture that the largest improvement brought by our model to the object representations are modeling the context information, while most of these datasets share a general class whose contexts are more or less similar. In addition, although we provide some insights about the Riemannian optimization, its underlying mechanism in the visual representation learning is still not fully understood. We conduct more experiments on training hyperbolic linear classifiers in Appendix C.1. However, more efforts are needed to fully unleash the potential of non-Euclidean representation learning.
+
+Our work is a technical contribution and much of societal impact depends upon the models used in our work. We hope that our work will be used for betterment of the society and doesn’t have any negative impact.
+
+# References
+
+350 [1] Y. Bai, X. Chen, A. Kirillov, A. Yuille, and A. C. Berg. Point-level region contrast for object detection   
+351 pre-training. CVPR, 2022.   
+352 [2] I. Balazevic, C. Allen, and T. Hospedales. Multi-relational poincaré graph embeddings. NeurIPS, 2019.   
+353 [3] L. Beyer, O. J. Hénaff, A. Kolesnikov, X. Zhai, and A. van den Oord. Are we done with imagenet?, 2020.   
+354 [4] S. Bonnabel. Stochastic gradient descent on riemannian manifolds. IEEE Transactions on Automatic   
+355 Control, 58(9):2217–2229, 2013.   
+356 [5] J. W. Cannon, W. J. Floyd, R. Kenyon, W. R. Parry, et al. Hyperbolic geometry. Flavors of geometry,   
+357 31(59-115):2, 1997.   
+358 [6] M. Caron, I. Misra, J. Mairal, P. Goyal, P. Bojanowski, and A. Joulin. Unsupervised learning of visual   
+359 features by contrasting cluster assignments. NeurIPS, 2020.   
+360 [7] M. Caron, H. Touvron, I. Misra, H. Jégou, J. Mairal, P. Bojanowski, and A. Joulin. Emerging properties in   
+361 self-supervised vision transformers. In ICCV, 2021.   
+362 [8] I. Chami, A. Wolf, D.-C. Juan, F. Sala, S. Ravi, and C. Ré. Low-dimensional hyperbolic knowledge graph   
+363 embeddings. In ACL, 2020.   
+364 [9] I. Chami, Z. Ying, C. Ré, and J. Leskovec. Hyperbolic graph convolutional neural networks. NeurIPS,   
+365 2019.   
+366 [10] J. Chen, J. Qin, Y. Shen, L. Liu, F. Zhu, and L. Shao. Learning attentive and hierarchical representations   
+367 for 3d shape recognition. In ECCV, 2020.   
+368 [11] P. Chen, B. B. Liao, G. Chen, and S. Zhang. Understanding and utilizing deep neural networks trained   
+369 with noisy labels. In ICML, 2019.   
+370 [12] T. Chen, S. Kornblith, M. Norouzi, and G. Hinton. A simple framework for contrastive learning of visual   
+371 representations. In ICML, 2020.   
+372 [13] T. Chen, S. Kornblith, K. Swersky, M. Norouzi, and G. E. Hinton. Big self-supervised models are strong   
+373 semi-supervised learners. NeurIPS, 2020.   
+374 [14] X. Chen, H. Fan, R. Girshick, and K. He. Improved baselines with momentum contrastive learning. arXiv   
+375 preprint arXiv:2003.04297, 2020.   
+376 [15] M. J. Choi, J. J. Lim, A. Torralba, and A. S. Willsky. Exploiting hierarchical context on a large database of   
+377 object categories. In CVPR, 2010.   
+378 [16] J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. Imagenet: A large-scale hierarchical image   
+379 database. In CVPR, 2009.   
+380 [17] M. P. Do Carmo and J. Flaherty Francis. Riemannian geometry, volume 6. Springer, 1992.   
+381 [18] N. Dvornik, J. Mairal, and C. Schmid. On the importance of visual context for data augmentation in scene   
+382 understanding. PAMI, 43(6):2014–2028, 2019.   
+383 [19] M. Everingham, L. Van Gool, C. K. Williams, J. Winn, and A. Zisserman. The pascal visual object classes   
+384 (voc) challenge. IJCV, 88(2):303–338, 2010.   
+385 [20] C. Galleguillos, A. Rabinovich, and S. Belongie. Object categorization using co-occurrence, location and   
+386 appearance. In CVPR, 2008.   
+387 [21] O. Ganea, G. Bécigneul, and T. Hofmann. Hyperbolic entailment cones for learning hierarchical embed  
+388 dings. In ICML, 2018.   
+389 [22] O. Ganea, G. Bécigneul, and T. Hofmann. Hyperbolic neural networks. NeurIPS, 2018.   
+390 [23] M. GhadimiAtigh, J. Schoep, E. Acar, N. van Noord, and P. Mettes. Hyperbolic image segmentation. arXiv   
+391 preprint arXiv:2203.05898, 2022.   
+392 [24] P. Goyal, P. Dollár, R. Girshick, P. Noordhuis, L. Wesolowski, A. Kyrola, A. Tulloch, Y. Jia, and K. He.   
+393 Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.   
+394 [25] J.-B. Grill, F. Strub, F. Altché, C. Tallec, P. Richemond, E. Buchatskaya, C. Doersch, B. Avila Pires, Z. Guo,   
+395 M. Gheshlaghi Azar, B. Piot, k. kavukcuoglu, R. Munos, and M. Valko. Bootstrap your own latent - a new   
+396 approach to self-supervised learning. In NeurIPS, 2020.   
+397 [26] M. Gromov. Hyperbolic groups. In Essays in group theory, pages 75–263. Springer, 1987.   
+398 [27] K. He, H. Fan, Y. Wu, S. Xie, and R. Girshick. Momentum contrast for unsupervised visual representation   
+399 learning. In CVPR, 2020.   
+400 [28] O. J. Hénaff, S. Koppula, J.-B. Alayrac, A. van den Oord, O. Vinyals, and J. Carreira. Efficient visual   
+401 pretraining with contrastive detection. In ICCV, pages 10086–10096, 2021.   
+402 [29] J. Johnson, R. Krishna, M. Stark, L.-J. Li, D. Shamma, M. Bernstein, and L. Fei-Fei. Image retrieval using   
+403 scene graphs. In CVPR, 2015.   
+404 [30] V. Khrulkov, L. Mirvakhabova, E. Ustinova, I. Oseledets, and V. Lempitsky. Hyperbolic image embeddings.   
+405 In CVPR, 2020.   
+406 [31] R. Krishna, Y. Zhu, O. Groth, J. Johnson, K. Hata, J. Kravitz, S. Chen, Y. Kalantidis, L.-J. Li, D. A. Shamma,   
+407 et al. Visual genome: Connecting language and vision using crowdsourced dense image annotations. IJCV,   
+408 2017.   
+409 [32] J. M. Lee. Introduction to Riemannian manifolds. Springer, 2018.   
+410 [33] T.-Y. Lin, M. Maire, S. J. Belongie, J. Hays, P. Perona, D. Ramanan, P. Dollár, and C. L. Zitnick. Microsoft   
+411 coco: Common objects in context. In ECCV, 2014.   
+412 [34] N. Linial, E. London, and Y. Rabinovich. The geometry of graphs and some of its algorithmic applications.   
+413 Combinatorica, 15(2):215–245, 1995.   
+414 [35] Q. Liu, M. Nickel, and D. Kiela. Hyperbolic graph neural networks. NeurIPS, 2019.   
+415 [36] S. Liu, J. Chen, L. Pan, C.-W. Ngo, T.-S. Chua, and Y.-G. Jiang. Hyperbolic visual embedding learning for   
+416 zero-shot recognition. In CVPR, 2020.   
+417 [37] S. Liu, Z. Li, and J. Sun. Self-emd: Self-supervised object detection without imagenet, 2021.   
+418 [38] T. Long, P. Mettes, H. T. Shen, and C. G. M. Snoek. Searching for actions on the hyperbole. In CVPR,   
+419 2020.   
+420 [39] T. Mensink, E. Gavves, and C. G. Snoek. Costa: Co-occurrence statistics for zero-shot classification. In   
+421 CVPR, 2014.   
+422 [40] G. A. Miller, R. Beckwith, C. Fellbaum, D. Gross, and K. J. Miller. Introduction to wordnet: An on-line   
+423 lexical database. International journal of lexicography, 3(4):235–244, 1990.   
+424 [41] S. K. Mishra, A. B. Shah, A. Bansal, A. N. Jagannatha, A. Sharma, D. Jacobs, and D. Krishnan. Object  
+425 aware cropping for self-supervised learning. ArXiv, abs/2112.00319, 2021.   
+426 [42] S. Mo, H. Kang, K. Sohn, C.-L. Li, and J. Shin. Object-aware contrastive learning for debiased scene   
+427 representation. In NeurIPS, 2021.   
+428 [43] M. Nickel and D. Kiela. Poincaré embeddings for learning hierarchical representations. NeurIPS, 2017.   
+429 [44] M. Nickel and D. Kiela. Learning continuous hierarchies in the lorentz model of hyperbolic geometry. In   
+430 ICML, 2018.   
+431 [45] C. Northcutt, L. Jiang, and I. Chuang. Confident learning: Estimating uncertainty in dataset labels. Journal   
+432 of Artificial Intelligence Research, 70:1373–1411, 2021.   
+433 [46] D. Parikh and T. Chen. Hierarchical semantics of objects (hsos). In ICCV, 2007.   
+434 [47] D. Parikh, C. L. Zitnick, and T. Chen. Unsupervised learning of hierarchical spatial structures in images.   
+435 In CVPR, 2009.   
+436 [48] J. Park, J. Cho, H. J. Chang, and J. Y. Choi. Unsupervised hyperbolic representation learning via message   
+437 passing auto-encoders. In CVPR, 2021.   
+438 [49] A. Radford, J. W. Kim, C. Hallacy, A. Ramesh, G. Goh, S. Agarwal, G. Sastry, A. Askell, P. Mishkin,   
+439 J. Clark, et al. Learning transferable visual models from natural language supervision. In ICML, 2021.   
+440 [50] B. Recht, R. Roelofs, L. Schmidt, and V. Shankar. Do imagenet classifiers generalize to imagenet? In   
+441 ICML, 2019.   
+442 [51] F. Sala, C. De Sa, A. Gu, and C. Ré. Representation tradeoffs for hyperbolic embeddings. In ICML, 2018.   
+443 [52] R. R. Selvaraju, M. Cogswell, A. Das, R. Vedantam, D. Parikh, and D. Batra. Grad-cam: Visual explanations   
+444 from deep networks via gradient-based localization. In ICCV, 2017.   
+445 [53] R. R. Selvaraju, K. Desai, J. Johnson, and N. Naik. Casting your model: Learning to localize improves   
+446 self-supervised representations. In CVPR, 2021.   
+447 [54] V. Shankar, R. Roelofs, H. Mania, A. Fang, B. Recht, and L. Schmidt. Evaluating machine accuracy on   
+448 imagenet. In ICML, 2020.   
+449 [55] R. Shimizu, Y. Mukuta, and T. Harada. Hyperbolic neural networks++. In ICLR, 2021.   
+450 [56] D. Surís, R. Liu, and C. Vondrick. Learning the predictability of the future. In CVPR, 2021.   
+451 [57] Y. Tian, D. Krishnan, and P. Isola. Contrastive multiview coding. In ECCV, 2020.   
+452 [58] A. Tifrea, G. Bécigneul, and O.-E. Ganea. Poincaré glove: Hyperbolic word embeddings. In ICLR.   
+453 OpenReview, 2018.   
+454 [59] D. Tsipras, S. Santurkar, L. Engstrom, A. Ilyas, and A. Madry. From imagenet to image classification:   
+455 Contextualizing progress on benchmarks. In ICML, 2020.   
+456 [60] J. R. Uijlings, K. E. Van De Sande, T. Gevers, and A. W. Smeulders. Selective search for object recognition.   
+457 IJCV, 104(2):154–171, 2013.   
+458 [61] V. Vasudevan, B. Caine, R. Gontijo-Lopes, S. Fridovich-Keil, and R. Roelofs. When does dough become a   
+459 bagel? analyzing the remaining mistakes on imagenet. arXiv preprint arXiv:2205.04596, 2022.   
+460 [62] W. Wang, T. Zhou, F. Yu, J. Dai, E. Konukoglu, and L. Van Gool. Exploring cross-image pixel contrast for   
+461 semantic segmentation. In ICCV, 2021.   
+462 [63] X. Wang, R. Zhang, C. Shen, T. Kong, and L. Li. Dense contrastive learning for self-supervised visual   
+463 pre-training. In CVPR, 2021.   
+464 [64] Z. Weng, M. G. Ogut, S. Limonchik, and S. Yeung. Unsupervised discovery of the long-tail in instance   
+465 segmentation using hierarchical self-supervision. In CVPR, 2021.   
+466 [65] Y. Wu, A. Kirillov, F. Massa, W.-Y. Lo, and R. Girshick. Detectron2. https://github.com/   
+467 facebookresearch/detectron2, 2019.   
+468 [66] Z. Wu, Y. Xiong, S. X. Yu, and D. Lin. Unsupervised feature learning via non-parametric instance   
+469 discrimination. In CVPR, 2018.   
+470 [67] J. Xie, X. Zhan, Z. Liu, Y. S. Ong, and C. C. Loy. Unsupervised object-level representation learning from   
+471 scene images. In NeurIPS, 2021.   
+472 [68] Z. Xie, Y. Lin, Z. Zhang, Y. Cao, S. Lin, and H. Hu. Propagate yourself: Exploring pixel-level consistency   
+473 for unsupervised visual representation learning. In CVPR, 2021.   
+474 [69] J. Yan, L. Luo, C. Deng, and H. Huang. Unsupervised hyperbolic metric learning. In CVPR, 2021.   
+475 [70] B. Zhou, A. Lapedriza, J. Xiao, A. Torralba, and A. Oliva. Learning deep features for scene recognition   
+476 using places database. NeurIPS, 2014.
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes]   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [N/A]   
+(b) Did you mention the license of the assets? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/dev/TTM7iEFOTzJ/TTM7iEFOTzJ.md

@@ -0,0 +1,298 @@
+# EpiGRAF: Rethinking training of 3D GANs
+
+Ivan Skorokhodov KAUST
+
+Sergey Tulyakov Snap Inc.
+
+Yiqun Wang KAUST
+
+Peter Wonka KAUST
+
+# Abstract
+
+A recent trend in generative modeling is building 3D-aware generators from 2D image collections. To induce the 3D bias, such models typically rely on volumetric rendering, which is expensive to employ at high resolutions. Over the past months, more than ten works have addressed this scaling issue by training a separate 2D decoder to upsample a low-resolution image (or a feature tensor) produced from a pure 3D generator. But this solution comes at a cost: not only does it break multi-view consistency (i.e., shape and texture change when the camera moves), but it also learns geometry in low fidelity. In this work, we show that obtaining a high-resolution 3D generator with SotA image quality is possible by following a completely different route of simply training the model patch-wise. We revisit and improve this optimization scheme in two ways. First, we design a location- and scale-aware discriminator to work on patches of different proportions and spatial positions. Second, we modify the patch sampling strategy based on an annealed beta distribution to stabilize training and accelerate the convergence. The resulting model, named EpiGRAF, is an efficient, high-resolution, pure 3D generator, and we test it on four datasets (two introduced in this work) at $2 5 6 ^ { 2 }$ and $\mathrm { \bar { 5 } 1 2 ^ { 2 } }$ resolutions. It obtains state-of-the-art image quality, high-fidelity geometry and trains ${ \approx } 2 . 5 \times$ faster than the upsampler-based counterparts.
+
+Code/data/visualizations: https://universome.github.io/epigraf
+
+# 1 Introduction
+
+![](images/f59e64d9db29f3ccf0bde54f75ad5db6e3242ced75a04bcc845c1f000c632b14.jpg)  
+Figure 1: We build a pure NeRF-based generator trained in a patch-wise fashion. Left two grids: samples on FFHQ $5 1 \bar { 2 } ^ { 2 }$ $[ [ 2 5 ] ]$ and Cats $2 5 6 ^ { 2 }$ [77]. Middle grids: interpolations between samples on M-Plants and M-Food (upper) and corresponding geometry interpolations (lower). Right grid: background separation examples. In contrast to the upsampler-based methods, one can naturally incorporate the techniques from the traditional NeRF literature into our generator: for background separation, we simply copy-pasted the corresponding code from $_ \mathrm { N e R F + + }$ [76].
+
+Generative models for image synthesis achieved remarkable success in recent years and now enjoy a lot of practical applications $\underline { { \| 5 5 \| } } , \bigstar \|$ . While initially they mainly focused on 2D images [21, 66, 25, 4, 28], recent research explored generative frameworks with partial 3D control over the underlying object in terms of texture/structure decomposition, novel view synthesis or lighting manipulation (e.g., [58, 56, 7, 68, 6, 12, 49]). These techniques are typically built on top of the recently emerged neural radiance fields (NeRF) $\textcircled { \lvert 3 8 \rvert }$ to explicitly represent the object (or its latent features) in 3D space.
+
+NeRF is a powerful framework, which made it possible to build expressive 3D-aware generators from challenging RGB datasets $\mathbb { \left[ 7 \right] } , \overline { { \left[ 1 2 \right] } } , \boxtimes$ . Under the hood, it trains a multi-layer perceptron (MLP) $\mathsf { F } ( \pmb { x } ; \pmb { d } ) = ( \pmb { c } , \sigma )$ to represent a scene by encoding a density $\sigma \in \mathbb { R } _ { + }$ for each coordinate position $\pmb { x } \in \mathbb { R } ^ { 3 }$ and a color value $\boldsymbol { c } \in \mathbb { R } ^ { 3 }$ from $_ { \textbf { \em x } }$ and view direction $\ b { d } \in \mathbb { S } ^ { 2 }$ [38]. To synthesize an image, one renders each pixel independently by casting a ray $r ( q ) = o + q d$ (for $q \in \mathbb { R } _ { + }$ ) from origin $\mathbf { o } \in \mathbb { R } ^ { 3 }$ into the direction $\pmb { d } \in \mathbb { S } ^ { 2 }$ and aggregating many color values along it with their corresponding densities. Such a representation is very expressive but comes at a cost: rendering a single pixel is computationally expensive and makes it intractable to produce a lot of pixels in one forward pass. It is not fatal for reconstruction tasks where the loss can be robustly computed on a subset of pixels, but it creates significant scaling problems for generative NeRFs: they are typically formulated in a GAN-based framework $\pmb { \Vert 4 \Vert }$ with 2D convolutional discriminators requiring an entire image as input.
+
+People address these scaling issues of NeRF-based GANs in different ways. The dominating approach is to train a separate 2D decoder to produce a high-resolution image from a low-resolution image or feature grid rendered from a NeRF backbone $| \check { \mathbb { H } 3 } | |$ . During the past six months, there appeared more than a dozen of methods that follow this paradigm (e.g., [6, 15, 71, 47, 79, 35, 75, 23, 72, 78, 64]). While using the upsampler allows scaling the model to high resolution, it comes with two severe limitations: 1) it breaks the multi-view consistency of a generated object, i.e., its texture and shape change when the camera moves; and 2) the geometry gets only represented in a low resolution $( { \approx } 6 4 ^ { 3 } )$ . In our work, we show that by dropping the upsampler and using a simple patch-wise optimization scheme, one can build a 3D generator with better image quality, faster training speed, and without the above limitations.
+
+Patch-wise training of NeRF-based GANs was initially proposed by GRAF $\pmb { \Vert 5 6 \Vert }$ and got largely neglected by the community since then. The idea is simple: instead of training the generative model on full-size images, one does this on small random crops. Since the model is coordinate-based $\mathbb { B } 9 , \mathbb { G } 5 \mathbb { I }$ , it does not face any issues to synthesize only a subset of pixels. This serves as an excellent way to save computation for both the generator and the discriminator since it makes them both operate on patches of small spatial resolution. To make the generator learn both the texture and the structure, crops are sampled to be of variable scales (but having the same number of pixels). In some sense, this can be seen as optimizing the model on low-resolution images $^ +$ high-resolution patches.
+
+In our work, we improve patch-wise training in two crucial ways. First, we redesign the discriminator by making it better suited to operating on image patches of variable scales and locations. Convolutional filters of a neural network learn to capture different patterns in their inputs depending on their semantic receptive fields $\textcircled { 1 3 0 } , \textcircled { 4 6 } $ . That’s why it is detrimental to reuse the same discriminator to judge both high-resolution local and low-resolution global patches, inducing additional burden on it to mix filters’ responses of different scales. To mitigate this, we propose to modulate the discriminator’s filters with a hypernetwork $\boxed { \boxed { 1 6 } }$ , which predicts which filters to suppress or reinforce from a given patch scale and location.
+
+Second, we change the random scale sampling strategy from an annealed uniform to an annealed beta distribution. Typically, patch scales are sampled from a uniform distribution $s \sim \mathcal { U } [ s ( t ) , 1 ]$ [56, 36, 5], where the minimum scale $s ( t )$ is gradually decreased (i.e. annealed) till some iteration $T$ from $s ( 0 ) = 0 . 9$ to a smaller value $s ( T )$ (in the interval $[ 0 . 1 2 5 - 0 . 5 ] )$ during training. This sampling strategy prevents learning high-frequency details early on in training and puts too little attention on the structure after $s ( t )$ reaches its final value $s ( T )$ . This makes the overall convergence of the generator slower and less stable that’s why we propose to sample patch scales using the beta distribution Beta $( 1 , \beta ( t ) )$ instead, where $\beta ( t )$ is gradually annealed from $\beta ( 0 ) \approx 0$ to some maximum value $\beta ( T )$ . In this way, the model starts learning high-frequency details immediately with the start of training and focuses more on the structure after the growth finishes. This simple change stabilizes the training and allows it to converge faster than the typically used uniform distribution $[ \sqrt { 5 6 } , \textcircled { 5 } , \textcircled { 3 6 } ]$ .
+
+![](images/620af1ff0c6ecdb7ecdd4ec42b22923a93b4ac532cc59df7836ada359d3e06ea.jpg)  
+Figure 2: Comparing the geometry between EG3D $\pmb { \mathbb { H } }$ and our generator on FFHQ $5 1 2 ^ { 2 }$ . For each method, we computed the density field in the $5 1 2 ^ { 3 }$ volume resolution and extracted the surfaces using marching cubes. The geometry of our generator contains more high-frequency details (e.g., hair strands are better separated) since it learns it in full resolution. EG3D uses the $6 4 ^ { 2 }$ rendering resolution (and $1 2 8 ^ { 2 }$ during the last $10 \%$ of the training) so its shapes appear over-smoothed.
+
+We use those two ideas to develop a novel state-of-the-art 3D GAN: Efficient patch-informed Generative Radiance Fields (EpiGRAF). We employ it for high-resolution 3D-aware image synthesis on four datasets: FFHQ $\pm \pmb { \Vert 2 5 \Vert }$ , Cats $\mathbb { [ [ \overline { { ] \mathrm { Z } \mathrm { Z } } } ] ] }$ , Megascans Plants, and Megascans Food. The last two benchmarks are introduced in our work and contain $3 6 0 ^ { \circ }$ renderings of photo-realistic scans of different plants and food objects (described in $\ S 4 )$ . They are much more complex in terms of geometry and are well-suited for assessing the structural limitations of modern 3D-aware generators.
+
+Our model uses a pure NeRF-based backbone, that’s why it represents geometry in high resolution and does not suffer from multi-view synthesis artifacts, as opposed to upsampler-based generators. Moreover, it has higher or comparable image quality (as measured by FID $\bar { \mathbb { I } } \bar { 2 0 } \bar { 1 } .$ ) and $2 . 5 \times$ lower training cost. Also, in contrast to upsampler-based 3D GANs, our generator can naturally incorporate the techniques from the traditional NeRF literature. To demonstrate this, we incorporate background separation into our framework by simply copy-pasting the corresponding code from $_ \mathrm { N e R F + + }$ [76].
+
+# 2 Related work
+
+Neural Radiance Fields. Neural Radiance Fields (NeRF) is an emerging area $\textcircled { \lVert { 3 8 } \rVert }$ , which combines neural networks with volumetric rendering techniques to perform novel-view synthesis [38, 76, 2], image-to-scene generation $\textcircled { 7 4 }$ , surface reconstruction [45, 69, 44] and other tasks [9, 17, 50]. In our work, we employ them in the context of 3D-aware generation from a dataset of RGB images [56, 7].
+
+3D generative models. A popular way to learn a 3D generative model is to train it on 3D data or in an autoencoder’s latent space (e.g., [10, 70, 1, 34, 31, 39, 29]). This requires explicit 3D supervision and there appeared methods which train from RGB datasets with segmentation masks, keypoints or multiple object views [13, 32, 54]. Recently, there appeared works which train from single-view RGB only, including mesh-generation methods [19, 73, 53] and methods that extract 3D structure from pretrained 2D GANs [58, 48]. And recent neural rendering advancements allowed to train NeRF-based generators [56, 7, 42] from purely RGB data from scratch, which became the dominating direction since then and which are typically formulated in the GAN-based framework [14].
+
+NeRF-based GANs. HoloGAN [41] generates a 3D feature voxel grid which is projected on a plane and then upsampled. GRAF [56] trains a noise-conditioned NeRF in an adversarial manner. $\pi$ -GAN $\mathbb { \left[ \bigcirc \right] }$ builds upon it and uses progressive growing and hypernetwork-based $\boxed { 1 1 6 }$ conditioning in the generator. GRAM $\mathbb { \lVert \rVert }$ builds on top of $\pi$ -GAN and samples ray points on a set of learnable iso-surfaces. GNeRF $\pmb { \mathbb { B } } \pmb { \ 6 } \|$ adapts GRAF for learning a scene representation from RGB images without known camera parameters. GIRAFFE $\mathbb { \lVert \boldsymbol { 4 3 } \rVert }$ uses a composite scene representation for better controllability. CAMPARI $\mathbb { H } 2 \mathbb { I }$ learns a camera distribution and a background separation network with inverse sphere parametrization $\pmb { \mathbb { Z } } 6 \|$ . To mitigate the scaling issue of volumetric rendering, many recent works train a 2D decoder under different multi-view consistency regularizations to upsample a low-resolution volumetrically rendered feature grid [6, 15, 71, 47, 79, 72, 78]. However, none of such regularizations can currently provide the multi-view consistency of pure-NeRF-based generators.
+
+![](images/9d6d2edbe3004b25fde84530041ab50bbb67e7e82837b3b718d614beb1352017.jpg)  
+Figure 3: Our generator (left) is purely NeRF-based and uses the tri-plane backbone $\pmb { \mathbb { H } }$ with the StyleGAN2 $\bar { \left\| 2 6 \right\| }$ decoder (but without the 2D upsampler). Our discriminator (right) is also based on StyleGAN2, but is modulated by the patch location and scale parameters. We use the patch-wise optimization for training $\left[ \left[ 5 6 \right] \right]$ with our proposed Beta scale sampling, which allows our model to converge $\times 2 \AA { - 3 }$ faster than the upsampler-based architectures despite the generator modeling geometry in full resolution (see Tab 1).
+
+Patch-wise generative models. Patch-wise training had been routinely utilized to learn the textural component of image distribution when the global structure is provided from segmentation masks, sketches, latents or other sources (e.g., [22, 57, 11, 67, 52, 51, 33, 61]). Recently, there appeared works which sample patches at variable scales, in which way a patch can carry global information about the whole image. Recent works use it to train a generative NeRF [56], fit a neural representation in an adversarial manner $\pmb { \mathbb { B } } 6 \|$ or to train a 2D GAN on a dataset of variable resolution $[ \bar { 1 } \bar { 5 } ]$ .
+
+# 3 Model
+
+We build upon StyleGAN2 $\pmb { \mathbb { Z } } 6 \|$ , replacing its generator with the tri-plane-based NeRF model [6] and using its discriminator as the backbone. We train the model on $r \times r$ patches (we use $r = 6 4$ everywhere) of random scales instead of the full images of resolution $R \times R$ . Scales $s \in [ \frac { r } { R } , 1 ]$ are randomly sampled from a time-varying distribution $s \sim p _ { t } ( s )$ .
+
+# 3.1 3D generator
+
+Compared to upsampler-based 3D GANs [15, 43, 72, 79, 6, 78], we use a pure NeRF $\pmb { \Vert 3 8 \Vert }$ as our generator $\sf G$ and utilize the tri-plane representation $\boxed { 6 } \boxed { 8 } \boxed { }$ as the backbone. It consists of three components: 1) mapping network $\mathsf { M } : \boldsymbol { z } \mapsto \boldsymbol { w }$ which transforms a noise vector $z \sim \mathbb { R } ^ { 5 1 2 }$ into the latent vector $w \sim \mathbb { R } ^ { 5 1 2 }$ ; 2) synthesis network ${ \mathsf { S } } : w \mapsto P$ which takes the latent vector $\pmb { w }$ and synthesizes three 32-dimensional feature planes $P = ( P _ { x y } , P _ { y z } , P _ { x z } )$ of resolution $R _ { p } \times R _ { p }$ (i.e. $P _ { ( * ) } \in \mathbb { R } ^ { R _ { p } \times R _ { p } \times 3 2 } )$ ; 3) tri-plane decoder network $\mathsf { F } : ( \pmb { x } , \pmb { P } ) \mapsto ( \pmb { c } , \pmb { \sigma } ) \in \mathbb { R } ^ { 4 }$ , which takes the space coordinate $\pmb { x } \in \mathbb { R } ^ { 3 }$ and tri-planes $_ { P }$ as input and produces the RGB color $\boldsymbol { c } \in \mathbb { R } ^ { 3 }$ and density value $\sigma \in \mathbb { R } _ { + }$ at that point by interpolating the tri-plane features in the given coordinate and processing them with a tiny MLP. In contrast to classical NeRF $\pmb { \Vert 3 8 \Vert }$ , we do not utilize view direction conditioning since it worsens multi-view consistency $\mathbb { I } \mathbb { I }$ in GANs, which are trained on RGB datasets with a single view per instance. To render a single pixel, we follow the classical volumetric rendering pipeline with hierarchical sampling $\mathbb { B } \boxtimes \perp \|$ , using 48 ray steps in coarse and 48 in fine sampling stages. See the accompanying source code for more details.
+
+![](images/0e35c4b9b31022544d0c2c8f5e4eb9d459b8590dbfff5b29526102f4ecaceee1.jpg)  
+Figure 4: Comparing uniform (left) and beta (middle) annealed patch scale sampling in terms of their probability density function (PDF) (for visualization purposes, we clamp the maximum density value to 5); (right) PDF of Beta $( 1 , \beta )$ , provided for completeness. Uniform distribution with annealed $s _ { \mathrm { m i n } } ( 0 ) = 0 . 9$ from 0.9 to $s _ { \mathrm { m i n } } ( T ) = 0 . 1 2 5$ does not put any attention to high-frequency details in the beginning and treats small-scale and large-scale patches equally at the end of the annealing. Beta distribution with annealed $\beta ( 0 ) \approx 0$ to $\beta ( T ) \approx 1$ , in contrast, lets the model learn high-resolution texture immediately after the training starts, and puts more focus on the structure at the end.
+
+# 3.2 2D scale/location-aware discriminator
+
+Our discriminator $\mathsf { D }$ is built on top of StyleGAN2 $\pmb { \mathbb { Z } } 6 \|$ . Since we train the model in a patch-wise fashion, the original backbone is not well suited for this: convolutional filters are forced to adapt to signals of very different scales and extracted from different locations. A natural way to resolve this problem is to use separate discriminators depending on the scale, but that strategy has three limitations: 1) each particular discriminator receives less overall training signal (since the batch size is limited); 2) from an engineering perspective, it is more expensive to evaluate a convolutional kernel with different parameters on different inputs; 3) one can use only a small fixed amount of possible patch scales. This is why we develop a novel hypernetwork-modulated $\boxed { 1 6 } \boxed { 6 2 } \boxed { 1 }$ discriminator architecture to operate on patches with continuously varying scales.
+
+To modulate the convolutional kernels of $\mathsf { D }$ , we define a hypernetwork $\mathsf { H } : ( s , \delta _ { x } , \delta _ { y } ) : \mapsto ( \pmb { \sigma } _ { 1 } , . . . , \pmb { \sigma } _ { L } )$ as a 2-layer MLP with tanh non-linearity at the end which takes patch scale $s$ and its cropping offsets $\delta _ { x } , \delta _ { y }$ as input and produces modulations $\sigma _ { \ell } \in ( 0 , 2 ) ^ { c _ { \mathrm { { o u t } } } ^ { \ell } }$ (we shift the tanh output by 1 to map into the 1-centered interval), where $c _ { \mathrm { o u t } } ^ { \ell }$ is the number of output channels in the $\ell$ -th convolutional layer. Given a convolutional kernel $W ^ { \ell } \in \mathbb { R } ^ { c _ { \mathrm { o u t } } ^ { \ell } \times c _ { \mathrm { i n } } ^ { \ell } \times k \times k }$ and input $\pmb { x } \in \mathbb { R } ^ { c _ { \mathrm { i n } } }$ , a straightforward strategy to apply the modulation is to multiply $\sigma$ on the weights (depicting the convolution operation by $\mathsf { c o n v 2 d ( . ) }$ and omitting its other parameters for simplicity):
+
+$$
+\begin{array} { r } { \pmb { y } = \mathsf { c o n v 2 d } ( \pmb { W } ^ { \ell } \odot \pmb { \sigma } , \pmb { x } ) , } \end{array}
+$$
+
+where we broadcast the remaining axes and $\ b { y } \in \mathbb { R } ^ { c _ { \mathrm { o u t } } }$ is the layer output (before the non-linearity). However, using different kernel weights on top of different inputs is inefficient in modern deep learning frameworks (even with the group-wise convolution trick $\pmb { \mathbb { Z } } 6 \mathbb { I }$ ). That’s why we use an equivalent strategy of multiplying the weights on $_ { \textbf { \em x } }$ instead:
+
+$$
+\begin{array} { r } { \pmb { y } = \pmb { \sigma } \odot \mathtt { c o n v 2 d } ( \mathbf { W } ^ { \ell } , \pmb { x } ) . } \end{array}
+$$
+
+This suppresses and reinforces different convolutional filters of the layer depending on the patch scale and location. And to incorporate even stronger conditioning, we also use the projection strategy $\pmb { \mathbb { H } }$ in the final discriminator block. We depict our discriminator architecture in $\mathrm { F i g } \ 3 .$ As we show in Tab 2, it allows us to obtain ${ \approx } 1 5 \%$ lower FID compared to the standard discriminator.
+
+# 3.3 Patch-wise optimization with Beta-distributed scales
+
+Training NeRF-based GANs is computationally expensive because rendering each pixel via volumetric rendering requires many evaluations (e.g., in our case, 96) of the underlying MLP. For scene reconstruction tasks, it does not create issues since the typically used $\mathcal { L } _ { 2 }$ loss [38, 76, 69] can be robustly computed on a sparse subset of the pixels. But for NeRF-based GANs, it becomes prohibitively expensive for high resolutions since convolutional discriminators operate on dense full-size images. The currently dominating approach to mitigate this is to train a separate 2D decoder to upsample a low-resolution image representation rendered from a NeRF-based MLP. But this breaks multi-view consistency (i.e., object’s shape and texture change when the camera is moving) and learns the 3D geometry in a low resolution (from ${ \approx } 1 6 ^ { 2 }$ [72] to ${ \approx } 1 2 8 ^ { 2 } \ [ \boxed { 6 } ] .$ ). This is why we build upon the multi-scale patch-wise training scheme $\pmb { \Vert 5 6 \Vert }$ and demonstrate that it can give state-of-the-art image quality and training speed without the above limitations.
+
+Patch-wise optimization works the following way. On each iteration, instead of passing the full-size $R \times R$ image to $\mathsf { D }$ , we instead input only a small patch with resolution $r \times r$ of random scale $s \in [ r / R , 1 ]$ and extracted with a random offset $( \delta _ { x } , \delta _ { y } ) \in [ 0 , 1 - s ] ^ { 2 }$ . We illustrate this procedure in Fig 3. Patch parameters are sampled from distribution:
+
+$$
+s , \delta _ { x } , \delta _ { y } \sim p _ { t } ( s , \delta _ { x } , \delta _ { y } ) \triangleq p _ { t } ( s ) p ( \delta _ { x } | s ) p ( \delta _ { y } | s )
+$$
+
+where $t$ is the current training iteration. In this way, patch scales depend on the current training iteration $t$ , and offsets are sampled independently after we know $s$ . As we show next, the choice of distribution $p _ { t } ( s )$ has a crucial influence on the learning speed and stability.
+
+Typically, patch scales are sampled from the annealed uniform distribution [56, 36, 5] $s$
+
+$$
+p _ { t } ( s ) = U [ s _ { \mathrm { m i n } } ( t ) , 1 ] , \qquad s _ { \mathrm { m i n } } ( t ) = 1 \mathrm { e r p } \left[ 1 , r / R , \mathrm { m i n } ( t / T , 1 ) \right] ,
+$$
+
+where lerp is the linear interpolation function $\displaystyle { } ^ { 1 } ,$ and the left interval bound $s _ { \mathrm { m i n } } ( t )$ is gradually annealed during the first $T$ iterations until it reaches the minimum possible value of $r / R \sharp$ But this strategy does not let the model learn high-frequency details early on in training and puts little focus on the structure when $s _ { \mathrm { m i n } } ( t )$ is fully annealed to $r / R$ (which is usually very small, e.g., $r / R = 0 . 1 2 5$ for a typical $6 4 ^ { 2 }$ patch-wise training on $5 1 2 ^ { 2 }$ resolution). As we show, the first issue makes the generator converge slower, and the second one makes the overall optimization less stable.
+
+To mitigate this, we propose a small change in the pipeline by simply replacing the uniform scale sampling distribution with:
+
+$$
+s \sim \mathrm { B e t a } ( 1 , \beta ( t ) ) \cdot ( 1 - r / R ) + r / R ,
+$$
+
+where $\beta ( t )$ is gradually annealed from $\beta ( 0 )$ to some final value $\beta ( T )$ . Using beta distribution instead of the uniform one gives a very convenient knob to shift the training focus between large patch scales $s \to 1$ (carrying the global information about the whole image) and small patch scales $r \to r / R$ (representing high-resolution local crops).
+
+A natural way to do the annealing is to anneal from 0 to 1: at the start, the model focuses entirely on the structure, while at the end, it transforms into the uniform distribution $( { \mathrm { S e e ~ F i g ~ 4 } } )$ . We follow this strategy, but from the design perspective, set $\beta ( T )$ to a value that is slightly smaller than 1 (we use $\beta ( T ) \stackrel {  } { = } 0 . 8$ everywhere) to keep more focus on the structure at the end of the annealing as well. In our initial experiments, $\beta ( T ) \in \lbrack 0 . 7 , 1 ]$ performs similarly. The scales distributions comparison between beta and uniform sampling is provided in $\mathrm { F i g } 4$ and the convergence comparison in Fig 7.
+
+# 3.4 Training details
+
+We inherit the training procedure from StyleGAN2-ADA $\pm \pm \mathbb { I }$ with minimal changes. The optimization is performed by Adam $\mathbb { \left[ \left[ 2 \right] \right] }$ with a learning rate of 0.002 and betas of 0 and 0.99 for both G and D. We use $\beta ( T ) = 0 . 8$ for $T = 1 0 0 0 0$ , $z \sim \mathcal { N } ( 0 , I )$ and set $R _ { p } = 5 1 2$ . D is trained with R1 regularization $\pmb { \Vert 3 7 } \Vert$ with $\gamma = 0 . 0 5$ . We train with the overall batch size of 64 for ${ \approx } 1 5 \mathbf { M }$ images seen by $\mathsf { D }$ for $2 5 6 ^ { 2 }$ resolution and ${ \approx } 2 0 \mathbf { M }$ for $5 1 2 ^ { 2 }$ . Similar to previous works $[ [ 6 , \boxed { 1 2 } ]$ , we use pose supervision for D for the FFHQ and Cats dataset to avoid geometry ambiguity. For this, we take the rotation and elevation angles, encode them with positional embeddings $\boxed { 5 9 } \boxed { 6 5 }$ and feed them into a 2-layer MLP. After that, we multiply the obtained vector with the last hidden representation in the discriminator, following the Projection GAN $\pmb { \mathbb { H } }$ strategy from StyleGAN2-ADA $\mathbb { \lVert 2 4 \rVert }$ . We train $\sf G$ in full precision and use mixed precision for D. Since FFHQ has too noticeable 3D biases, we use generator pose conditioning for it $\pmb { \Vert 6 \Vert }$ . Further details can be found in the source code.
+
+# 4 Experiments
+
+# 4.1 Experimental setup
+
+Benchmarks. In our study, we consider four benchmarks: 1) FFHQ $\mathbb { \left[ \left[ 2 5 \right] \right] }$ in $2 5 6 ^ { 2 }$ and $5 1 2 ^ { 2 }$ resolutions, consisting of 70,000 (mostly front-view) human face images; 2) Cats $2 5 6 ^ { 2 }$ [77], consisting of 9,998 (mostly front-view) cat face images; 3) Megascans Food (M-Food) $2 5 6 ^ { 2 }$ consisting of 199 models of different food items with 128 views per model (25472 images in total); and 4) Megascans Plants (M-Plants) $2 5 6 ^ { 2 }$ consisting of 1108 different plant models with 128 views per model (141824 images in total). The last two datasets are introduced in our work to fix two issues with the modern 3D generation benchmarks. First, existing benchmarks have low variability of global object geometry, focusing entirely on a single class of objects, like human/cat faces or cars, that do not vary much from instance to instance. Second, they all have limited camera pose distribution: for example, FFHQ $\mathbb { \left[ \left. 2 5 \right] \right. }$ and Cats $\mathbb { \ m }$ are completely dominated by the frontal and near-frontal views (see Appx E). That’s why we obtain and render 1307 Megascans models from Quixel, which are photo-realistic (barely distinguishable from real) scans of real-life objects with complex geometry. Those benchmarks and the rendering code will be made publicly available.
+
+![](images/bee22046870ee0cf3d16ec9ab60e04ab44f2dfdfdb0256d3ee667988e6b1e29e.jpg)  
+Figure 5: Comparing samples of EpiGRAF and modern 3D-aware generators. Our method attains state-of-the-art image quality, recovers high-fidelity geometry and preserves multi-view consistency for both simple-shape (FFHQ and Cats) and variable-shape (M-Plants and M-Food) datasets. We refer the reader to the supplementary for the video comparisons to evaluate multi-view consistency.
+
+Metrics. We use FID $\left[ \left[ 2 0 \right] \right]$ to measure image quality and estimate the training cost for each method in terms of NVidia V100 GPU days needed to complete the training process.
+
+Baselines. For upsampler-based baselines, we compare to the following generators: StyleNeRF [15], StyleSDF [47], EG3D [6], VolumeGAN $\pmb { \mathbb { Z } 1 }$ , MVCGAN $\pmb { \mathbb { Z } } \pmb { 8 } \|$ and GIRAFFE-HD $\Dot { \mathbb { Z } } \Dot { 2 } \mathbb { I }$ . Apart from that, we also compare to pi-GAN $\mathbb { I } \mathbb { I }$ and GRAM $\mathbb { \lVert 1 2 \rVert }$ , which are non-upsampler-based GANs. To compare on Megascans, we train StyleNeRF, MVCGAN, pi-GAN, and GRAM from scratch using their official code repositories (obtained online or requested from the authors), using their FFHQ or CARLA hyperparameters, except for the camera distribution and rendering settings. We also train StyleNeRF, MVCGAN, and $\pi$ -GAN on Cats $2 5 6 ^ { 2 }$ . GRAM $\pmb { \mathbb { I } }$ restricts the sampling space to a set of learnable iso-surfaces, which makes it not well-suited for datasets with varying geometry.
+
+Table 1: FID scores of modern 3D GANs. “ ” evaluated on a re-aligned version of FFHQ (different from original FFHQ $\mathbb { \left[ \left[ 2 5 \right] \right] }$ ). Training cost is measured in terms of NVidia V100 GPU days. “OOM” denotes out-of-memory error.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">FFHQ 5122</td><td rowspan="2">Cats 2562</td><td rowspan="2">M-Plants 2562</td><td rowspan="2">M-Food 2562</td><td colspan="2">Training cost</td><td rowspan="2">Geometry constraints</td></tr><tr><td>2562</td><td></td><td>2562</td><td>5122</td></tr><tr><td>StyleNeRF 因</td><td>8.00</td><td>7.8</td><td>5.91</td><td>19.32</td><td>16.75</td><td>40</td><td>56</td><td>322-res + 2D upsampler</td></tr><tr><td>StyleSDF[47</td><td>11.5</td><td>11.19</td><td>1</td><td>1</td><td>1</td><td>42</td><td>56</td><td>64²-res + 2D upsampler</td></tr><tr><td>EG3D 回</td><td>4.8t</td><td>4.7†</td><td>1</td><td>1</td><td>1</td><td>N/A</td><td>76</td><td>128²-res + 2D upsampler</td></tr><tr><td>VolumeGAN [71]</td><td>9.1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>N/A</td><td>N/A</td><td>64²-res + 2D upsampler</td></tr><tr><td>MVCGAN 因</td><td>13.7</td><td>13.4</td><td>39.16</td><td>31.70</td><td>29.29</td><td>42</td><td>64</td><td>64²-res + 2D upsampler</td></tr><tr><td>GIRAFFE-HD 四</td><td>11.93</td><td>1</td><td>12.36</td><td>1</td><td>1</td><td>N/A</td><td>N/A</td><td>162-res + 2D upsampler</td></tr><tr><td>pi-GAN </td><td>53.2</td><td>OOM</td><td>68.28</td><td>75.64</td><td>51.99</td><td>56</td><td>8</td><td>none</td></tr><tr><td>GRAM [12]</td><td>13.78</td><td>0OM</td><td>13.40</td><td>188.6</td><td>178.9</td><td>56</td><td>8</td><td>iso-surfaces</td></tr><tr><td>EpiGRAF (ours)</td><td>9.71</td><td>9.92</td><td>6.93</td><td>19.42</td><td>18.15</td><td>16</td><td>24</td><td>none</td></tr></table>
+
+![](images/cc382f7806eac50f2c3fefe92be94ce04873b18c8567129c0667ea987c22ba53.jpg)  
+Figure 6: Visualizing the learned geometry for different methods. $\pi$ -GAN [7] recovers high-fidelity shapes, but has worse image quality (see Table $^ { 1 ) }$ and is much more expensive to train than our model. MVC-GAN $ { \mathbb { I } } ^ {  { \mathbb { Z } } 8 \| }$ fails to capture good geometry because of the 2D upsampler. Our method learns proper geometry and achieves state-of-the-art image quality. We extracted the surfaces using marching cubes from the density fields sampled on $2 5 6 ^ { 3 }$ grid and visualized them in PyVista $\pmb { \mathbb { \left| \overline { { 6 3 } } \right\| } }$ . We manually optimized the marching cubes contouring threshold for each checkpoint of each method. We noticed that $\pi$ -GAN [7] produces a lot of “spurious” density which makes.
+
+# 4.2 Results
+
+EpiGRAF achieves state-of-the-art image quality. For Cats $2 5 6 ^ { 2 }$ , M-Plants $2 5 6 ^ { 2 }$ and M-Food $2 5 6 ^ { 2 }$ , EpiGRAF outperforms all the baselines in terms of FID except for StyleNeRF, performing very similar to it on all the datasets even though it does not have a 2D upsampler. For FFHQ, our model attains very similar FID scores as the other methods, ranking 4/9 (including older $\pi$ -GAN [7]), noticeably losing only to EG3D $\textcircled { 6 }$ , which trains and evaluates on a different version of FFHQ and uses pose conditioning in the generator (which potentially improves FID at the cost of multi-view consistency). We provide a visual comparison for different methods in Fig 5.
+
+EpiGRAF is much faster to train. As reported in Tab $\mathbb { J }$ existing methods typically train for ${ \approx } 1$ week on 8 V100s, EpiGRAF finishes training in just 2 days for $2 5 6 ^ { 2 }$ and 3 days for $5 1 2 ^ { \bar { 2 } }$ resolutions, which is $2 - 3 \times$ faster. Note that this high training efficiency is achieved without using an upsampler, which initially enabled the high-resolution synthesis of 3D-aware GANs. As to the non-upsampler methods, we couldn’t train GRAM or $\pi$ -GAN on $5 1 2 ^ { 2 }$ resolution due to the memory limitations of the setup with 8 NVidia V100 32GB GPUs (i.e., 256GB of GPU memory in total).
+
+EpiGRAF learns high-fidelity geometry. Using a pure NeRF-based backbone has two crucial benefits: it provides multi-view consistency and allows learning the geometry in the full dataset resolution. In ${ \mathrm { F i g } } 6 ,$ we visualize the learned shapes on M-Food and M-Plants for 1) $\pi$ -GAN: a pure NeRF-based generator without the geometry constraints; 2) MVC-GAN $ { \mathbb { I } } ^ {  { \mathbb { Z } } 8 \| }$ : an upsampler-based generator with strong multi-view consistency regularization; 3) our model. We provide the details and analysis in the caption of $\operatorname { F i g } \boxed { 6 }$ We also provide the geometry comparison with EG3D on FFHQ $5 1 2 ^ { 2 }$ in Fig 2.
+
+EpiGRAF easily capitalizes on techniques from the NeRF literature. Since our generator is purely NeRF based and renders images without a 2D upsampler, it is well coupled with the existing techniques from the NeRF scene reconstruction field. To demonstrate this, we adopted background separation from $_ \mathrm { N e R F + + }$ [76] using the inverse sphere parametrization by simply copy-pasting the corresponding code from their repo. We depict the results in Fig 1 and provide the details in Appx B.
+
+# 4.3 Ablations
+
+We report the ablations for different discriminator architectures and patch sizes on FFHQ $5 1 2 ^ { 2 }$ and M-Plants $2 5 6 ^ { 2 }$ in $\mathrm { T a b } \bigstar \bigstar$ Using a traditional discriminator architecture results in ${ \approx } 1 5 \%$ worse performance. Using several ones (via the group-wise convolution trick $\mathbb { \left[ \left[ 2 6 \right] \right. }$ ) results in a noticeably slower training time and dramatically degrades the image quality. We hypothesize that the reason for it was the reduced overall training signal each discriminator receives, which we tried to alleviate by increasing their learning rate, but that did not improve the results. A too-small patch size hampers the learning process and produces a ${ \approx } 8 0 \%$ worse FID. A too-large one provides decent image quality but greatly reduces the training speed. Using a single scale/position-aware discriminator achieves the best performance, outperforming the standard one by ${ \approx } 1 5 \%$ on average.
+
+To assess the convergence of our proposed patch sampling scheme, we compared against uniform sampling on Cats $2 5 \bar { 6 } ^ { 2 }$ for $T \in \{ 1 0 0 0 , 5 0 0 0 , 1 0 0 0 0 \}$ , representing different annealing speeds. We show the results for it in $\mathrm { F i g } \ 7 ;$ our proposed beta scale sampling strategy with $T = 1 0 \mathbf { k }$ schedule robustly converges to lower values than the uniform one with $T = 5 \mathrm { k }$ or $T = 1 0 \mathbf { k }$ and does not fluctuate much compared to the $T = 1 k$ uniform one (where the model reached its final annealing stage in just 1k kilo-images seen by D).
+
+To analyze how hyper-modulation manipulates the convolutional filters of the discriminator, we visualize the modulation weights $\sigma$ , predicted by $\mathsf { H }$ , in $\operatorname { F i g } 8$ (see the caption for the details). These visualizations show that some of the filters are always switched on, regardless of the patch scale; while others are always switched off, providing potential room for pruning $\mathbb { \ m }$ . And ${ \approx } 4 0 \%$ of the filters are getting switched on and off depending on the patch scale, which shows that H indeed learns to perform meaningful modulation.
+
+![](images/adef4eab7ec613c8085673a4f960b5eb6125ca54e34e4c26048281a7d3ac72d0.jpg)  
+Figure 7: Convergence comparison on Cats $2 5 6 ^ { 2 }$ for different sampling strategies.
+
+<table><tr><td>Experiment</td><td>FFHQ 512²</td><td>M-Plants 2562</td><td>Training cost</td></tr><tr><td>GRAF(with tri-planes)</td><td>13.41</td><td>24.99</td><td>24</td></tr><tr><td>+ beta scale sampling (T= 5k)</td><td>11.57</td><td>21.77</td><td>24</td></tr><tr><td>+2 scale-specific D-s</td><td>10.87</td><td>21.02</td><td>28</td></tr><tr><td>+ 4 scale-specific D-s</td><td>21.56</td><td>43.11</td><td>28</td></tr><tr><td>+ 1 scale/position-aware D</td><td>9.92</td><td>19.42</td><td>24</td></tr><tr><td>-32² patch resolution</td><td>17.44</td><td>34.32</td><td>19</td></tr><tr><td>- 64² patch resolution (default)</td><td>9.92</td><td>19.42</td><td>24</td></tr><tr><td>-128² patch resolution</td><td>11.36</td><td>18.90</td><td>34</td></tr></table>
+
+![](images/3a11630a476a9c733b727f6bb50eafeb18dd3d4eca53501769a54b51c9d6cf47.jpg)  
+Table 2: Ablating the discriminator architecture and patch sizes in terms of FID scores and training cost (V100 GPU days).   
+Figure 8: Visualizing modulation weights $\pmb { \sigma }$ , predicted by H for 2-nd, 6-th, 10-th and 14-th convolutional layers. Each subplot denotes a separate layer and we visualize random 32 filters for it.
+
+# 5 Limitations
+
+Performance drop for 2D generation. Before switching to training 3D-aware generators, we spent a considerable amount of time, exploring our ideas on top of StyleGAN2 $\bar { \lVert 2 4 \rVert }$ for traditional 2D generation since it is faster, less error-prone and more robust to a hyperparameters choice. What we observed is that despite our best efforts (see C) and even with longer training, we couldn’t obtain the same image quality as the full-resolution StyleGAN2 generator.
+
+Table 3: Trying to train a traditional StyleGAN2 $\pmb { \mathbb { D } } \pmb { 6 } \|$ generator in the patch-wise fashion. We tried to train longer to compensate for a smaller learning signal overall (a $6 4 ^ { \dot { 2 } }$ patch is $1 / 6 4$ of information compared to a $5 1 2 ^ { 2 }$ image), but this didn’t allow to catch up. Note, however, that AnyResGAN [5] reaches SotA when training on $2 5 6 ^ { 2 }$ patches compared to $1 \bar { 0 } 2 4 ^ { 2 }$ images.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">FFHQ 5122</td><td colspan="2">LSUN Bedroom 2562</td></tr><tr><td>FID</td><td>Training cost</td><td>FID</td><td>Training cost</td></tr><tr><td>StyleGAN2-ADA 四</td><td>3.83</td><td>8</td><td>4.12</td><td>5</td></tr><tr><td>+ multi-scale 64² patch-wise training</td><td>7.11</td><td>6</td><td>6.73</td><td>4</td></tr><tr><td>+ ×2 longer training</td><td>5.71</td><td>12</td><td>5.42</td><td>8</td></tr><tr><td>+ ×4 longer training</td><td>4.76</td><td>24</td><td>4.31</td><td>16</td></tr></table>
+
+A range of possible patch sizes is restricted. Tab 2 shows the performance drop when using the $3 2 ^ { 2 }$ patch size instead of the default $6 4 ^ { 2 }$ one without any dramatic improvement in speed. Trying to decrease it further would produce even worse performance (imagine training in the extreme case of $2 ^ { 2 }$ patches). Increasing the patch size is also not desirable since it decreases the training speed a lot: going from $6 4 ^ { 2 }$ to $1 2 8 ^ { \overline { { 2 } } }$ resulted in $30 \%$ cost increase without clear performance benefits. In this way, we are very constrained in what patch size one can use.
+
+Discriminator does not see the global context. When the discriminator classifies patches of small scale, it is forced to do so without relying on the global image information, which could be useful for this. Our attempts to incorporate it (see Appx C) did not improve the performance (though we believe we under-explored this).
+
+Low-resolution artifacts. While our generator achieves good FID on FFHQ $5 1 2 ^ { 2 }$ , we noticed that it has some blurriness when one zooms-in into the samples. It is not well captured by FID since it always resizes images to the $2 9 9 \times 2 9 9$ resolution. We attribute this problem to our patch-wise training scheme, which puts too much focus on the structure and believe that it could be resolved.
+
+# 6 Conclusion
+
+In this work, we showed that it is possible to build a state-of-the-art 3D GAN framework without a 2D upsampler, but using a pure NeRF-based generator trained in a multi-scale patch-wise fashion. For this, we improved the traditional patch-wise training scheme in two important ways. First, we proposed to use a scale/location-aware discriminator with convolutional filters modulated by a hypernetwork depending on the patch parameters. Second, we developed a schedule for patch scale sampling based on the beta distribution, that leads to faster and more robust convergence. We believe that the future of 3D GANs is a combination of efficient volumetric representations, regularized 2D upsamplers, and patch-wise training. We propose this avenue of research for future work.
+
+Our method also has several limitations. Before switching to training 3D-aware generators, we spent a considerable amount of time exploring our ideas on top of StyleGAN2 for traditional 2D generation, which always resulted in higher FID scores. Further, the discriminator loses information about global context. We tried multiple ideas to incorporate global context, but it did not lead to an improvement. Next, our current patch-wise training scheme might cause some low-res artifacts. Finally, 3D GANs generating faces and humans may have negative societal impact as discussed in Appx H.
+
+# 7 Acknowledgements
+
+We would like to acknowledge support from the SDAIA-KAUST Center of Excellence in Data Science and Artificial Intelligence.
+
+# References
+
+[1] P. Achlioptas, O. Diamanti, I. Mitliagkas, and L. Guibas. Learning representations and generative models for 3d point clouds. In International conference on machine learning, pages 40–49. PMLR, 2018. [2] J. T. Barron, B. Mildenhall, M. Tancik, P. Hedman, R. Martin-Brualla, and P. P. Srinivasan. Mip-nerf: A multiscale representation for anti-aliasing neural radiance fields. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 5855–5864, 2021.   
+[3] Blender Online Community. Blender - a 3D modelling and rendering package. Blender Foundation, Blender Institute, Amsterdam, 2022.   
+[4] A. Brock, J. Donahue, and K. Simonyan. Large scale gan training for high fidelity natural image synthesis. arXiv preprint arXiv:1809.11096, 2018.   
+[5] L. Chai, M. Gharbi, E. Shechtman, P. Isola, and R. Zhang. Any-resolution training for high-resolution image synthesis. arXiv preprint arXiv:2204.07156, 2022. [6] E. R. Chan, C. Z. Lin, M. A. Chan, K. Nagano, B. Pan, S. D. Mello, O. Gallo, L. Guibas, J. Tremblay, S. Khamis, T. Karras, and G. Wetzstein. Efficient geometry-aware 3D generative adversarial networks. In arXiv, 2021.   
+[7] E. R. Chan, M. Monteiro, P. Kellnhofer, J. Wu, and G. Wetzstein. pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 5799–5809, 2021.   
+[8] A. Chen, Z. Xu, A. Geiger, J. Yu, and H. Su. Tensorf: Tensorial radiance fields. arXiv preprint arXiv:2203.09517, 2022. [9] H. Chen, B. He, H. Wang, Y. Ren, S.-N. Lim, and A. Shrivastava. Nerv: Neural representations for videos. arXiv preprint arXiv:2110.13903, 2021.   
+[10] Z. Chen and H. Zhang. Learning implicit fields for generative shape modeling. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 5939–5948, 2019.   
+[11] Y. Choi, M. Choi, M. Kim, J.-W. Ha, S. Kim, and J. Choo. Stargan: Unified generative adversarial networks for multi-domain image-to-image translation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 8789–8797, 2018.   
+[12] Y. Deng, J. Yang, J. Xiang, and X. Tong. Gram: Generative radiance manifolds for 3d-aware image generation. In IEEE Computer Vision and Pattern Recognition, 2022.   
+[13] M. Gadelha, S. Maji, and R. Wang. 3d shape induction from 2d views of multiple objects. In 2017 International Conference on 3D Vision (3DV), pages 402–411. IEEE, 2017.   
+[14] I. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial nets. Advances in neural information processing systems, 27, 2014.   
+[15] J. Gu, L. Liu, P. Wang, and C. Theobalt. Stylenerf: A style-based 3d aware generator for high-resolution image synthesis. In International Conference on Learning Representations, 2022.   
+[16] D. Ha, A. Dai, and Q. V. Le. Hypernetworks. arXiv preprint arXiv:1609.09106, 2016.   
+[17] Z. Hao, A. Mallya, S. Belongie, and M.-Y. Liu. GANcraft: Unsupervised 3D Neural Rendering of Minecraft Worlds. In ICCV, 2021.   
+[18] Y. He, X. Zhang, and J. Sun. Channel pruning for accelerating very deep neural networks. In Proceedings of the IEEE international conference on computer vision, pages 1389–1397, 2017.   
+[19] P. Henderson, V. Tsiminaki, and C. H. Lampert. Leveraging 2d data to learn textured 3d mesh generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 7498–7507, 2020.   
+[20] M. Heusel, H. Ramsauer, T. Unterthiner, B. Nessler, and S. Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. Advances in neural information processing systems, 30, 2017.   
+[21] J. Ho, A. Jain, and P. Abbeel. Denoising diffusion probabilistic models. Advances in Neural Information Processing Systems, 33:6840–6851, 2020.   
+[22] P. Isola, J.-Y. Zhu, T. Zhou, and A. A. Efros. Image-to-image translation with conditional adversarial networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1125–1134, 2017.   
+[23] K. Jo, G. Shim, S. Jung, S. Yang, and J. Choo. Cg-nerf: Conditional generative neural radiance fields. arXiv preprint arXiv:2112.03517, 2021.   
+[24] T. Karras, M. Aittala, J. Hellsten, S. Laine, J. Lehtinen, and T. Aila. Training generative adversarial networks with limited data. arXiv preprint arXiv:2006.06676, 2020.   
+[25] T. Karras, S. Laine, and T. Aila. A style-based generator architecture for generative adversarial networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4401–4410, 2019.   
+[26] T. Karras, S. Laine, M. Aittala, J. Hellsten, J. Lehtinen, and T. Aila. Analyzing and improving the image quality of stylegan. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8110–8119, 2020.   
+[27] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+[28] D. P. Kingma and P. Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. Advances in neural information processing systems, 31, 2018.   
+[29] A. R. Kosiorek, H. Strathmann, D. Zoran, P. Moreno, R. Schneider, S. Mokrá, and D. J. Rezende. Nerf-vae: A geometry aware 3d scene generative model. arXiv preprint arXiv:2104.00587, 2021.   
+[30] A. Krizhevsky, I. Sutskever, and G. E. Hinton. Imagenet classification with deep convolutional neural networks. Advances in neural information processing systems, 25, 2012.   
+[31] R. Li, X. Li, K.-H. Hui, and C.-W. Fu. Sp-gan: Sphere-guided 3d shape generation and manipulation. ACM Transactions on Graphics (TOG), 40(4):1–12, 2021.   
+[32] X. Li, Y. Dong, P. Peers, and X. Tong. Synthesizing 3d shapes from silhouette image collections using multiprojection generative adversarial networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 5535–5544, 2019.   
+[33] C. H. Lin, H.-Y. Lee, Y.-C. Cheng, S. Tulyakov, and M.-H. Yang. Infinitygan: Towards infinite-resolution image synthesis. arXiv preprint arXiv:2104.03963, 2021.   
+[34] S. Luo and W. Hu. Diffusion probabilistic models for 3d point cloud generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2021.   
+[35] Y. A. Mejjati, I. Milefchik, A. Gokaslan, O. Wang, K. I. Kim, and J. Tompkin. Gaussigan: Controllable image synthesis with 3d gaussians from unposed silhouettes. arXiv preprint arXiv:2106.13215, 2021.   
+[36] Q. Meng, A. Chen, H. Luo, M. Wu, H. Su, L. Xu, X. He, and J. Yu. Gnerf: Gan-based neural radiance field without posed camera. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 6351–6361, 2021.   
+[37] L. Mescheder, A. Geiger, and S. Nowozin. Which training methods for gans do actually converge? In International conference on machine learning, pages 3481–3490. PMLR, 2018.   
+[38] B. Mildenhall, P. P. Srinivasan, M. Tancik, J. T. Barron, R. Ramamoorthi, and R. Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. In European conference on computer vision, pages 405–421. Springer, 2020.   
+[39] P. Mittal, Y.-C. Cheng, M. Singh, and S. Tulsiani. AutoSDF: Shape priors for 3d completion, reconstruction and generation. In CVPR, 2022.   
+[40] T. Miyato and M. Koyama. cgans with projection discriminator. arXiv preprint arXiv:1802.05637, 2018.   
+[41] T. Nguyen-Phuoc, C. Li, L. Theis, C. Richardt, and Y.-L. Yang. Hologan: Unsupervised learning of 3d representations from natural images. In The IEEE International Conference on Computer Vision (ICCV), Nov 2019.   
+[42] M. Niemeyer and A. Geiger. Campari: Camera-aware decomposed generative neural radiance fields. In 2021 International Conference on 3D Vision (3DV), pages 951–961. IEEE, 2021.   
+[43] M. Niemeyer and A. Geiger. Giraffe: Representing scenes as compositional generative neural feature fields. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11453–11464, 2021.   
+[44] M. Niemeyer, L. Mescheder, M. Oechsle, and A. Geiger. Differentiable volumetric rendering: Learning implicit 3d representations without 3d supervision. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 3504–3515, 2020.   
+[45] M. Oechsle, S. Peng, and A. Geiger. Unisurf: Unifying neural implicit surfaces and radiance fields for multi-view reconstruction. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 5589–5599, 2021.   
+[46] C. Olah, A. Mordvintsev, and L. Schubert. Feature visualization. Distill, 2017. https://distill.pub/2017/feature-visualization.   
+[47] R. Or-El, X. Luo, M. Shan, E. Shechtman, J. J. Park, and I. Kemelmacher-Shlizerman. StyleSDF: High-Resolution 3D-Consistent Image and Geometry Generation. arXiv preprint arXiv:2112.11427, 2021.   
+[48] X. Pan, B. Dai, Z. Liu, C. C. Loy, and P. Luo. Do 2d gans know 3d shape? unsupervised 3d shape reconstruction from 2d image gans. arXiv preprint arXiv:2011.00844, 2020. accurate 3d-aware image synthesis. In Advances in Neural Information Processing Systems (NeurIPS), 2021.   
+[50] K. Park, U. Sinha, J. T. Barron, S. Bouaziz, D. B. Goldman, S. M. Seitz, and R. Martin-Brualla. Deformable neural radiance fields. arXiv preprint arXiv:2011.12948, 2020.   
+[51] T. Park, M.-Y. Liu, T.-C. Wang, and J.-Y. Zhu. Semantic image synthesis with spatially-adaptive normalization. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 2337–2346, 2019.   
+[52] T. Park, J.-Y. Zhu, O. Wang, J. Lu, E. Shechtman, A. Efros, and R. Zhang. Swapping autoencoder for deep image manipulation. Advances in Neural Information Processing Systems, 33:7198–7211, 2020.   
+[53] D. Pavllo, J. Kohler, T. Hofmann, and A. Lucchi. Learning generative models of textured 3d meshes from real-world images. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 13879–13889, October 2021.   
+[54] D. Pavllo, G. Spinks, T. Hofmann, M.-F. Moens, and A. Lucchi. Convolutional generation of textured 3d meshes. In Neural Information Processing Systems (NeurIPS), 2020.   
+[55] A. Ramesh, P. Dhariwal, A. Nichol, C. Chu, and M. Chen. Hierarchical text-conditional image generation with clip latents. arXiv preprint arXiv:2204.06125, 2022.   
+[56] K. Schwarz, Y. Liao, M. Niemeyer, and A. Geiger. Graf: Generative radiance fields for 3d-aware image synthesis. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   
+[57] T. R. Shaham, T. Dekel, and T. Michaeli. Singan: Learning a generative model from a single natural image. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 4570–4580, 2019.   
+[58] Y. Shi, D. Aggarwal, and A. K. Jain. Lifting 2d stylegan for 3d-aware face generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 6258–6266, 2021.   
+[59] V. Sitzmann, J. Martel, A. Bergman, D. Lindell, and G. Wetzstein. Implicit neural representations with periodic activation functions. Advances in Neural Information Processing Systems, 33, 2020.   
+[60] I. Skorokhodov, S. Ignatyev, and M. Elhoseiny. Adversarial generation of continuous images. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10753–10764, 2021.   
+[61] I. Skorokhodov, G. Sotnikov, and M. Elhoseiny. Aligning latent and image spaces to connect the unconnectable. arXiv preprint arXiv:2104.06954, 2021.   
+[62] I. Skorokhodov, S. Tulyakov, and M. Elhoseiny. Stylegan-v: A continuous video generator with the price, image quality and perks of stylegan2. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 3626–3636, 2022.   
+[63] C. B. Sullivan and A. Kaszynski. PyVista: 3d plotting and mesh analysis through a streamlined interface for the visualization toolkit (VTK). Journal of Open Source Software, 4(37):1450, may 2019.   
+[64] F. Tan, S. Fanello, A. Meka, S. Orts-Escolano, D. Tang, R. Pandey, J. Taylor, P. Tan, and Y. Zhang. Volux-gan: A generative model for 3d face synthesis with hdri relighting. arXiv preprint arXiv:2201.04873, 2022.   
+[65] M. Tancik, P. P. Srinivasan, B. Mildenhall, S. Fridovich-Keil, N. Raghavan, U. Singhal, R. Ramamoorthi, J. T. Barron, and R. Ng. Fourier features let networks learn high frequency functions in low dimensional domains. arXiv preprint arXiv:2006.10739, 2020.   
+[66] A. Van den Oord, N. Kalchbrenner, L. Espeholt, O. Vinyals, A. Graves, et al. Conditional image generation with pixelcnn decoders. Advances in neural information processing systems, 29, 2016.   
+[67] Y. Vinker, E. Horwitz, N. Zabari, and Y. Hoshen. Image shape manipulation from a single augmented training sample. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 13769–13778, October 2021.   
+[68] C. Wang, M. Chai, M. He, D. Chen, and J. Liao. Clip-nerf: Text-and-image driven manipulation of neural radiance fields. arXiv preprint arXiv:2112.05139, 2021.   
+[69] P. Wang, L. Liu, Y. Liu, C. Theobalt, T. Komura, and W. Wang. Neus: Learning neural implicit surfaces by volume rendering for multi-view reconstruction. arXiv preprint arXiv:2106.10689, 2021.   
+[70] Z. Wu, S. Song, A. Khosla, F. Yu, L. Zhang, X. Tang, and J. Xiao. 3d shapenets: A deep representation for volumetric shapes. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1912–1920, 2015.   
+[71] Y. Xu, S. Peng, C. Yang, Y. Shen, and B. Zhou. 3d-aware image synthesis via learning structural and textural representations. arXiv preprint arXiv:2112.10759, 2021.   
+[72] Y. Xue, Y. Li, K. K. Singh, and Y. J. Lee. Giraffe hd: A high-resolution 3d-aware generative model. arXiv preprint arXiv:2203.14954, 2022.   
+[73] Y. Ye, S. Tulsiani, and A. Gupta. Shelf-supervised mesh prediction in the wild. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 8843–8852, June 2021.   
+[74] A. Yu, V. Ye, M. Tancik, and A. Kanazawa. pixelnerf: Neural radiance fields from one or few images. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 4578–4587, June 2021.   
+[75] J. Zhang, E. Sangineto, H. Tang, A. Siarohin, Z. Zhong, N. Sebe, and W. Wang. 3d-aware semantic-guided generative model for human synthesis. arXiv preprint arXiv:2112.01422, 2021.   
+[76] K. Zhang, G. Riegler, N. Snavely, and V. Koltun. Nerf++: Analyzing and improving neural radiance fields. arXiv preprint arXiv:2010.07492, 2020.   
+[77] W. Zhang, J. Sun, and X. Tang. Cat head detection-how to effectively exploit shape and texture features. In European conference on computer vision, pages 802–816. Springer, 2008.   
+[78] X. Zhang, Z. Zheng, D. Gao, B. Zhang, P. Pan, and Y. Yang. Multi-view consistent generative adversarial networks for 3d-aware image synthesis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2022.   
+[79] P. Zhou, L. Xie, B. Ni, and Q. Tian. Cips-3d: A 3d-aware generator of gans based on conditionallyindependent pixel synthesis. arXiv preprint arXiv:2110.09788, 2021.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] See §5 and Appx A.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] We do this in Appendix G.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] We discuss the potential ethical concerns of using our model in Appendix G.
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] We provide the code/data and additional visualizations on https://universome.github.io/epigraf(as specified in the introduction).   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We provide the most important training details in $\ S 3 . 4 .$ The rest of the details are provided in Appx B and the provided source code.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] . That’s too computationally expensive and single-run results are typically reliable in the GAN field.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] We report this numbers in Appx B.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] We cite all the sources of the datasets which were used or mentioned in our submission.   
+(b) Did you mention the license of the assets? [Yes] In this work, we release two new datasets: Megascans Plants and Megascans Food. We discuss their licensing in Appx E.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We provide our datasets on the project website: https://universome.github.io/epigraf.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] We specify the information on dataset collection in Appx E.   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [Yes] As discussed in Appx E, the released data does not contain personally identifiable information or offensive content.
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/dev/TTM7iEFOTzJ/TTM7iEFOTzJ_content_list.json

@@ -0,0 +1,1187 @@
+[
+    {
+        "type": "text",
+        "text": "EpiGRAF: Rethinking training of 3D GANs ",
+        "text_level": 1,
+        "bbox": [
+            230,
+            122,
+            767,
+            148
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ivan Skorokhodov KAUST ",
+        "bbox": [
+            217,
+            200,
+            346,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sergey Tulyakov Snap Inc. ",
+        "bbox": [
+            392,
+            202,
+            509,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yiqun Wang KAUST ",
+        "bbox": [
+            557,
+            200,
+            647,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Peter Wonka KAUST ",
+        "bbox": [
+            691,
+            202,
+            784,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            265,
+            535,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A recent trend in generative modeling is building 3D-aware generators from 2D image collections. To induce the 3D bias, such models typically rely on volumetric rendering, which is expensive to employ at high resolutions. Over the past months, more than ten works have addressed this scaling issue by training a separate 2D decoder to upsample a low-resolution image (or a feature tensor) produced from a pure 3D generator. But this solution comes at a cost: not only does it break multi-view consistency (i.e., shape and texture change when the camera moves), but it also learns geometry in low fidelity. In this work, we show that obtaining a high-resolution 3D generator with SotA image quality is possible by following a completely different route of simply training the model patch-wise. We revisit and improve this optimization scheme in two ways. First, we design a location- and scale-aware discriminator to work on patches of different proportions and spatial positions. Second, we modify the patch sampling strategy based on an annealed beta distribution to stabilize training and accelerate the convergence. The resulting model, named EpiGRAF, is an efficient, high-resolution, pure 3D generator, and we test it on four datasets (two introduced in this work) at $2 5 6 ^ { 2 }$ and $\\mathrm { \\bar { 5 } 1 2 ^ { 2 } }$ resolutions. It obtains state-of-the-art image quality, high-fidelity geometry and trains ${ \\approx } 2 . 5 \\times$ faster than the upsampler-based counterparts. ",
+        "bbox": [
+            232,
+            296,
+            766,
+            545
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Code/data/visualizations: https://universome.github.io/epigraf ",
+        "bbox": [
+            295,
+            554,
+            702,
+            569
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            595,
+            312,
+            612
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/f59e64d9db29f3ccf0bde54f75ad5db6e3242ced75a04bcc845c1f000c632b14.jpg",
+        "image_caption": [
+            "Figure 1: We build a pure NeRF-based generator trained in a patch-wise fashion. Left two grids: samples on FFHQ $5 1 \\bar { 2 } ^ { 2 }$ $[ [ 2 5 ] ]$ and Cats $2 5 6 ^ { 2 }$ [77]. Middle grids: interpolations between samples on M-Plants and M-Food (upper) and corresponding geometry interpolations (lower). Right grid: background separation examples. In contrast to the upsampler-based methods, one can naturally incorporate the techniques from the traditional NeRF literature into our generator: for background separation, we simply copy-pasted the corresponding code from $_ \\mathrm { N e R F + + }$ [76]. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            632,
+            825,
+            808
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative models for image synthesis achieved remarkable success in recent years and now enjoy a lot of practical applications $\\underline { { \\| 5 5 \\| } } , \\bigstar \\|$ . While initially they mainly focused on 2D images [21, 66, 25, 4, 28], recent research explored generative frameworks with partial 3D control over the underlying object in terms of texture/structure decomposition, novel view synthesis or lighting manipulation (e.g., [58, 56, 7, 68, 6, 12, 49]). These techniques are typically built on top of the recently emerged neural radiance fields (NeRF) $\\textcircled { \\lvert 3 8 \\rvert }$ to explicitly represent the object (or its latent features) in 3D space. ",
+        "bbox": [
+            173,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "NeRF is a powerful framework, which made it possible to build expressive 3D-aware generators from challenging RGB datasets $\\mathbb { \\left[ 7 \\right] } , \\overline { { \\left[ 1 2 \\right] } } , \\boxtimes$ . Under the hood, it trains a multi-layer perceptron (MLP) $\\mathsf { F } ( \\pmb { x } ; \\pmb { d } ) = ( \\pmb { c } , \\sigma )$ to represent a scene by encoding a density $\\sigma \\in \\mathbb { R } _ { + }$ for each coordinate position $\\pmb { x } \\in \\mathbb { R } ^ { 3 }$ and a color value $\\boldsymbol { c } \\in \\mathbb { R } ^ { 3 }$ from $_ { \\textbf { \\em x } }$ and view direction $\\ b { d } \\in \\mathbb { S } ^ { 2 }$ [38]. To synthesize an image, one renders each pixel independently by casting a ray $r ( q ) = o + q d$ (for $q \\in \\mathbb { R } _ { + }$ ) from origin $\\mathbf { o } \\in \\mathbb { R } ^ { 3 }$ into the direction $\\pmb { d } \\in \\mathbb { S } ^ { 2 }$ and aggregating many color values along it with their corresponding densities. Such a representation is very expressive but comes at a cost: rendering a single pixel is computationally expensive and makes it intractable to produce a lot of pixels in one forward pass. It is not fatal for reconstruction tasks where the loss can be robustly computed on a subset of pixels, but it creates significant scaling problems for generative NeRFs: they are typically formulated in a GAN-based framework $\\pmb { \\Vert 4 \\Vert }$ with 2D convolutional discriminators requiring an entire image as input. ",
+        "bbox": [
+            173,
+            194,
+            826,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "People address these scaling issues of NeRF-based GANs in different ways. The dominating approach is to train a separate 2D decoder to produce a high-resolution image from a low-resolution image or feature grid rendered from a NeRF backbone $| \\check { \\mathbb { H } 3 } | |$ . During the past six months, there appeared more than a dozen of methods that follow this paradigm (e.g., [6, 15, 71, 47, 79, 35, 75, 23, 72, 78, 64]). While using the upsampler allows scaling the model to high resolution, it comes with two severe limitations: 1) it breaks the multi-view consistency of a generated object, i.e., its texture and shape change when the camera moves; and 2) the geometry gets only represented in a low resolution $( { \\approx } 6 4 ^ { 3 } )$ . In our work, we show that by dropping the upsampler and using a simple patch-wise optimization scheme, one can build a 3D generator with better image quality, faster training speed, and without the above limitations. ",
+        "bbox": [
+            173,
+            353,
+            825,
+            491
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Patch-wise training of NeRF-based GANs was initially proposed by GRAF $\\pmb { \\Vert 5 6 \\Vert }$ and got largely neglected by the community since then. The idea is simple: instead of training the generative model on full-size images, one does this on small random crops. Since the model is coordinate-based $\\mathbb { B } 9 , \\mathbb { G } 5 \\mathbb { I }$ , it does not face any issues to synthesize only a subset of pixels. This serves as an excellent way to save computation for both the generator and the discriminator since it makes them both operate on patches of small spatial resolution. To make the generator learn both the texture and the structure, crops are sampled to be of variable scales (but having the same number of pixels). In some sense, this can be seen as optimizing the model on low-resolution images $^ +$ high-resolution patches. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            609
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In our work, we improve patch-wise training in two crucial ways. First, we redesign the discriminator by making it better suited to operating on image patches of variable scales and locations. Convolutional filters of a neural network learn to capture different patterns in their inputs depending on their semantic receptive fields $\\textcircled { 1 3 0 } , \\textcircled { 4 6 } $ . That’s why it is detrimental to reuse the same discriminator to judge both high-resolution local and low-resolution global patches, inducing additional burden on it to mix filters’ responses of different scales. To mitigate this, we propose to modulate the discriminator’s filters with a hypernetwork $\\boxed { \\boxed { 1 6 } }$ , which predicts which filters to suppress or reinforce from a given patch scale and location. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            726
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Second, we change the random scale sampling strategy from an annealed uniform to an annealed beta distribution. Typically, patch scales are sampled from a uniform distribution $s \\sim \\mathcal { U } [ s ( t ) , 1 ]$ [56, 36, 5], where the minimum scale $s ( t )$ is gradually decreased (i.e. annealed) till some iteration $T$ from $s ( 0 ) = 0 . 9$ to a smaller value $s ( T )$ (in the interval $[ 0 . 1 2 5 - 0 . 5 ] )$ during training. This sampling strategy prevents learning high-frequency details early on in training and puts too little attention on the structure after $s ( t )$ reaches its final value $s ( T )$ . This makes the overall convergence of the generator slower and less stable that’s why we propose to sample patch scales using the beta distribution Beta $( 1 , \\beta ( t ) )$ instead, where $\\beta ( t )$ is gradually annealed from $\\beta ( 0 ) \\approx 0$ to some maximum value $\\beta ( T )$ . In this way, the model starts learning high-frequency details immediately with the start of training and focuses more on the structure after the growth finishes. This simple change stabilizes the training and allows it to converge faster than the typically used uniform distribution $[ \\sqrt { 5 6 } , \\textcircled { 5 } , \\textcircled { 3 6 } ]$ . ",
+        "bbox": [
+            173,
+            732,
+            825,
+            885
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/620af1ff0c6ecdb7ecdd4ec42b22923a93b4ac532cc59df7836ada359d3e06ea.jpg",
+        "image_caption": [
+            "Figure 2: Comparing the geometry between EG3D $\\pmb { \\mathbb { H } }$ and our generator on FFHQ $5 1 2 ^ { 2 }$ . For each method, we computed the density field in the $5 1 2 ^ { 3 }$ volume resolution and extracted the surfaces using marching cubes. The geometry of our generator contains more high-frequency details (e.g., hair strands are better separated) since it learns it in full resolution. EG3D uses the $6 4 ^ { 2 }$ rendering resolution (and $1 2 8 ^ { 2 }$ during the last $10 \\%$ of the training) so its shapes appear over-smoothed. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            85,
+            823,
+            352
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use those two ideas to develop a novel state-of-the-art 3D GAN: Efficient patch-informed Generative Radiance Fields (EpiGRAF). We employ it for high-resolution 3D-aware image synthesis on four datasets: FFHQ $\\pm \\pmb { \\Vert 2 5 \\Vert }$ , Cats $\\mathbb { [ [ \\overline { { ] \\mathrm { Z } \\mathrm { Z } } } ] ] }$ , Megascans Plants, and Megascans Food. The last two benchmarks are introduced in our work and contain $3 6 0 ^ { \\circ }$ renderings of photo-realistic scans of different plants and food objects (described in $\\ S 4 )$ . They are much more complex in terms of geometry and are well-suited for assessing the structural limitations of modern 3D-aware generators. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            542
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our model uses a pure NeRF-based backbone, that’s why it represents geometry in high resolution and does not suffer from multi-view synthesis artifacts, as opposed to upsampler-based generators. Moreover, it has higher or comparable image quality (as measured by FID $\\bar { \\mathbb { I } } \\bar { 2 0 } \\bar { 1 } .$ ) and $2 . 5 \\times$ lower training cost. Also, in contrast to upsampler-based 3D GANs, our generator can naturally incorporate the techniques from the traditional NeRF literature. To demonstrate this, we incorporate background separation into our framework by simply copy-pasting the corresponding code from $_ \\mathrm { N e R F + + }$ [76]. ",
+        "bbox": [
+            174,
+            549,
+            825,
+            633
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            656,
+            316,
+            672
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Neural Radiance Fields. Neural Radiance Fields (NeRF) is an emerging area $\\textcircled { \\lVert { 3 8 } \\rVert }$ , which combines neural networks with volumetric rendering techniques to perform novel-view synthesis [38, 76, 2], image-to-scene generation $\\textcircled { 7 4 }$ , surface reconstruction [45, 69, 44] and other tasks [9, 17, 50]. In our work, we employ them in the context of 3D-aware generation from a dataset of RGB images [56, 7]. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            746
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3D generative models. A popular way to learn a 3D generative model is to train it on 3D data or in an autoencoder’s latent space (e.g., [10, 70, 1, 34, 31, 39, 29]). This requires explicit 3D supervision and there appeared methods which train from RGB datasets with segmentation masks, keypoints or multiple object views [13, 32, 54]. Recently, there appeared works which train from single-view RGB only, including mesh-generation methods [19, 73, 53] and methods that extract 3D structure from pretrained 2D GANs [58, 48]. And recent neural rendering advancements allowed to train NeRF-based generators [56, 7, 42] from purely RGB data from scratch, which became the dominating direction since then and which are typically formulated in the GAN-based framework [14]. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            863
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "NeRF-based GANs. HoloGAN [41] generates a 3D feature voxel grid which is projected on a plane and then upsampled. GRAF [56] trains a noise-conditioned NeRF in an adversarial manner. $\\pi$ -GAN $\\mathbb { \\left[ \\bigcirc \\right] }$ builds upon it and uses progressive growing and hypernetwork-based $\\boxed { 1 1 6 }$ conditioning in the generator. GRAM $\\mathbb { \\lVert \\rVert }$ builds on top of $\\pi$ -GAN and samples ray points on a set of learnable iso-surfaces. GNeRF $\\pmb { \\mathbb { B } } \\pmb { \\ 6 } \\|$ adapts GRAF for learning a scene representation from RGB images without known camera parameters. GIRAFFE $\\mathbb { \\lVert \\boldsymbol { 4 3 } \\rVert }$ uses a composite scene representation for better controllability. CAMPARI $\\mathbb { H } 2 \\mathbb { I }$ learns a camera distribution and a background separation network with inverse sphere parametrization $\\pmb { \\mathbb { Z } } 6 \\|$ . To mitigate the scaling issue of volumetric rendering, many recent works train a 2D decoder under different multi-view consistency regularizations to upsample a low-resolution volumetrically rendered feature grid [6, 15, 71, 47, 79, 72, 78]. However, none of such regularizations can currently provide the multi-view consistency of pure-NeRF-based generators. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/9d6d2edbe3004b25fde84530041ab50bbb67e7e82837b3b718d614beb1352017.jpg",
+        "image_caption": [
+            "Figure 3: Our generator (left) is purely NeRF-based and uses the tri-plane backbone $\\pmb { \\mathbb { H } }$ with the StyleGAN2 $\\bar { \\left\\| 2 6 \\right\\| }$ decoder (but without the 2D upsampler). Our discriminator (right) is also based on StyleGAN2, but is modulated by the patch location and scale parameters. We use the patch-wise optimization for training $\\left[ \\left[ 5 6 \\right] \\right]$ with our proposed Beta scale sampling, which allows our model to converge $\\times 2 \\AA { - 3 }$ faster than the upsampler-based architectures despite the generator modeling geometry in full resolution (see Tab 1). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            825,
+            244
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            366,
+            825,
+            478
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Patch-wise generative models. Patch-wise training had been routinely utilized to learn the textural component of image distribution when the global structure is provided from segmentation masks, sketches, latents or other sources (e.g., [22, 57, 11, 67, 52, 51, 33, 61]). Recently, there appeared works which sample patches at variable scales, in which way a patch can carry global information about the whole image. Recent works use it to train a generative NeRF [56], fit a neural representation in an adversarial manner $\\pmb { \\mathbb { B } } 6 \\|$ or to train a 2D GAN on a dataset of variable resolution $[ \\bar { 1 } \\bar { 5 } ]$ . ",
+        "bbox": [
+            174,
+            483,
+            825,
+            566
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Model ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            590,
+            259,
+            607
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We build upon StyleGAN2 $\\pmb { \\mathbb { Z } } 6 \\|$ , replacing its generator with the tri-plane-based NeRF model [6] and using its discriminator as the backbone. We train the model on $r \\times r$ patches (we use $r = 6 4$ everywhere) of random scales instead of the full images of resolution $R \\times R$ . Scales $s \\in [ \\frac { r } { R } , 1 ]$ are randomly sampled from a time-varying distribution $s \\sim p _ { t } ( s )$ . ",
+        "bbox": [
+            174,
+            623,
+            825,
+            680
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 3D generator ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            700,
+            303,
+            715
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Compared to upsampler-based 3D GANs [15, 43, 72, 79, 6, 78], we use a pure NeRF $\\pmb { \\Vert 3 8 \\Vert }$ as our generator $\\sf G$ and utilize the tri-plane representation $\\boxed { 6 } \\boxed { 8 } \\boxed { }$ as the backbone. It consists of three components: 1) mapping network $\\mathsf { M } : \\boldsymbol { z } \\mapsto \\boldsymbol { w }$ which transforms a noise vector $z \\sim \\mathbb { R } ^ { 5 1 2 }$ into the latent vector $w \\sim \\mathbb { R } ^ { 5 1 2 }$ ; 2) synthesis network ${ \\mathsf { S } } : w \\mapsto P$ which takes the latent vector $\\pmb { w }$ and synthesizes three 32-dimensional feature planes $P = ( P _ { x y } , P _ { y z } , P _ { x z } )$ of resolution $R _ { p } \\times R _ { p }$ (i.e. $P _ { ( * ) } \\in \\mathbb { R } ^ { R _ { p } \\times R _ { p } \\times 3 2 } )$ ; 3) tri-plane decoder network $\\mathsf { F } : ( \\pmb { x } , \\pmb { P } ) \\mapsto ( \\pmb { c } , \\pmb { \\sigma } ) \\in \\mathbb { R } ^ { 4 }$ , which takes the space coordinate $\\pmb { x } \\in \\mathbb { R } ^ { 3 }$ and tri-planes $_ { P }$ as input and produces the RGB color $\\boldsymbol { c } \\in \\mathbb { R } ^ { 3 }$ and density value $\\sigma \\in \\mathbb { R } _ { + }$ at that point by interpolating the tri-plane features in the given coordinate and processing them with a tiny MLP. In contrast to classical NeRF $\\pmb { \\Vert 3 8 \\Vert }$ , we do not utilize view direction conditioning since it worsens multi-view consistency $\\mathbb { I } \\mathbb { I }$ in GANs, which are trained on RGB datasets with a single view per instance. To render a single pixel, we follow the classical volumetric rendering pipeline with hierarchical sampling $\\mathbb { B } \\boxtimes \\perp \\|$ , using 48 ray steps in coarse and 48 in fine sampling stages. See the accompanying source code for more details. ",
+        "bbox": [
+            173,
+            726,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/0e35c4b9b31022544d0c2c8f5e4eb9d459b8590dbfff5b29526102f4ecaceee1.jpg",
+        "image_caption": [
+            "Figure 4: Comparing uniform (left) and beta (middle) annealed patch scale sampling in terms of their probability density function (PDF) (for visualization purposes, we clamp the maximum density value to 5); (right) PDF of Beta $( 1 , \\beta )$ , provided for completeness. Uniform distribution with annealed $s _ { \\mathrm { m i n } } ( 0 ) = 0 . 9$ from 0.9 to $s _ { \\mathrm { m i n } } ( T ) = 0 . 1 2 5$ does not put any attention to high-frequency details in the beginning and treats small-scale and large-scale patches equally at the end of the annealing. Beta distribution with annealed $\\beta ( 0 ) \\approx 0$ to $\\beta ( T ) \\approx 1$ , in contrast, lets the model learn high-resolution texture immediately after the training starts, and puts more focus on the structure at the end. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            87,
+            826,
+            195
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 2D scale/location-aware discriminator ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            324,
+            475,
+            339
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our discriminator $\\mathsf { D }$ is built on top of StyleGAN2 $\\pmb { \\mathbb { Z } } 6 \\|$ . Since we train the model in a patch-wise fashion, the original backbone is not well suited for this: convolutional filters are forced to adapt to signals of very different scales and extracted from different locations. A natural way to resolve this problem is to use separate discriminators depending on the scale, but that strategy has three limitations: 1) each particular discriminator receives less overall training signal (since the batch size is limited); 2) from an engineering perspective, it is more expensive to evaluate a convolutional kernel with different parameters on different inputs; 3) one can use only a small fixed amount of possible patch scales. This is why we develop a novel hypernetwork-modulated $\\boxed { 1 6 } \\boxed { 6 2 } \\boxed { 1 }$ discriminator architecture to operate on patches with continuously varying scales. ",
+        "bbox": [
+            173,
+            348,
+            825,
+            476
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To modulate the convolutional kernels of $\\mathsf { D }$ , we define a hypernetwork $\\mathsf { H } : ( s , \\delta _ { x } , \\delta _ { y } ) : \\mapsto ( \\pmb { \\sigma } _ { 1 } , . . . , \\pmb { \\sigma } _ { L } )$ as a 2-layer MLP with tanh non-linearity at the end which takes patch scale $s$ and its cropping offsets $\\delta _ { x } , \\delta _ { y }$ as input and produces modulations $\\sigma _ { \\ell } \\in ( 0 , 2 ) ^ { c _ { \\mathrm { { o u t } } } ^ { \\ell } }$ (we shift the tanh output by 1 to map into the 1-centered interval), where $c _ { \\mathrm { o u t } } ^ { \\ell }$ is the number of output channels in the $\\ell$ -th convolutional layer. Given a convolutional kernel $W ^ { \\ell } \\in \\mathbb { R } ^ { c _ { \\mathrm { o u t } } ^ { \\ell } \\times c _ { \\mathrm { i n } } ^ { \\ell } \\times k \\times k }$ and input $\\pmb { x } \\in \\mathbb { R } ^ { c _ { \\mathrm { i n } } }$ , a straightforward strategy to apply the modulation is to multiply $\\sigma$ on the weights (depicting the convolution operation by $\\mathsf { c o n v 2 d ( . ) }$ and omitting its other parameters for simplicity): ",
+        "bbox": [
+            173,
+            481,
+            825,
+            587
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/56113af6027c28bc00924327e6e180bdfc96cd3969abb9b97d5ceabcbb54ae8d.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pmb { y } = \\mathsf { c o n v 2 d } ( \\pmb { W } ^ { \\ell } \\odot \\pmb { \\sigma } , \\pmb { x } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            592,
+            588,
+            611
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where we broadcast the remaining axes and $\\ b { y } \\in \\mathbb { R } ^ { c _ { \\mathrm { o u t } } }$ is the layer output (before the non-linearity). However, using different kernel weights on top of different inputs is inefficient in modern deep learning frameworks (even with the group-wise convolution trick $\\pmb { \\mathbb { Z } } 6 \\mathbb { I }$ ). That’s why we use an equivalent strategy of multiplying the weights on $_ { \\textbf { \\em x } }$ instead: ",
+        "bbox": [
+            173,
+            616,
+            825,
+            672
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7b03383f7be9ce4f94f127e84b3365f2e192eb4ab6c0bab2b53938088ca6539a.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pmb { y } = \\pmb { \\sigma } \\odot \\mathtt { c o n v 2 d } ( \\mathbf { W } ^ { \\ell } , \\pmb { x } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            679,
+            589,
+            696
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This suppresses and reinforces different convolutional filters of the layer depending on the patch scale and location. And to incorporate even stronger conditioning, we also use the projection strategy $\\pmb { \\mathbb { H } }$ in the final discriminator block. We depict our discriminator architecture in $\\mathrm { F i g } \\ 3 .$ As we show in Tab 2, it allows us to obtain ${ \\approx } 1 5 \\%$ lower FID compared to the standard discriminator. ",
+        "bbox": [
+            174,
+            703,
+            825,
+            760
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Patch-wise optimization with Beta-distributed scales ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            773,
+            576,
+            790
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training NeRF-based GANs is computationally expensive because rendering each pixel via volumetric rendering requires many evaluations (e.g., in our case, 96) of the underlying MLP. For scene reconstruction tasks, it does not create issues since the typically used $\\mathcal { L } _ { 2 }$ loss [38, 76, 69] can be robustly computed on a sparse subset of the pixels. But for NeRF-based GANs, it becomes prohibitively expensive for high resolutions since convolutional discriminators operate on dense full-size images. The currently dominating approach to mitigate this is to train a separate 2D decoder to upsample a low-resolution image representation rendered from a NeRF-based MLP. But this breaks multi-view consistency (i.e., object’s shape and texture change when the camera is moving) and learns the 3D geometry in a low resolution (from ${ \\approx } 1 6 ^ { 2 }$ [72] to ${ \\approx } 1 2 8 ^ { 2 } \\ [ \\boxed { 6 } ] .$ ). This is why we build upon the multi-scale patch-wise training scheme $\\pmb { \\Vert 5 6 \\Vert }$ and demonstrate that it can give state-of-the-art image quality and training speed without the above limitations. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Patch-wise optimization works the following way. On each iteration, instead of passing the full-size $R \\times R$ image to $\\mathsf { D }$ , we instead input only a small patch with resolution $r \\times r$ of random scale $s \\in [ r / R , 1 ]$ and extracted with a random offset $( \\delta _ { x } , \\delta _ { y } ) \\in [ 0 , 1 - s ] ^ { 2 }$ . We illustrate this procedure in Fig 3. Patch parameters are sampled from distribution: ",
+        "bbox": [
+            173,
+            140,
+            825,
+            195
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d9a749d7b676ed4b7e320b5482851819d1088bba78786f81180172968ba6bba3.jpg",
+        "text": "$$\ns , \\delta _ { x } , \\delta _ { y } \\sim p _ { t } ( s , \\delta _ { x } , \\delta _ { y } ) \\triangleq p _ { t } ( s ) p ( \\delta _ { x } | s ) p ( \\delta _ { y } | s )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            196,
+            655,
+            215
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $t$ is the current training iteration. In this way, patch scales depend on the current training iteration $t$ , and offsets are sampled independently after we know $s$ . As we show next, the choice of distribution $p _ { t } ( s )$ has a crucial influence on the learning speed and stability. ",
+        "bbox": [
+            176,
+            217,
+            826,
+            258
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Typically, patch scales are sampled from the annealed uniform distribution [56, 36, 5] $s$ ",
+        "bbox": [
+            181,
+            263,
+            750,
+            279
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/054aeb45ea1f32dc61b7e548763492d6a4644a0d08ef4506eb1ecd97edaf2836.jpg",
+        "text": "$$\np _ { t } ( s ) = U [ s _ { \\mathrm { m i n } } ( t ) , 1 ] , \\qquad s _ { \\mathrm { m i n } } ( t ) = 1 \\mathrm { e r p } \\left[ 1 , r / R , \\mathrm { m i n } ( t / T , 1 ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            280,
+            717,
+            297
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where lerp is the linear interpolation function $\\displaystyle { } ^ { 1 } ,$ and the left interval bound $s _ { \\mathrm { m i n } } ( t )$ is gradually annealed during the first $T$ iterations until it reaches the minimum possible value of $r / R \\sharp$ But this strategy does not let the model learn high-frequency details early on in training and puts little focus on the structure when $s _ { \\mathrm { m i n } } ( t )$ is fully annealed to $r / R$ (which is usually very small, e.g., $r / R = 0 . 1 2 5$ for a typical $6 4 ^ { 2 }$ patch-wise training on $5 1 2 ^ { 2 }$ resolution). As we show, the first issue makes the generator converge slower, and the second one makes the overall optimization less stable. ",
+        "bbox": [
+            173,
+            299,
+            825,
+            382
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To mitigate this, we propose a small change in the pipeline by simply replacing the uniform scale sampling distribution with: ",
+        "bbox": [
+            173,
+            388,
+            825,
+            416
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d75dc299e72f5e077c596acee5f6522fd20ceffff45fc1dfd60a7b1289cecc35.jpg",
+        "text": "$$\ns \\sim \\mathrm { B e t a } ( 1 , \\beta ( t ) ) \\cdot ( 1 - r / R ) + r / R ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            417,
+            625,
+            434
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\beta ( t )$ is gradually annealed from $\\beta ( 0 )$ to some final value $\\beta ( T )$ . Using beta distribution instead of the uniform one gives a very convenient knob to shift the training focus between large patch scales $s \\to 1$ (carrying the global information about the whole image) and small patch scales $r \\to r / R$ (representing high-resolution local crops). ",
+        "bbox": [
+            174,
+            435,
+            825,
+            491
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A natural way to do the annealing is to anneal from 0 to 1: at the start, the model focuses entirely on the structure, while at the end, it transforms into the uniform distribution $( { \\mathrm { S e e ~ F i g ~ 4 } } )$ . We follow this strategy, but from the design perspective, set $\\beta ( T )$ to a value that is slightly smaller than 1 (we use $\\beta ( T ) \\stackrel {  } { = } 0 . 8$ everywhere) to keep more focus on the structure at the end of the annealing as well. In our initial experiments, $\\beta ( T ) \\in \\lbrack 0 . 7 , 1 ]$ performs similarly. The scales distributions comparison between beta and uniform sampling is provided in $\\mathrm { F i g } 4$ and the convergence comparison in Fig 7. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            583
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 Training details ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            595,
+            323,
+            611
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We inherit the training procedure from StyleGAN2-ADA $\\pm \\pm \\mathbb { I }$ with minimal changes. The optimization is performed by Adam $\\mathbb { \\left[ \\left[ 2 \\right] \\right] }$ with a learning rate of 0.002 and betas of 0 and 0.99 for both G and D. We use $\\beta ( T ) = 0 . 8$ for $T = 1 0 0 0 0$ , $z \\sim \\mathcal { N } ( 0 , I )$ and set $R _ { p } = 5 1 2$ . D is trained with R1 regularization $\\pmb { \\Vert 3 7 } \\Vert$ with $\\gamma = 0 . 0 5$ . We train with the overall batch size of 64 for ${ \\approx } 1 5 \\mathbf { M }$ images seen by $\\mathsf { D }$ for $2 5 6 ^ { 2 }$ resolution and ${ \\approx } 2 0 \\mathbf { M }$ for $5 1 2 ^ { 2 }$ . Similar to previous works $[ [ 6 , \\boxed { 1 2 } ]$ , we use pose supervision for D for the FFHQ and Cats dataset to avoid geometry ambiguity. For this, we take the rotation and elevation angles, encode them with positional embeddings $\\boxed { 5 9 } \\boxed { 6 5 }$ and feed them into a 2-layer MLP. After that, we multiply the obtained vector with the last hidden representation in the discriminator, following the Projection GAN $\\pmb { \\mathbb { H } }$ strategy from StyleGAN2-ADA $\\mathbb { \\lVert 2 4 \\rVert }$ . We train $\\sf G$ in full precision and use mixed precision for D. Since FFHQ has too noticeable 3D biases, we use generator pose conditioning for it $\\pmb { \\Vert 6 \\Vert }$ . Further details can be found in the source code. ",
+        "bbox": [
+            173,
+            621,
+            826,
+            775
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            791,
+            312,
+            809
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experimental setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            821,
+            349,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Benchmarks. In our study, we consider four benchmarks: 1) FFHQ $\\mathbb { \\left[ \\left[ 2 5 \\right] \\right] }$ in $2 5 6 ^ { 2 }$ and $5 1 2 ^ { 2 }$ resolutions, consisting of 70,000 (mostly front-view) human face images; 2) Cats $2 5 6 ^ { 2 }$ [77], consisting of 9,998 (mostly front-view) cat face images; 3) Megascans Food (M-Food) $2 5 6 ^ { 2 }$ consisting of 199 models of different food items with 128 views per model (25472 images in total); and 4) Megascans Plants (M-Plants) $2 5 6 ^ { 2 }$ consisting of 1108 different plant models with 128 views per model (141824 images in total). The last two datasets are introduced in our work to fix two issues with the modern 3D generation benchmarks. First, existing benchmarks have low variability of global object geometry, focusing entirely on a single class of objects, like human/cat faces or cars, that do not vary much from instance to instance. Second, they all have limited camera pose distribution: for example, FFHQ $\\mathbb { \\left[ \\left. 2 5 \\right] \\right. }$ and Cats $\\mathbb { \\ m }$ are completely dominated by the frontal and near-frontal views (see Appx E). That’s why we obtain and render 1307 Megascans models from Quixel, which are photo-realistic (barely distinguishable from real) scans of real-life objects with complex geometry. Those benchmarks and the rendering code will be made publicly available. ",
+        "bbox": [
+            174,
+            847,
+            825,
+            876
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/bee22046870ee0cf3d16ec9ab60e04ab44f2dfdfdb0256d3ee667988e6b1e29e.jpg",
+        "image_caption": [
+            "Figure 5: Comparing samples of EpiGRAF and modern 3D-aware generators. Our method attains state-of-the-art image quality, recovers high-fidelity geometry and preserves multi-view consistency for both simple-shape (FFHQ and Cats) and variable-shape (M-Plants and M-Food) datasets. We refer the reader to the supplementary for the video comparisons to evaluate multi-view consistency. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            85,
+            825,
+            513
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            607,
+            825,
+            760
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Metrics. We use FID $\\left[ \\left[ 2 0 \\right] \\right]$ to measure image quality and estimate the training cost for each method in terms of NVidia V100 GPU days needed to complete the training process. ",
+        "bbox": [
+            173,
+            766,
+            823,
+            794
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Baselines. For upsampler-based baselines, we compare to the following generators: StyleNeRF [15], StyleSDF [47], EG3D [6], VolumeGAN $\\pmb { \\mathbb { Z } 1 }$ , MVCGAN $\\pmb { \\mathbb { Z } } \\pmb { 8 } \\|$ and GIRAFFE-HD $\\Dot { \\mathbb { Z } } \\Dot { 2 } \\mathbb { I }$ . Apart from that, we also compare to pi-GAN $\\mathbb { I } \\mathbb { I }$ and GRAM $\\mathbb { \\lVert 1 2 \\rVert }$ , which are non-upsampler-based GANs. To compare on Megascans, we train StyleNeRF, MVCGAN, pi-GAN, and GRAM from scratch using their official code repositories (obtained online or requested from the authors), using their FFHQ or CARLA hyperparameters, except for the camera distribution and rendering settings. We also train StyleNeRF, MVCGAN, and $\\pi$ -GAN on Cats $2 5 6 ^ { 2 }$ . GRAM $\\pmb { \\mathbb { I } }$ restricts the sampling space to a set of learnable iso-surfaces, which makes it not well-suited for datasets with varying geometry. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/713ef18a01292d820a6dde17864dee825630def878df7c65bb7197dc7322719f.jpg",
+        "table_caption": [
+            "Table 1: FID scores of modern 3D GANs. “ ” evaluated on a re-aligned version of FFHQ (different from original FFHQ $\\mathbb { \\left[ \\left[ 2 5 \\right] \\right] }$ ). Training cost is measured in terms of NVidia V100 GPU days. “OOM” denotes out-of-memory error. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">FFHQ 5122</td><td rowspan=\"2\">Cats 2562</td><td rowspan=\"2\">M-Plants 2562</td><td rowspan=\"2\">M-Food 2562</td><td colspan=\"2\">Training cost</td><td rowspan=\"2\">Geometry constraints</td></tr><tr><td>2562</td><td></td><td>2562</td><td>5122</td></tr><tr><td>StyleNeRF 因</td><td>8.00</td><td>7.8</td><td>5.91</td><td>19.32</td><td>16.75</td><td>40</td><td>56</td><td>322-res + 2D upsampler</td></tr><tr><td>StyleSDF[47</td><td>11.5</td><td>11.19</td><td>1</td><td>1</td><td>1</td><td>42</td><td>56</td><td>64²-res + 2D upsampler</td></tr><tr><td>EG3D 回</td><td>4.8t</td><td>4.7†</td><td>1</td><td>1</td><td>1</td><td>N/A</td><td>76</td><td>128²-res + 2D upsampler</td></tr><tr><td>VolumeGAN [71]</td><td>9.1</td><td>1</td><td>1</td><td>1</td><td>1</td><td>N/A</td><td>N/A</td><td>64²-res + 2D upsampler</td></tr><tr><td>MVCGAN 因</td><td>13.7</td><td>13.4</td><td>39.16</td><td>31.70</td><td>29.29</td><td>42</td><td>64</td><td>64²-res + 2D upsampler</td></tr><tr><td>GIRAFFE-HD 四</td><td>11.93</td><td>1</td><td>12.36</td><td>1</td><td>1</td><td>N/A</td><td>N/A</td><td>162-res + 2D upsampler</td></tr><tr><td>pi-GAN </td><td>53.2</td><td>OOM</td><td>68.28</td><td>75.64</td><td>51.99</td><td>56</td><td>8</td><td>none</td></tr><tr><td>GRAM [12]</td><td>13.78</td><td>0OM</td><td>13.40</td><td>188.6</td><td>178.9</td><td>56</td><td>8</td><td>iso-surfaces</td></tr><tr><td>EpiGRAF (ours)</td><td>9.71</td><td>9.92</td><td>6.93</td><td>19.42</td><td>18.15</td><td>16</td><td>24</td><td>none</td></tr></table>",
+        "bbox": [
+            176,
+            137,
+            821,
+            290
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/cc382f7806eac50f2c3fefe92be94ce04873b18c8567129c0667ea987c22ba53.jpg",
+        "image_caption": [
+            "Figure 6: Visualizing the learned geometry for different methods. $\\pi$ -GAN [7] recovers high-fidelity shapes, but has worse image quality (see Table $^ { 1 ) }$ and is much more expensive to train than our model. MVC-GAN $ { \\mathbb { I } } ^ {  { \\mathbb { Z } } 8 \\| }$ fails to capture good geometry because of the 2D upsampler. Our method learns proper geometry and achieves state-of-the-art image quality. We extracted the surfaces using marching cubes from the density fields sampled on $2 5 6 ^ { 3 }$ grid and visualized them in PyVista $\\pmb { \\mathbb { \\left| \\overline { { 6 3 } } \\right\\| } }$ . We manually optimized the marching cubes contouring threshold for each checkpoint of each method. We noticed that $\\pi$ -GAN [7] produces a lot of “spurious” density which makes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            306,
+            825,
+            561
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            696,
+            263,
+            712
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "EpiGRAF achieves state-of-the-art image quality. For Cats $2 5 6 ^ { 2 }$ , M-Plants $2 5 6 ^ { 2 }$ and M-Food $2 5 6 ^ { 2 }$ , EpiGRAF outperforms all the baselines in terms of FID except for StyleNeRF, performing very similar to it on all the datasets even though it does not have a 2D upsampler. For FFHQ, our model attains very similar FID scores as the other methods, ranking 4/9 (including older $\\pi$ -GAN [7]), noticeably losing only to EG3D $\\textcircled { 6 }$ , which trains and evaluates on a different version of FFHQ and uses pose conditioning in the generator (which potentially improves FID at the cost of multi-view consistency). We provide a visual comparison for different methods in Fig 5. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            823
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "EpiGRAF is much faster to train. As reported in Tab $\\mathbb { J }$ existing methods typically train for ${ \\approx } 1$ week on 8 V100s, EpiGRAF finishes training in just 2 days for $2 5 6 ^ { 2 }$ and 3 days for $5 1 2 ^ { \\bar { 2 } }$ resolutions, which is $2 - 3 \\times$ faster. Note that this high training efficiency is achieved without using an upsampler, which initially enabled the high-resolution synthesis of 3D-aware GANs. As to the non-upsampler methods, we couldn’t train GRAM or $\\pi$ -GAN on $5 1 2 ^ { 2 }$ resolution due to the memory limitations of the setup with 8 NVidia V100 32GB GPUs (i.e., 256GB of GPU memory in total). ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "EpiGRAF learns high-fidelity geometry. Using a pure NeRF-based backbone has two crucial benefits: it provides multi-view consistency and allows learning the geometry in the full dataset resolution. In ${ \\mathrm { F i g } } 6 ,$ we visualize the learned shapes on M-Food and M-Plants for 1) $\\pi$ -GAN: a pure NeRF-based generator without the geometry constraints; 2) MVC-GAN $ { \\mathbb { I } } ^ {  { \\mathbb { Z } } 8 \\| }$ : an upsampler-based generator with strong multi-view consistency regularization; 3) our model. We provide the details and analysis in the caption of $\\operatorname { F i g } \\boxed { 6 }$ We also provide the geometry comparison with EG3D on FFHQ $5 1 2 ^ { 2 }$ in Fig 2. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            175
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "EpiGRAF easily capitalizes on techniques from the NeRF literature. Since our generator is purely NeRF based and renders images without a 2D upsampler, it is well coupled with the existing techniques from the NeRF scene reconstruction field. To demonstrate this, we adopted background separation from $_ \\mathrm { N e R F + + }$ [76] using the inverse sphere parametrization by simply copy-pasting the corresponding code from their repo. We depict the results in Fig 1 and provide the details in Appx B. ",
+        "bbox": [
+            174,
+            181,
+            825,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 Ablations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            267,
+            281,
+            281
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We report the ablations for different discriminator architectures and patch sizes on FFHQ $5 1 2 ^ { 2 }$ and M-Plants $2 5 6 ^ { 2 }$ in $\\mathrm { T a b } \\bigstar \\bigstar$ Using a traditional discriminator architecture results in ${ \\approx } 1 5 \\%$ worse performance. Using several ones (via the group-wise convolution trick $\\mathbb { \\left[ \\left[ 2 6 \\right] \\right. }$ ) results in a noticeably slower training time and dramatically degrades the image quality. We hypothesize that the reason for it was the reduced overall training signal each discriminator receives, which we tried to alleviate by increasing their learning rate, but that did not improve the results. A too-small patch size hampers the learning process and produces a ${ \\approx } 8 0 \\%$ worse FID. A too-large one provides decent image quality but greatly reduces the training speed. Using a single scale/position-aware discriminator achieves the best performance, outperforming the standard one by ${ \\approx } 1 5 \\%$ on average. ",
+        "bbox": [
+            173,
+            292,
+            825,
+            417
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To assess the convergence of our proposed patch sampling scheme, we compared against uniform sampling on Cats $2 5 \\bar { 6 } ^ { 2 }$ for $T \\in \\{ 1 0 0 0 , 5 0 0 0 , 1 0 0 0 0 \\}$ , representing different annealing speeds. We show the results for it in $\\mathrm { F i g } \\ 7 ;$ our proposed beta scale sampling strategy with $T = 1 0 \\mathbf { k }$ schedule robustly converges to lower values than the uniform one with $T = 5 \\mathrm { k }$ or $T = 1 0 \\mathbf { k }$ and does not fluctuate much compared to the $T = 1 k$ uniform one (where the model reached its final annealing stage in just 1k kilo-images seen by D). ",
+        "bbox": [
+            173,
+            424,
+            825,
+            508
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To analyze how hyper-modulation manipulates the convolutional filters of the discriminator, we visualize the modulation weights $\\sigma$ , predicted by $\\mathsf { H }$ , in $\\operatorname { F i g } 8$ (see the caption for the details). These visualizations show that some of the filters are always switched on, regardless of the patch scale; while others are always switched off, providing potential room for pruning $\\mathbb { \\ m }$ . And ${ \\approx } 4 0 \\%$ of the filters are getting switched on and off depending on the patch scale, which shows that H indeed learns to perform meaningful modulation. ",
+        "bbox": [
+            173,
+            513,
+            825,
+            597
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/adef4eab7ec613c8085673a4f960b5eb6125ca54e34e4c26048281a7d3ac72d0.jpg",
+        "image_caption": [
+            "Figure 7: Convergence comparison on Cats $2 5 6 ^ { 2 }$ for different sampling strategies. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            608,
+            362,
+            705
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/ddda3f376c7da80fd472efc67aac7bba78db00df23ad636e852d5c4be798fcb3.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Experiment</td><td>FFHQ 512²</td><td>M-Plants 2562</td><td>Training cost</td></tr><tr><td>GRAF(with tri-planes)</td><td>13.41</td><td>24.99</td><td>24</td></tr><tr><td>+ beta scale sampling (T= 5k)</td><td>11.57</td><td>21.77</td><td>24</td></tr><tr><td>+2 scale-specific D-s</td><td>10.87</td><td>21.02</td><td>28</td></tr><tr><td>+ 4 scale-specific D-s</td><td>21.56</td><td>43.11</td><td>28</td></tr><tr><td>+ 1 scale/position-aware D</td><td>9.92</td><td>19.42</td><td>24</td></tr><tr><td>-32² patch resolution</td><td>17.44</td><td>34.32</td><td>19</td></tr><tr><td>- 64² patch resolution (default)</td><td>9.92</td><td>19.42</td><td>24</td></tr><tr><td>-128² patch resolution</td><td>11.36</td><td>18.90</td><td>34</td></tr></table>",
+        "bbox": [
+            403,
+            603,
+            821,
+            717
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/3a11630a476a9c733b727f6bb50eafeb18dd3d4eca53501769a54b51c9d6cf47.jpg",
+        "image_caption": [
+            "Table 2: Ablating the discriminator architecture and patch sizes in terms of FID scores and training cost (V100 GPU days). ",
+            "Figure 8: Visualizing modulation weights $\\pmb { \\sigma }$ , predicted by H for 2-nd, 6-th, 10-th and 14-th convolutional layers. Each subplot denotes a separate layer and we visualize random 32 filters for it. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            770,
+            826,
+            864
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Limitations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            302,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Performance drop for 2D generation. Before switching to training 3D-aware generators, we spent a considerable amount of time, exploring our ideas on top of StyleGAN2 $\\bar { \\lVert 2 4 \\rVert }$ for traditional 2D generation since it is faster, less error-prone and more robust to a hyperparameters choice. What we observed is that despite our best efforts (see C) and even with longer training, we couldn’t obtain the same image quality as the full-resolution StyleGAN2 generator. ",
+        "bbox": [
+            174,
+            119,
+            825,
+            189
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/f090aed2826844841e130d446fd7c8d3c9454a047e7bb732ce48425cfef3dbc2.jpg",
+        "table_caption": [
+            "Table 3: Trying to train a traditional StyleGAN2 $\\pmb { \\mathbb { D } } \\pmb { 6 } \\|$ generator in the patch-wise fashion. We tried to train longer to compensate for a smaller learning signal overall (a $6 4 ^ { \\dot { 2 } }$ patch is $1 / 6 4$ of information compared to a $5 1 2 ^ { 2 }$ image), but this didn’t allow to catch up. Note, however, that AnyResGAN [5] reaches SotA when training on $2 5 6 ^ { 2 }$ patches compared to $1 \\bar { 0 } 2 4 ^ { 2 }$ images. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">FFHQ 5122</td><td colspan=\"2\">LSUN Bedroom 2562</td></tr><tr><td>FID</td><td>Training cost</td><td>FID</td><td>Training cost</td></tr><tr><td>StyleGAN2-ADA 四</td><td>3.83</td><td>8</td><td>4.12</td><td>5</td></tr><tr><td>+ multi-scale 64² patch-wise training</td><td>7.11</td><td>6</td><td>6.73</td><td>4</td></tr><tr><td>+ ×2 longer training</td><td>5.71</td><td>12</td><td>5.42</td><td>8</td></tr><tr><td>+ ×4 longer training</td><td>4.76</td><td>24</td><td>4.31</td><td>16</td></tr></table>",
+        "bbox": [
+            204,
+            263,
+            794,
+            364
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A range of possible patch sizes is restricted. Tab 2 shows the performance drop when using the $3 2 ^ { 2 }$ patch size instead of the default $6 4 ^ { 2 }$ one without any dramatic improvement in speed. Trying to decrease it further would produce even worse performance (imagine training in the extreme case of $2 ^ { 2 }$ patches). Increasing the patch size is also not desirable since it decreases the training speed a lot: going from $6 4 ^ { 2 }$ to $1 2 8 ^ { \\overline { { 2 } } }$ resulted in $30 \\%$ cost increase without clear performance benefits. In this way, we are very constrained in what patch size one can use. ",
+        "bbox": [
+            173,
+            377,
+            825,
+            460
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Discriminator does not see the global context. When the discriminator classifies patches of small scale, it is forced to do so without relying on the global image information, which could be useful for this. Our attempts to incorporate it (see Appx C) did not improve the performance (though we believe we under-explored this). ",
+        "bbox": [
+            174,
+            467,
+            825,
+            522
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Low-resolution artifacts. While our generator achieves good FID on FFHQ $5 1 2 ^ { 2 }$ , we noticed that it has some blurriness when one zooms-in into the samples. It is not well captured by FID since it always resizes images to the $2 9 9 \\times 2 9 9$ resolution. We attribute this problem to our patch-wise training scheme, which puts too much focus on the structure and believe that it could be resolved. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            585
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            603,
+            299,
+            621
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we showed that it is possible to build a state-of-the-art 3D GAN framework without a 2D upsampler, but using a pure NeRF-based generator trained in a multi-scale patch-wise fashion. For this, we improved the traditional patch-wise training scheme in two important ways. First, we proposed to use a scale/location-aware discriminator with convolutional filters modulated by a hypernetwork depending on the patch parameters. Second, we developed a schedule for patch scale sampling based on the beta distribution, that leads to faster and more robust convergence. We believe that the future of 3D GANs is a combination of efficient volumetric representations, regularized 2D upsamplers, and patch-wise training. We propose this avenue of research for future work. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            744
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our method also has several limitations. Before switching to training 3D-aware generators, we spent a considerable amount of time exploring our ideas on top of StyleGAN2 for traditional 2D generation, which always resulted in higher FID scores. Further, the discriminator loses information about global context. We tried multiple ideas to incorporate global context, but it did not lead to an improvement. Next, our current patch-wise training scheme might cause some low-res artifacts. Finally, 3D GANs generating faces and humans may have negative societal impact as discussed in Appx H. ",
+        "bbox": [
+            174,
+            751,
+            825,
+            834
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            852,
+            367,
+            869
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We would like to acknowledge support from the SDAIA-KAUST Center of Excellence in Data Science and Artificial Intelligence. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            267,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] P. Achlioptas, O. Diamanti, I. Mitliagkas, and L. Guibas. Learning representations and generative models for 3d point clouds. In International conference on machine learning, pages 40–49. PMLR, 2018. [2] J. T. Barron, B. Mildenhall, M. Tancik, P. Hedman, R. Martin-Brualla, and P. P. Srinivasan. Mip-nerf: A multiscale representation for anti-aliasing neural radiance fields. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 5855–5864, 2021.   \n[3] Blender Online Community. Blender - a 3D modelling and rendering package. Blender Foundation, Blender Institute, Amsterdam, 2022.   \n[4] A. Brock, J. Donahue, and K. Simonyan. Large scale gan training for high fidelity natural image synthesis. arXiv preprint arXiv:1809.11096, 2018.   \n[5] L. Chai, M. Gharbi, E. Shechtman, P. Isola, and R. Zhang. Any-resolution training for high-resolution image synthesis. arXiv preprint arXiv:2204.07156, 2022. [6] E. R. Chan, C. Z. Lin, M. A. Chan, K. Nagano, B. Pan, S. D. Mello, O. Gallo, L. Guibas, J. Tremblay, S. Khamis, T. Karras, and G. Wetzstein. Efficient geometry-aware 3D generative adversarial networks. In arXiv, 2021.   \n[7] E. R. Chan, M. Monteiro, P. Kellnhofer, J. Wu, and G. Wetzstein. pi-gan: Periodic implicit generative adversarial networks for 3d-aware image synthesis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 5799–5809, 2021.   \n[8] A. Chen, Z. Xu, A. Geiger, J. Yu, and H. Su. Tensorf: Tensorial radiance fields. arXiv preprint arXiv:2203.09517, 2022. [9] H. Chen, B. He, H. Wang, Y. Ren, S.-N. Lim, and A. Shrivastava. Nerv: Neural representations for videos. arXiv preprint arXiv:2110.13903, 2021.   \n[10] Z. Chen and H. Zhang. Learning implicit fields for generative shape modeling. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 5939–5948, 2019.   \n[11] Y. Choi, M. Choi, M. Kim, J.-W. Ha, S. Kim, and J. Choo. Stargan: Unified generative adversarial networks for multi-domain image-to-image translation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 8789–8797, 2018.   \n[12] Y. Deng, J. Yang, J. Xiang, and X. Tong. Gram: Generative radiance manifolds for 3d-aware image generation. In IEEE Computer Vision and Pattern Recognition, 2022.   \n[13] M. Gadelha, S. Maji, and R. Wang. 3d shape induction from 2d views of multiple objects. In 2017 International Conference on 3D Vision (3DV), pages 402–411. IEEE, 2017.   \n[14] I. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial nets. Advances in neural information processing systems, 27, 2014.   \n[15] J. Gu, L. Liu, P. Wang, and C. Theobalt. Stylenerf: A style-based 3d aware generator for high-resolution image synthesis. In International Conference on Learning Representations, 2022.   \n[16] D. Ha, A. Dai, and Q. V. Le. Hypernetworks. arXiv preprint arXiv:1609.09106, 2016.   \n[17] Z. Hao, A. Mallya, S. Belongie, and M.-Y. Liu. GANcraft: Unsupervised 3D Neural Rendering of Minecraft Worlds. In ICCV, 2021.   \n[18] Y. He, X. Zhang, and J. Sun. Channel pruning for accelerating very deep neural networks. In Proceedings of the IEEE international conference on computer vision, pages 1389–1397, 2017.   \n[19] P. Henderson, V. Tsiminaki, and C. H. Lampert. Leveraging 2d data to learn textured 3d mesh generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 7498–7507, 2020.   \n[20] M. Heusel, H. Ramsauer, T. Unterthiner, B. Nessler, and S. Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. Advances in neural information processing systems, 30, 2017.   \n[21] J. Ho, A. Jain, and P. Abbeel. Denoising diffusion probabilistic models. Advances in Neural Information Processing Systems, 33:6840–6851, 2020.   \n[22] P. Isola, J.-Y. Zhu, T. Zhou, and A. A. Efros. Image-to-image translation with conditional adversarial networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1125–1134, 2017.   \n[23] K. Jo, G. Shim, S. Jung, S. Yang, and J. Choo. Cg-nerf: Conditional generative neural radiance fields. arXiv preprint arXiv:2112.03517, 2021.   \n[24] T. Karras, M. Aittala, J. Hellsten, S. Laine, J. Lehtinen, and T. Aila. Training generative adversarial networks with limited data. arXiv preprint arXiv:2006.06676, 2020.   \n[25] T. Karras, S. Laine, and T. Aila. A style-based generator architecture for generative adversarial networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4401–4410, 2019.   \n[26] T. Karras, S. Laine, M. Aittala, J. Hellsten, J. Lehtinen, and T. Aila. Analyzing and improving the image quality of stylegan. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8110–8119, 2020.   \n[27] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   \n[28] D. P. Kingma and P. Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. Advances in neural information processing systems, 31, 2018.   \n[29] A. R. Kosiorek, H. Strathmann, D. Zoran, P. Moreno, R. Schneider, S. Mokrá, and D. J. Rezende. Nerf-vae: A geometry aware 3d scene generative model. arXiv preprint arXiv:2104.00587, 2021.   \n[30] A. Krizhevsky, I. Sutskever, and G. E. Hinton. Imagenet classification with deep convolutional neural networks. Advances in neural information processing systems, 25, 2012.   \n[31] R. Li, X. Li, K.-H. Hui, and C.-W. Fu. Sp-gan: Sphere-guided 3d shape generation and manipulation. ACM Transactions on Graphics (TOG), 40(4):1–12, 2021.   \n[32] X. Li, Y. Dong, P. Peers, and X. Tong. Synthesizing 3d shapes from silhouette image collections using multiprojection generative adversarial networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 5535–5544, 2019.   \n[33] C. H. Lin, H.-Y. Lee, Y.-C. Cheng, S. Tulyakov, and M.-H. Yang. Infinitygan: Towards infinite-resolution image synthesis. arXiv preprint arXiv:2104.03963, 2021.   \n[34] S. Luo and W. Hu. Diffusion probabilistic models for 3d point cloud generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2021.   \n[35] Y. A. Mejjati, I. Milefchik, A. Gokaslan, O. Wang, K. I. Kim, and J. Tompkin. Gaussigan: Controllable image synthesis with 3d gaussians from unposed silhouettes. arXiv preprint arXiv:2106.13215, 2021.   \n[36] Q. Meng, A. Chen, H. Luo, M. Wu, H. Su, L. Xu, X. He, and J. Yu. Gnerf: Gan-based neural radiance field without posed camera. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 6351–6361, 2021.   \n[37] L. Mescheder, A. Geiger, and S. Nowozin. Which training methods for gans do actually converge? In International conference on machine learning, pages 3481–3490. PMLR, 2018.   \n[38] B. Mildenhall, P. P. Srinivasan, M. Tancik, J. T. Barron, R. Ramamoorthi, and R. Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. In European conference on computer vision, pages 405–421. Springer, 2020.   \n[39] P. Mittal, Y.-C. Cheng, M. Singh, and S. Tulsiani. AutoSDF: Shape priors for 3d completion, reconstruction and generation. In CVPR, 2022.   \n[40] T. Miyato and M. Koyama. cgans with projection discriminator. arXiv preprint arXiv:1802.05637, 2018.   \n[41] T. Nguyen-Phuoc, C. Li, L. Theis, C. Richardt, and Y.-L. Yang. Hologan: Unsupervised learning of 3d representations from natural images. In The IEEE International Conference on Computer Vision (ICCV), Nov 2019.   \n[42] M. Niemeyer and A. Geiger. Campari: Camera-aware decomposed generative neural radiance fields. In 2021 International Conference on 3D Vision (3DV), pages 951–961. IEEE, 2021.   \n[43] M. Niemeyer and A. Geiger. Giraffe: Representing scenes as compositional generative neural feature fields. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11453–11464, 2021.   \n[44] M. Niemeyer, L. Mescheder, M. Oechsle, and A. Geiger. Differentiable volumetric rendering: Learning implicit 3d representations without 3d supervision. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 3504–3515, 2020.   \n[45] M. Oechsle, S. Peng, and A. Geiger. Unisurf: Unifying neural implicit surfaces and radiance fields for multi-view reconstruction. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 5589–5599, 2021.   \n[46] C. Olah, A. Mordvintsev, and L. Schubert. Feature visualization. Distill, 2017. https://distill.pub/2017/feature-visualization.   \n[47] R. Or-El, X. Luo, M. Shan, E. Shechtman, J. J. Park, and I. Kemelmacher-Shlizerman. StyleSDF: High-Resolution 3D-Consistent Image and Geometry Generation. arXiv preprint arXiv:2112.11427, 2021.   \n[48] X. Pan, B. Dai, Z. Liu, C. C. Loy, and P. Luo. Do 2d gans know 3d shape? unsupervised 3d shape reconstruction from 2d image gans. arXiv preprint arXiv:2011.00844, 2020. accurate 3d-aware image synthesis. In Advances in Neural Information Processing Systems (NeurIPS), 2021.   \n[50] K. Park, U. Sinha, J. T. Barron, S. Bouaziz, D. B. Goldman, S. M. Seitz, and R. Martin-Brualla. Deformable neural radiance fields. arXiv preprint arXiv:2011.12948, 2020.   \n[51] T. Park, M.-Y. Liu, T.-C. Wang, and J.-Y. Zhu. Semantic image synthesis with spatially-adaptive normalization. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 2337–2346, 2019.   \n[52] T. Park, J.-Y. Zhu, O. Wang, J. Lu, E. Shechtman, A. Efros, and R. Zhang. Swapping autoencoder for deep image manipulation. Advances in Neural Information Processing Systems, 33:7198–7211, 2020.   \n[53] D. Pavllo, J. Kohler, T. Hofmann, and A. Lucchi. Learning generative models of textured 3d meshes from real-world images. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 13879–13889, October 2021.   \n[54] D. Pavllo, G. Spinks, T. Hofmann, M.-F. Moens, and A. Lucchi. Convolutional generation of textured 3d meshes. In Neural Information Processing Systems (NeurIPS), 2020.   \n[55] A. Ramesh, P. Dhariwal, A. Nichol, C. Chu, and M. Chen. Hierarchical text-conditional image generation with clip latents. arXiv preprint arXiv:2204.06125, 2022.   \n[56] K. Schwarz, Y. Liao, M. Niemeyer, and A. Geiger. Graf: Generative radiance fields for 3d-aware image synthesis. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   \n[57] T. R. Shaham, T. Dekel, and T. Michaeli. Singan: Learning a generative model from a single natural image. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 4570–4580, 2019.   \n[58] Y. Shi, D. Aggarwal, and A. K. Jain. Lifting 2d stylegan for 3d-aware face generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 6258–6266, 2021.   \n[59] V. Sitzmann, J. Martel, A. Bergman, D. Lindell, and G. Wetzstein. Implicit neural representations with periodic activation functions. Advances in Neural Information Processing Systems, 33, 2020.   \n[60] I. Skorokhodov, S. Ignatyev, and M. Elhoseiny. Adversarial generation of continuous images. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10753–10764, 2021.   \n[61] I. Skorokhodov, G. Sotnikov, and M. Elhoseiny. Aligning latent and image spaces to connect the unconnectable. arXiv preprint arXiv:2104.06954, 2021.   \n[62] I. Skorokhodov, S. Tulyakov, and M. Elhoseiny. Stylegan-v: A continuous video generator with the price, image quality and perks of stylegan2. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 3626–3636, 2022.   \n[63] C. B. Sullivan and A. Kaszynski. PyVista: 3d plotting and mesh analysis through a streamlined interface for the visualization toolkit (VTK). Journal of Open Source Software, 4(37):1450, may 2019.   \n[64] F. Tan, S. Fanello, A. Meka, S. Orts-Escolano, D. Tang, R. Pandey, J. Taylor, P. Tan, and Y. Zhang. Volux-gan: A generative model for 3d face synthesis with hdri relighting. arXiv preprint arXiv:2201.04873, 2022.   \n[65] M. Tancik, P. P. Srinivasan, B. Mildenhall, S. Fridovich-Keil, N. Raghavan, U. Singhal, R. Ramamoorthi, J. T. Barron, and R. Ng. Fourier features let networks learn high frequency functions in low dimensional domains. arXiv preprint arXiv:2006.10739, 2020.   \n[66] A. Van den Oord, N. Kalchbrenner, L. Espeholt, O. Vinyals, A. Graves, et al. Conditional image generation with pixelcnn decoders. Advances in neural information processing systems, 29, 2016.   \n[67] Y. Vinker, E. Horwitz, N. Zabari, and Y. Hoshen. Image shape manipulation from a single augmented training sample. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 13769–13778, October 2021.   \n[68] C. Wang, M. Chai, M. He, D. Chen, and J. Liao. Clip-nerf: Text-and-image driven manipulation of neural radiance fields. arXiv preprint arXiv:2112.05139, 2021.   \n[69] P. Wang, L. Liu, Y. Liu, C. Theobalt, T. Komura, and W. Wang. Neus: Learning neural implicit surfaces by volume rendering for multi-view reconstruction. arXiv preprint arXiv:2106.10689, 2021.   \n[70] Z. Wu, S. Song, A. Khosla, F. Yu, L. Zhang, X. Tang, and J. Xiao. 3d shapenets: A deep representation for volumetric shapes. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1912–1920, 2015.   \n[71] Y. Xu, S. Peng, C. Yang, Y. Shen, and B. Zhou. 3d-aware image synthesis via learning structural and textural representations. arXiv preprint arXiv:2112.10759, 2021.   \n[72] Y. Xue, Y. Li, K. K. Singh, and Y. J. Lee. Giraffe hd: A high-resolution 3d-aware generative model. arXiv preprint arXiv:2203.14954, 2022.   \n[73] Y. Ye, S. Tulsiani, and A. Gupta. Shelf-supervised mesh prediction in the wild. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 8843–8852, June 2021.   \n[74] A. Yu, V. Ye, M. Tancik, and A. Kanazawa. pixelnerf: Neural radiance fields from one or few images. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 4578–4587, June 2021.   \n[75] J. Zhang, E. Sangineto, H. Tang, A. Siarohin, Z. Zhong, N. Sebe, and W. Wang. 3d-aware semantic-guided generative model for human synthesis. arXiv preprint arXiv:2112.01422, 2021.   \n[76] K. Zhang, G. Riegler, N. Snavely, and V. Koltun. Nerf++: Analyzing and improving neural radiance fields. arXiv preprint arXiv:2010.07492, 2020.   \n[77] W. Zhang, J. Sun, and X. Tang. Cat head detection-how to effectively exploit shape and texture features. In European conference on computer vision, pages 802–816. Springer, 2008.   \n[78] X. Zhang, Z. Zheng, D. Gao, B. Zhang, P. Pan, and Y. Yang. Multi-view consistent generative adversarial networks for 3d-aware image synthesis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2022.   \n[79] P. Zhou, L. Xie, B. Ni, and Q. Tian. Cips-3d: A 3d-aware generator of gans based on conditionallyindependent pixel synthesis. arXiv preprint arXiv:2110.09788, 2021. ",
+        "bbox": [
+            171,
+            116,
+            828,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            75,
+            828,
+            915
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            109,
+            828,
+            920
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            369
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            121,
+            339,
+            135
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] See §5 and Appx A.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] We do this in Appendix G.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] We discuss the potential ethical concerns of using our model in Appendix G. ",
+        "bbox": [
+            238,
+            138,
+            825,
+            258
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            262,
+            493,
+            276
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            236,
+            281,
+            738,
+            313
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            316,
+            393,
+            330
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] We provide the code/data and additional visualizations on https://universome.github.io/epigraf(as specified in the introduction).   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We provide the most important training details in $\\ S 3 . 4 .$ The rest of the details are provided in Appx B and the provided source code.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] . That’s too computationally expensive and single-run results are typically reliable in the GAN field.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] We report this numbers in Appx B. ",
+        "bbox": [
+            238,
+            335,
+            825,
+            508
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            218,
+            513,
+            823,
+            527
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We cite all the sources of the datasets which were used or mentioned in our submission.   \n(b) Did you mention the license of the assets? [Yes] In this work, we release two new datasets: Megascans Plants and Megascans Food. We discuss their licensing in Appx E.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We provide our datasets on the project website: https://universome.github.io/epigraf.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] We specify the information on dataset collection in Appx E.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [Yes] As discussed in Appx E, the released data does not contain personally identifiable information or offensive content. ",
+        "bbox": [
+            238,
+            531,
+            825,
+            693
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            698,
+            705,
+            713
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            717,
+            826,
+            806
+        ],
+        "page_idx": 14
+    }
+]

parse/dev/YevsQ05DEN7/YevsQ05DEN7.md

@@ -0,0 +1,655 @@
+# UNDERSTANDING DIMENSIONAL COLLAPSE IN CONTRASTIVE SELF-SUPERVISED LEARNING
+
+Li Jing, Pascal Vincent, Yann LeCun, Yuandong Tian Facebook AI Research {ljng, pascal, yann, yuandong}@fb.com
+
+# ABSTRACT
+
+Self-supervised visual representation learning aims to learn useful representations without relying on human annotations. Joint embedding approach bases on maximizing the agreement between embedding vectors from different views of the same image. Various methods have been proposed to solve the collapsing problem where all embedding vectors collapse to a trivial constant solution. Among these methods, contrastive learning prevents collapse via negative sample pairs. It has been shown that non-contrastive methods suffer from a lesser collapse problem of a different nature: dimensional collapse, whereby the embedding vectors end up spanning a lower-dimensional subspace instead of the entire available embedding space. Here, we show that dimensional collapse also happens in contrastive learning. In this paper, we shed light on the dynamics at play in contrastive learning that leads to dimensional collapse. Inspired by our theory, we propose a novel contrastive learning method, called DirectCLR, which directly optimizes the representation space without relying on a trainable projector. Experiments show that DirectCLR outperforms SimCLR with a trainable linear projector on ImageNet.
+
+# 1 INTRODUCTION
+
+Self-supervised learning aims to learn useful representations of the input data without relying on human annotations. Recent advances in self-supervised visual representation learning based on joint embedding methods (Misra & Maaten, 2020b; He et al., 2020; Chen et al., 2020a; Chen & He, 2020; Grill et al., 2020; Zbontar et al., 2021; Bardes et al., 2021; Chen et al., 2020b; Dwibedi et al., 2021; Li et al., 2021; Misra & Maaten, 2020a; HaoChen et al., 2021; Assran et al., 2021; Caron et al., 2021) show that self-supervised representations have competitive performances compared with supervised ones. These methods generally aim to learn representations invariant to data augmentations by maximizing the agreement between embedding vectors from different distortions of the same images.
+
+As there are trivial solutions where the model maps all input to the same constant vector, known as the collapsing problem, various methods have been proposed to solve this problem that rely on different mechanisms. Contrastive methods like Chen et al. (2020a) and He et al. (2016) define ‘positive’ and ‘negative’ sample pairs which are treated differently in the loss function. Non-contrastive methbods like Grill et al. (2020) and Chen & He (2020) use stop-gradient, and an extra predictor to prevent collapse without negative pairs; Caron et al. (2018; 2020) use an additional clustering step; and Zbontar et al. (2021) minimize the redundant information between two branches.
+
+These self-supervised learning methods are successful in preventing complete collapse whereby all representation vectors shrink into a single point. However, it has been observed empirically in noncontrastive learning methods (Hua et al., 2021; Tian et al., 2021) that while embedding vectors do not completely collapse; they collapse along certain dimensions. This is known as dimensional collapse (Hua et al., 2021), whereby the embedding vectors only span a lower-dimensional subspace.
+
+In contrastive methods that explicitly use positive and negative pairs in the loss function, it seems intuitive to speculate that the repulsive effect of negative examples should prevent this kind of dimensional collapse and make full use of all dimensions. However, contrary to intuition, contrastive learning methods still suffer from dimensional collapse (See Fig. 7). In this work, we theoretically study the dynamics behind this phenomenon. We show there are two different mechanisms that cause collapsing: (1) along the feature direction where the variance caused by the data augmentation is larger than the variance caused by the data distribution, the weight collapses. Moreover, (2) even if the covariance of data augmentation has a smaller magnitude than the data variance along all dimensions, the weight will still collapse due to the interplay of weight matrices at different layers known as implicit regularization. This kind of collapsing happens only in networks where the network has more than one layer.
+
+Inspired by our theory, we propose a novel contrastive learning method, called DirectCLR, which directly optimizes the encoder (i.e., representation space) without relying on a trainable projector. DirectCLR outperforms SimCLR with a linear trainable projector on ImageNet.
+
+We summarize our contributions as follows:
+
+• We empirically show that contrastive self-supervised learning suffers from dimensional collapse whereby all the embedding vectors fall into a lower-dimensional subspace instead of the entire available embedding space.   
+• We showed that there are two mechanisms causing the dimensional collapse in contrastive learning: (1) strong augmentation along feature dimensions (2) implicit regularization driving models toward low-rank solutions.   
+• We propose DirectCLR, a novel contrastive learning method that directly optimizes the representation space without relying on a trainable projector. DirectCLR outperforms SimCLR with a linear trainable projector.
+
+# 2 RELATED WORKS
+
+Self-supervised Learning Methods Joint embedding methods are a promising approach in selfsupervised learning, whose principle is to match the embedding vectors of augmented views of a training instance. Contrastive methods (Chen et al., 2020a; He et al., 2016) directly compare training samples by effectively viewing each sample as its own class, typically based on the InfoNCE contrastive loss (van den Oord et al., 2018) which encourages representations from positive pairs of examples to be close in the embedding space while representations from negative pairs are pushed away from each other. In practice, contrastive methods are known to require a large number of negative samples. Non-contrastive methods do not directly rely on explicit negative samples. These include clustering-based methods (Caron et al., 2018; 2020), redundancy reduction methods (Zbontar et al., 2021; Bardes et al., 2021) and methods using special architecture design (Grill et al., 2020; Chen & He, 2020).
+
+Theoretical Understanding of Self-supervised Learning Although self-supervised learning models have shown success in learning useful representations and have outperformed their supervised counterpart in several downstream transfer learning benchmarks (Chen et al., 2020a), the underlying dynamics of these methods remains somewhat mysterious and poorly understood. Several theoretical works have attempted to understand it. Arora et al. (2019b); Lee et al. (2020); Tosh et al. (2021) theoretically proved that the learned representations via contrastive learning are useful for downstream tasks. Tian et al. (2021) explained why non-contrastive learning methods like BYOL (Grill et al., 2020) and SimSiam (Chen & He, 2020) work: the dynamics of the alignment of eigenspaces between the predictor and its input correlation matrix play a key role in preventing complete collapse.
+
+Implicit Regularization It has been theoretically explained that gradient descent will drive adjacent matrices aligned in a linear neural network setting (Ji & Telgarsky, 2019). Under the aligned matrix assumption, Gunasekar et al. (2018) prove that gradient descent can derive minimal nuclear norm solution. Arora et al. (2019a) extend this concept to the deep linear network case by theoretically and empirically demonstrating that a deep linear network can derive low-rank solutions. In general, over-parametrized neural networks tend to find flatter local minima (Saxe et al., 2019; Neyshabur et al., 2019; Soudry et al., 2018; Barrett & Dherin, 2021).
+
+# 3 DIMENSIONAL COLLAPSE
+
+Self-supervised learning methods learn useful representation by minimizing the distances between embedding vectors from augmented images (Figure 1a). On its own, this would result in a collapsed solution where the produced representation becomes constant (Figure 1b). Contrastive methods prevent complete collapse via the negative term that pushes embedding vectors of different input images away from each other. In this section, we show that while they prevent complete collapse, contrastive methods still experience a dimensional collapse in which the embedding vectors occupy a lower-dimensional subspace than their dimension (Figure 1c).
+
+![](images/a7ef56d8feee7eaf66a24e3ba99bb787eb76dc0b1a3775d734606ccd0b8f785f.jpg)  
+Figure 1: Illustration of the collapsing problem. For complete collapse, the embedding vectors collapse to same point. For dimensional collapse, the embedding vectors only span a lower dimensional space.
+
+We train a SimCLR model (Chen et al. (2020a)) with a two-layer MLP projector. We followed the standard recipe and trained the model on ImageNet for 100 epoch. We evaluate the dimensionality by collecting the embedding vectors on the validation set. Each embedding vector has a size of $d = 1 2 8$ . We compute the colayer (here number of variance matrix $\begin{array} { r } { \bar { \mathbf { z } } : = \sum _ { i = 1 } ^ { N } \mathbf { z } _ { i } / N } \end{array}$ $C \in \mathbb { R } ^ { d \times d }$ of the embedding and $N$ is the total
+
+$$
+C = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } ( { \bf { z } } _ { i } - { \bar { \bf { z } } } ) ( { \bf { z } } _ { i } - { \bar { \bf { z } } } ) ^ { T }
+$$
+
+Figure 2 shows singular value decomposition on this matrix $\mathbf { \check { \mathit { C } } } = \mathbf { \check { \mathit { U } } } \mathbf { \mathit { S } } V ^ { T }$ , $S = d i a g ( \dot { \sigma } ^ { k } ) )$ . in sorted order and logarithmic scale $( \{ \log ( \sigma ^ { k } ) \} )$ . We observe that a number of singular values collapse to zero, thus representing collapsed dimensions.
+
+![](images/5ddd2ea6a650018ec00b67925824a769dccae3463462d39b23ec63f8401e4cf5.jpg)  
+Figure 2: Singular value spectrum of the embedding space. The embedding vectors are computed from a pretrained SimCLR model on the validation set of ImageNet. Each embedding vector has a dimension of 128. The spectrum contains the singular values of the covariance matrix of these embedding vectors in sorted order and logarithmic scale. A number of singular values drop to zero, indicating collapsed dimensions.
+
+# 4 DIMENSIONAL COLLAPSE CAUSED BY STRONG AUGMENTATION
+
+# 4.1 LINEAR MODEL
+
+In this section, we explain one scenario for contrastive learning to have collapsed embedding dimensions, where the augmentation surpasses the input information. We focus on a simple linear network setting. We denote the input vector as $\mathbf { X }$ and the augmentation is an additive noise. The network is a single linear layer with weight matrix is $W$ . Hence, the embedding vector is $\mathbf { z } = W \mathbf { x }$ . We focus on a typical contrastive loss, InfoNCE (van den Oord et al., 2018):
+
+$$
+L = - \sum _ { i = 1 } ^ { N } \log \frac { \exp ( - | \mathbf { z } _ { i } - \mathbf { z } _ { i } ^ { \prime } | ^ { 2 } / 2 ) } { \sum _ { j \ne i } \exp ( - | \mathbf { z } _ { i } - \mathbf { z } _ { j } | ^ { 2 } / 2 ) + \exp ( - | \mathbf { z } _ { i } - \mathbf { z } _ { i } ^ { \prime } | ^ { 2 } / 2 ) }
+$$
+
+where $\mathbf { z } _ { i }$ and $\mathbf { z } _ { i } ^ { \prime }$ are a pair of embedding vectors from the two branches, $\mathbf { z } _ { j }$ indicates the negative samples within the minibatch. When all $\mathbf { z } _ { i }$ and $\mathbf { z } _ { i } ^ { \prime }$ are normalized to be unit vector, the negative distance $- | \mathbf { z } _ { i } - \mathbf { z } _ { i } ^ { \prime } | ^ { 2 } / 2$ can be replaced by inner products $\mathbf { z } _ { i } ^ { T } \mathbf { z } _ { i } ^ { \prime }$ . The model is trained with a basic stochastic gradient descent without momentum or weight decay.
+
+# 4.2 GRADIENT FLOW DYNAMICS
+
+We study the dynamics via gradient flow, i.e., gradient descent with an infinitesimally small learning rate.
+
+Lemma 1. The weight matrix in a linear contrastive self-supervised learning model evolves by:
+
+$$
+{ \dot { W } } = - G
+$$
+
+where $\begin{array} { r } { G = \sum _ { i } ( g _ { z _ { i } } \pmb { x } _ { i } ^ { T } + \pmb { g } _ { z _ { i } ^ { \prime } } \pmb { x } _ { i } ^ { \prime T } ) } \end{array}$ , and ${ \pmb g } _ { z _ { i } }$ is the gradient on the embedding vector $z _ { i }$ (similarly ${ \pmb g } _ { z _ { i } ^ { \prime } }$ ).
+
+This can be easily proven based on the chain rule. See proof in Appendix B.1. For InfoNCE loss defined in Eqn 2, the gradient of the embedding vector for each branch can be written as
+
+$$
+\mathbf { g } _ { \mathbf { z } _ { i } } = \sum _ { j \neq i } \alpha _ { i j } ( \mathbf { z } _ { j } - \mathbf { z } _ { i } ^ { \prime } ) + \sum _ { j \neq i } \alpha _ { j i } ( \mathbf { z } _ { j } - \mathbf { z } _ { i } ) , \qquad \mathbf { g } _ { \mathbf { z } _ { i } ^ { \prime } } = \sum _ { j \neq i } \alpha _ { i j } ( \mathbf { z } _ { i } ^ { \prime } - \mathbf { z } _ { i } )
+$$
+
+where $\{ \alpha _ { i j } \}$ are the softmax of similarity of between $z _ { i }$ and $\{ z _ { j } \}$ , defined by $\alpha _ { i j } = \exp ( - | { \bf z } _ { i } -$ $\mathbf { z } _ { j } | ^ { 2 } / 2 ) / Z _ { i }$ , $\alpha _ { i i } = \exp ( - | \mathbf { z } _ { i } - \mathbf { z } _ { i } ^ { \prime } | ^ { 2 } / 2 ) / Z _ { i }$ , and $\begin{array} { r } { Z _ { i } = \sum _ { j \neq i } \exp ( - \vert \mathbf { z } _ { i } - \mathbf { z } _ { j } \vert ^ { 2 } / 2 ) + \exp ( - \vert \mathbf { z } _ { i } - \mathbf { z } _ { i } ^ { \prime } \vert ^ { 2 } / 2 ) } \end{array}$ . Hence, $\textstyle \sum _ { j } \alpha _ { i j } = 1$ . Since $z _ { i } = W \mathbf { x } _ { i }$ , we have
+
+$$
+G = - W X
+$$
+
+where
+
+$$
+X : = - \sum _ { i } \left( \sum _ { j \neq i } \alpha _ { i j } ( { \bf x } _ { i } ^ { \prime } - { \bf x } _ { j } ) + \sum _ { j \neq i } \alpha _ { j i } ( { \bf x } _ { i } - { \bf x } _ { j } ) \right) { \bf x } _ { i } ^ { T } - \sum _ { i } ( 1 - \alpha _ { i i } ) ( { \bf x } _ { i } ^ { \prime } - { \bf x } _ { i } ) { \bf x } _ { i } ^ { \prime } { } ^ { T }
+$$
+
+Lemma 2. $X$ is a difference of two PSD matrices:
+
+$$
+X = \hat { \Sigma } _ { 0 } - \hat { \Sigma } _ { 1 }
+$$
+
+Here $\begin{array} { r } { \hat { \Sigma } _ { 0 } = \sum _ { i , j } \alpha _ { i j } ( { \pmb x } _ { i } - { \pmb x } _ { j } ) ( { \pmb x } _ { i } - { \pmb x } _ { j } ) ^ { T } } \end{array}$ is a weighted data distribution covariance matrix and $\begin{array} { r } { \hat { \Sigma } _ { 1 } = \sum _ { i } ( 1 - \alpha _ { i i } ) ( { \pmb x } _ { i } ^ { \prime } - { \pmb x } _ { i } ) ( { \pmb x } _ { i } ^ { \prime } - { \pmb x } _ { i } ) ^ { T } } \end{array}$ is a weighted augmentation distribution covariance matrix.
+
+See proof in Appendix B.2. Therefore, the amplitude of augmentation determines whether $X$ is a positive definite matrix. Similar to Theorem 3-4 in Tian et al. (2020), Lemma 2 also models the time derivative of weight $W$ as a product of $W$ and a symmetric and/or PSD matrices. However, Lemma 2 is much more general: it applies to InfoNCE with multiple negative contrastive terms, remains true when $\alpha _ { i j }$ varies with sample pair $( i , j )$ , and holds with finite batch size $N$ . In contrast, Theorem 4 in Tian et al. (2020) only works for one negative term in InfoNCE, holds only in the population sense (i.e., $N \to + \infty$ ), and the formulation has residual terms, if $\alpha _ { i j }$ are not constants.
+
+Next, we look into the dynamics of weight matrix $W$ given property of $X$ .
+
+Theorem 1. With fixed matrix $X$ (defined in Eqn $6$ ) and strong augmentation such that $X$ has negative eigenvalues, the weight matrix $W$ has vanishing singular values.
+
+See proof in Appendix B.3.
+
+Corollary 1 (Dimensional Collapse Caused by Strong Augmentation). With strong augmentation, the embedding space covariance matrix becomes low-rank.
+
+The embedding space is identified by the singular value spectrum of the covariance matrix on the embedding (Eqn. 1), $\begin{array} { r } { C = \sum _ { i } ( \mathbf { z } _ { i } - \bar { \mathbf { z } } ) ( \mathbf { z } _ { i } - \bar { \mathbf { z } } ) ^ { T } / N = \sum _ { i } W ( \mathbf { x } _ { i } - \bar { \mathbf { x } } ) ( \mathbf { x } _ { i } - \bar { \mathbf { x } } ) ^ { T } W ^ { T } / N } \end{array}$ . Since $W$ has vanishing singular values, $C$ is also low-rank, indicating collapsed dimensions.
+
+Numerical simulation verifies our theory. We choice input data as isotropic Gaussian with covariance matrix $\begin{array} { r } { \sum _ { i , j } ( { \bf x } _ { i } - { \bf x } _ { j } ) ( { \bf x } _ { i } - { \bf x } _ { j } ) ^ { T } / \dot { N } = I } \end{array}$ . We set the augmentation as additive Gaussian with covariance matrix equal to $\begin{array} { r } { \sum _ { i } ( \mathbf { x } _ { i } ^ { \prime } - \mathbf { x } _ { i } ) ( \mathbf { x } _ { i } ^ { \prime } - \mathbf { x } _ { i } ) ^ { T } / N = b l o c k \_ d i a g o n a l ( \mathbf { 0 } , k * I ) } \end{array}$ , where the block has the size of $8 \mathrm { x } 8$ . We plot the weight matrix singular value spectrum in Figure 3 with various augmentation amplitude $k$ . This proves that under linear network setting, strong augmentation leads to dimensional collapse in embedding space.
+
+Our theory in this section is limited to linear network settings. For more complex nonlinear networks, the collapsing condition will still depend on “strong augmentation” but interpreted differently. A strong augmentation will be determined by more complicated properties of the augmentation (higher-order statistics of augmentation, manifold property of augmentation vs. data distribution) conditioned on the capacity of the networks.
+
+# 5 DIMENSIONAL COLLAPSE CAUSED BY IMPLICIT REGULARIZATION
+
+# 5.1 TWO-LAYER LINEAR MODEL
+
+With strong augmentation, a linear model under InfoNCE loss will have dimensional collapse. However, such scenarios rely on the condition that the network has a limited capacity which may not hold for real cases. On the other hand, when there is no strong augmentation $( \hat { \Sigma } _ { 1 } \prec \hat { \Sigma } _ { 0 } )$ and thus $X$ matrix remains PSD, a single linear model won’t have dimensional collapsing. However, interestingly, for deep networks, dimensional collapsing still happens in practice. In the following, we will show that it stems from a different nature: implicit regularization, where over-parametrized linear networks tend to find low-rank solutions.
+
+![](images/5d908d5e00b9e3d705d6c4f074830473a7ff332605d095ccb70aee98edaf17bb.jpg)  
+Figure 3: Weight matrix singular value spectrum with different augmentation amplitude $k$ . The setting is a single layer linear toy model with each weight matrix of the size of 16x16, where the block has the size of $8 \mathrm { x } 8$ . Strong augmentation results in vanishing singular values in weight matrices.
+
+To understand this counter-intuitive phenomena, we start with the simplest over-parametrized setting by choosing the network as a two-layer linear MLP without bias. The weight matrices of these two layers are denoted by $\breve { W _ { 1 } } \in \mathbb { R } ^ { d \times d }$ and $W _ { 2 } \in \mathbb { R } ^ { d \times \overline { { d } } }$ . Similar to the setting in Sec 4, the input vector is denoted as $\mathbf { X }$ and the augmentation is an additive noise. The embedding vector from each branch is $\mathbf { z } = W _ { 2 } W _ { 1 } \mathbf { x }$ , hence $\mathbf { z } \in \mathbb { R } ^ { n }$ . We do not normalize z. See Figure 4. We use InfoNCE loss defined in Eqn 2. The model is trained with a basic stochastic gradient descent without momentum or weight decay
+
+![](images/00fd28a11c0055fd86aa51e59811df29b0a4367449f1b21b2bf959857b71983b.jpg)  
+Figure 4: Two-layer Linear Model
+
+# 5.2 GRADIENT FLOW DYNAMICS
+
+Similar to Lemma 1, we derive the gradient flow on the two weight matrices $W _ { 1 }$ and $W _ { 2 }$ .
+
+Lemma 3. The weight matrices of the two layer linear contrastive self-supervised learning model evolves by $\begin{array} { r } { ( G = \sum _ { i } \mathbf { \bar { ( } } g _ { \mathbf { z } _ { i } } \mathbf { x } _ { i } ^ { T } + \mathbf { g } _ { \mathbf { z } _ { i } ^ { \prime } } \mathbf { \bar { x } } _ { i } ^ { \prime T } ) } \end{array}$ is defined in Lemma $I$ ):
+
+$$
+\dot { W _ { 1 } } = - W _ { 2 } ^ { T } G , \qquad \dot { W _ { 2 } } = - G W _ { 1 } ^ { T }
+$$
+
+This can be easily proven based on the chain rule. See proof in Appendix B.4. For the two layer case, similar to Eqn 5, we have the specific form of $G$ :
+
+$$
+G = - W _ { 2 } W _ { 1 } X
+$$
+
+where $X$ is defined in Eqn 6. According to Lemma 2, we know that with small augmentation, $X = \hat { \Sigma } _ { 0 } - \hat { \Sigma } _ { 1 } \succ 0$ is a positive-definite matrix.
+
+# 5.3 WEIGHT ALIGNMENT
+
+Since we have two matrices $W _ { 1 }$ and $W _ { 2 }$ , the first question is how they interact with each other. We apply singular value decomposition on both matrices $W _ { 1 }$ and $W _ { 2 }$ , i.e., $W _ { 1 } = U _ { 1 } S _ { 1 } V _ { 1 } ^ { T }$ , $W _ { 2 } =$ $U _ { 2 } S _ { 2 } V _ { 2 } ^ { T }$ and $\mathsf { \bar { \Pi } } S _ { 1 } = d i a g ( [ \sigma _ { 1 } ^ { k } ] )$ , $\mathbf { \bar { \cal S } } _ { 2 } = d i a g ( [ \sigma _ { 2 } ^ { k } ] )$ . The alignment is now governed by the interaction between the adjacent orthonormal matrices $V _ { 2 } : = [ \mathbf { v } _ { 2 } ^ { k } ]$ and $U _ { 1 } = [ \mathbf { u } _ { 1 } ^ { k } ]$ . This can be characterized by the alignment matrix $A = V _ { 2 } ^ { T } U _ { 1 }$ , whose $( k , k ^ { \prime } )$ -entry represents the alignment between the $k$ -th right singular vector $\mathbf { v } _ { 2 } ^ { k }$ of $W _ { 2 }$ and the $k ^ { \prime }$ -th left singular vector $\mathbf { u } _ { 1 } ^ { k ^ { \prime } }$ of $W _ { 1 }$ . The following shows that indeed $W _ { 1 }$ and $W _ { 2 }$ aligns.
+
+Theorem 2 (Weight matrices align). If for all $t$ , $W _ { 2 } ( t ) W _ { 1 } ( t ) \neq 0$ , $X ( t )$ is positive-definite and $W _ { 1 } ( + \infty )$ , $W _ { 2 } ( + \infty )$ have distinctive singular values, then the alignment matrix $A = V _ { 2 } ^ { T } \dot { U } _ { 1 }  I$ .
+
+See proof in Appendix B.5. Here, we also empirically demonstrate that under InfoNCE loss, the absolute value of the alignment matrix $A$ converges to an identity matrix. See Figure 5.
+
+The alignment effect has been studied in other scenarios (Ji & Telgarsky, 2019; Radhakrishnan et al., 2020). In the real case, when some of our assumptions are not satisfied, e.g., there are degenerate singular values in weight matrices, we will not observe a perfect alignment. This can be easily understood by the fact that the singular decomposition is no longer unique given degenerate singular values. In our toy experiment, we specifically initialize the weight matrices to have non-degenerate singular values. In real scenario, when weight matrices are randomly initialized, we will only observe the alignment matrix to converge to a block-diagonal matrix, with each block representing a group of degenerate singular values.
+
+Given the fact that singular vectors corresponding to the same singular value align, we can now study the dynamics of the singular values of each weight matrix $W _ { 1 }$ and $W _ { 2 }$ .
+
+Theorem 3. If $W _ { 2 }$ and $W _ { 1 }$ are aligned (i.e., $V _ { 2 } =$ $U _ { 1 } ^ { T } )$ , then the singular values of the weight matrices $W _ { 1 }$ and $W _ { 2 }$ under InfoNCE loss evolve by:
+
+$$
+\begin{array} { r } { \dot { \sigma } _ { 1 } ^ { k } = \sigma _ { 1 } ^ { k } ( \sigma _ { 2 } ^ { k } ) ^ { 2 } ( \pmb { \nu } _ { 1 } ^ { k ^ { T } } X \pmb { \nu } _ { 1 } ^ { k } ) } \\ { \dot { \sigma } _ { 2 } ^ { k } = \sigma _ { 2 } ^ { k } ( \sigma _ { 1 } ^ { k } ) ^ { 2 } ( \pmb { \nu } _ { 1 } ^ { k ^ { T } } X \pmb { \nu } _ { 1 } ^ { k } ) } \end{array}
+$$
+
+![](images/741af3a742a9548b5234c7324442e560fdbf5d424b31169076ae43143daf42a2.jpg)  
+Figure 5: Visualization of the alignment matrix $\overset { \cdot } { A } \overset { \cdot } { = } V _ { 2 } ^ { T } U _ { 1 }$ after training. The setting is a 2-layer linear toy model with each weight matrix of the size of 16x16. The alignment matrix converges to an identity matrix.
+
+See proof in Appendix B.6. According to Eqn. 10, $( \sigma _ { 1 } ^ { k } ) ^ { 2 } = ( \sigma _ { 2 } ^ { \acute { k } } ) ^ { 2 } + { \cal C }$ . We solve the singular value dynamics analytically: $\dot { \sigma _ { 1 } ^ { k } } ~ = ~ \sigma _ { 1 } ^ { k } ( ( \sigma _ { 1 } ^ { k } ) ^ { 2 } ~ +$
+
+$C ) ( \mathbf { v } _ { 1 } ^ { k ^ { T } } X \mathbf { v } _ { 1 } ^ { k } )$ . This shows that a pair of singular values (singular values with same ranking from the other matrix) have gradients proportional to themselves. Notice that $X$ is a positive definite matrix, the term $\mathbf { v } _ { 1 } ^ { k ^ { T } } X \mathbf { v } _ { 1 } ^ { k }$ is always non-negative. This explains why we observe that the smallest group of singular values grow significantly slower. See demonstrative experiment results in Figure 6a and 6b.
+
+![](images/977de116b5ba2c5fd0415979ce1977c1192cceb7877a296ddcc2203cf2a44dbf.jpg)  
+Figure 6: Evolution of the singular values of the weight matrices and the embedding space covariance matrix. The setting is a 2-layer linear toy model with each weight matrix of the size of 16x16. The lowest few singular values of each weight matrix remain significantly smaller.
+
+Corollary 2 (Dimensional Collapse Caused by Implicit Regularization). With small augmentation and over-parametrized linear networks, the embedding space covariance matrix becomes low-rank.
+
+The embedding space is identified by the singular value spectrum of the covariance matrix on the embedding vectors, $C = \textstyle \sum ( { \bf z } - { \bar { \bf z } } ) ( { \bf z } - { \bar { \bf z } } ) ^ { \tilde { T } } / N = \textstyle \sum { \dot { W } } _ { 2 } W _ { 1 } ( { \bf x } - { \bar { \bf x } } ) ( { \bf x } - { \bar { \bf x } } ) ^ { T } W _ { 1 } ^ { T } W _ { 2 } ^ { T } / N$ . As
+
+$W _ { 2 } W _ { 1 }$ evolves to be low-rank, $C$ is low-rank, indicating collapsed dimensions. See Figure 6c for experimental verification.
+
+Our theory can also be extended to multilayer networks and nonlinear setting. Please see Appendix C
+
+# 6 DIRECTCLR
+
+# 6.1 MOTIVATION
+
+We now leverage our theoretical finding to design novel algorithms. Here we are targeting the projector component in contrastive learning.
+
+Empirically, adding a projector substantially improves the quality of the learned representation and downstream performance (Chen et al., 2020a). Checking the spectrum of the representation layer also reveals a difference with/without a projector. To see this, we train two SimCLR models with and without a projector. The representation space spectrum are shown in Figure 7b. The dimensional collapse in representation space happens when the model is trained without a projector. Thus, the projector prevents the collapse in the representation space.
+
+![](images/578bcfd5e37f4284709d18003105ae11e83a8249cc36d429ca00cbb3772ebe0e.jpg)  
+Figure 7: (a) Definition of representation and the embedding space; (b) Singular value spectrums of the representation space of pretrained contrastive learning models (pretrained with or without a projector). The representation vectors are the output from the ResNet50 encoder and directly used for downstream tasks. Each representation vector has a dimension of 2048. Without a projector, SimCLR suffers from dimensional collapse in the representation space.
+
+The projector in contrastive learning is essential to prevent dimensional collapse in the representation space. We claim the following propositions regarding a linear projector in contrastive learning models.
+
+Proposition 1. A linear projector weight matrix only needs to be diagonal.
+
+Proposition 2. A linear projector weight matrix only needs to be low-rank.
+
+Based on our theory on implicit regularization dynamics, we expect to see adjacent layers $W _ { 1 } ( =$ $U _ { 1 } S _ { 1 } V _ { 1 } ^ { T } )$ and $W _ { 2 } ( = U _ { 2 } S _ { 2 } \bar { V } _ { 2 } ^ { T } )$ to be aligned such that the overall dynamics is only governed by their singular values $S _ { 1 }$ and $S _ { 2 }$ . And the orthogonal matrices $V _ { 2 } ^ { T }$ and $U _ { 1 }$ are redundant as they will evolve to $V _ { 2 } ^ { T } U _ { 1 } = I$ , given $S _ { 1 }$ and $S _ { 2 }$ .
+
+Now, let’s consider the linear projector SimCLR model and only focus on the channel dimension. $W _ { 1 }$ is the last layer in the encoder, and $W _ { 2 }$ is the projector weight matrix. Our propositions claim that for this projector matrix $W _ { 2 }$ , the orthogonal component $V _ { 2 }$ can be omitted. Because the previous layer $W _ { 1 }$ is fully trainable, its orthogonal component $( U _ { 1 } )$ will always evolve to satisfy $V _ { 2 } ^ { T } { \cal U } _ { 1 } = I$ . Therefore, the final behavior of the projector is only determined by the singular values $( S _ { 2 } )$ of the projector weight matrix. This motivates Proposition 1: the orthogonal component of the weight matrix doesn’t matter. So we can set the projector matrix as a diagonal matrix.
+
+Also, according to our theory, the weight matrix will always converge to the low-rank. The singular value diagonal matrix naturally becomes low-rank, so why not just set it low-rank directly? This is the motivation of Proposition 2.
+
+These propositions are verified via ablation studies in Sec 6.3. Given these two propositions, we propose DirectCLR, which is effectively using a low-rank diagonal projector.
+
+# 6.2 MAIN IDEA
+
+We propose to remove the projector in contrastive learning by directly sending a sub-vector of the representation vector to the loss function. We call our method DirectCLR. In contrast to all recent state-of-the-art self-supervised learning methods, our method directly optimizes the representation space. See Figure 8, DirectCLR picks a subvector of the representation $\mathbf { z } = \mathbf { r } [ 0 : d _ { 0 } ]$ , where $d _ { 0 }$ is a hyperparameter. Then, it applies a standard InfoNCE loss on this normalized subvector $\hat { \mathbf { z } } = \mathbf { z } / | \mathbf { z } |$ , $\begin{array} { r } { \pmb { { \cal L } } = \sum _ { i } \log \frac { \exp ( \hat { \mathbf { z } } _ { i } \cdot \hat { \mathbf { z } } _ { i } ^ { \prime } ) } { \sum _ { j } \exp ( \hat { \mathbf { z } } _ { i } \cdot \hat { \mathbf { z } } _ { j } ) } . } \end{array}$
+
+![](images/5f6301bb75b561fd985a0c9d874b2f5641196bdf4db79de8a102d7ed36ae2426.jpg)  
+Figure 8: DirectCLR: no trainable projector, simply apply InfoNCE loss on the a fixed sub-vector of the representations
+
+We train DirectCLR with a standard recipe of SimCLR for 100 epochs on ImageNet. The backbone encoder is a ResNet50. More implementation details can be found in the Appendix D. DirectCLR demonstrates better performance compared to SimCLR with a trainable linear projector on ImageNet. The linear probe accuracies for each model are listed in Table 1.
+
+<table><tr><td>Loss function</td><td>Projector</td><td>Accuracy</td></tr><tr><td>SimCLR</td><td>2-layer nonlinear projector</td><td>66.5</td></tr><tr><td>SimCLR</td><td>1-layer linear projector</td><td>61.1</td></tr><tr><td>SimCLR</td><td>no projector</td><td>51.5</td></tr><tr><td>DirectCLR</td><td>no projector</td><td>62.7</td></tr></table>
+
+Table 1: Linear probe accuracy on ImageNet. Each model is trained on ImageNet for 100 epochs with standard training recipe. The backbone encoder is a ResNet50. DirectCLR outperforms SimCLR with 1-layer linear projector.
+
+We visualize the learnt representation space spectrum in Figure 9. DirectCLR prevents dimensional collapse in the representation space similar to the functionality of a trainable projector in SimCLR.
+
+![](images/554ab97bfad1e3f1046eb5f59a7f168f19535b8098c5da2a9ba6d8bb28098c66.jpg)  
+Figure 9: Representation space spectrum of $D i$ - rectCLR compared to SimCLR (a) with a 2-layer nonlinear projector (b) with a 1-layer linear projector (c) without projector. The spectrums are computed based on the output from the backbone, using ImgaeNet validation set. Similar to SimCLR with projectors, DirectCLR is able to prevent dimensional collapse in the representation space.
+
+![](images/1ef34db2b106b7f571686bfa23139b06fe03a9951c504072e77faa9f338b4526.jpg)  
+Figure 10: Why is the whole representation vector r meaningful in DirectCLR while only part of it receives gradient? It takes advantage of the residual connection in the backbone. Thus, the gradient passing through the representation vector is low-rank where only the first $d _ { 0 }$ channel dimensions are non-zero. When the gradient enters the ResNet backbone and passes through the last nonlinear conv block, it becomes full rank. Therefore, this hidden layer h receives gradients on all channels. During forward pass, h is directly fed to the representation vectors via the residual connection. Therefore, the entire representation vector r is meaningful.
+
+One may suspect that the contrastive loss in DirectCLR does not apply a gradient on the rest part of the representation vector $\mathbf { r } [ d _ { 0 } : ]$ , then why these dimensions would contain useful information?
+
+Here, we show that the entire representation vector r contains useful information. See Figure 10. First, the gradient backpropagating through the representation vector is low-rank, where only the first $d _ { 0 }$ channel dimensions are non-zero. When the gradient enters the ResNet backbone and passes through the last nonlinear conv block, it becomes full rank. Therefore, this hidden layer h receives gradients on all channels. Note that h and $\mathbf { r }$ have a same channel dimension of 2048. Next, we consider the forward pass. This hidden layer h is directly fed to the representation vectors via the residual connection. As a result, the rest part of the representation vector $\mathbf { r } [ d _ { 0 } \ : ]$ is not trivial. In addition, we run an ablation study in Sec F to test the linear probe accuracy based only on the “directly” optimized vector. This verifies that the whole representation vector is meaningful.
+
+# 6.3 ABLATION STUDY
+
+Table 2: Ablation study: top-1 accuracies on ImageNet by SimCLR model with different projector settings.   
+
+<table><tr><td>Projector</td><td>diagonal</td><td>low-rank</td><td>Top-1 Accuracy</td></tr><tr><td>no projector</td><td></td><td></td><td>51.5</td></tr><tr><td>orthogonal projector</td><td></td><td></td><td>52.2</td></tr><tr><td>trainable projector</td><td></td><td></td><td>61.1</td></tr><tr><td>trainable diagonal projector</td><td>√</td><td></td><td>60.2</td></tr><tr><td>fixed low-rank projector</td><td></td><td>√</td><td>62.3</td></tr><tr><td>fixed low-rank diagonal projector</td><td>√</td><td>√</td><td>62.7</td></tr></table>
+
+To further verify our hypothesis, we have perform ablation studies.
+
+Proposition 1 matches the fact that: (a) an orthogonal constrained projector performs the same as the non-projector setting; (b) fixed low-rank projector performs the same as a fixed diagonal projector; (c) trainable linear projector performs the same as a trainable diagonal projector.
+
+Proposition 2 matches the observation that a low-rank projector has the highest accuracy.
+
+Please see more detailed ablation study discuss and additional ablation experiments in Appendix F.
+
+# 7 CONCLUSIONS
+
+In this work, we showed that contrastive self-supervised learning suffers from dimensional collapse, where the embedding vectors only span a lower-dimensional subspace. We provided the theoretical understanding of this phenomenon and showed that there are two mechanisms causing dimensional collapse: strong augmentation and implicit regularization. Inspired by our theory, we proposed a novel contrastive self-supervised learning method DirectCLR that directly optimizes the representation space without relying on a trainable projector. DirectCLR outperforms SimCLR with a linear projector on ImageNet.
+
+# ACKNOWLEDGEMENT
+
+We thank Yubei Chen, Jiachen Zhu, Adrien Bardes, Nicolas Ballas, Randall Balestriero, Quentin Garrido for useful discussions.
+
+# REPRODUCIBILITY STATEMENT
+
+We provide detailed proof for all the lemmas and theorems in the Appendices. Code (in PyTorch) is available at https://github.com/facebookresearch/directclr
+
+# REFERENCES
+
+Sanjeev Arora, Nadav Cohen, W. Hu, and Yuping Luo. Implicit regularization in deep matrix factorization. In NeurIPS, 2019a.
+
+Sanjeev Arora, H. Khandeparkar, M. Khodak, Orestis Plevrakis, and Nikunj Saunshi. A theoretical analysis of contrastive unsupervised representation learning. In ICML, 2019b.
+
+Mahmoud Assran, Mathilde Caron, Ishan Misra, Piotr Bojanowski, Armand Joulin, Nicolas Ballas, and Michael G. Rabbat. Semi-supervised learning of visual features by non-parametrically predicting view assignments with support samples. ArXiv, abs/2104.13963, 2021.
+
+Adrien Bardes, J. Ponce, and Y. LeCun. Vicreg: Variance-invariance-covariance regularization for self-supervised learning. ArXiv, abs/2105.04906, 2021.
+
+D. Barrett and B. Dherin. Implicit gradient regularization. ArXiv, abs/2009.11162, 2021.
+
+Mathilde Caron, Piotr Bojanowski, Armand Joulin, and M. Douze. Deep clustering for unsupervised learning of visual features. In ECCV, 2018.
+
+Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments. In NeurIPS, 2020.
+
+Mathilde Caron, Hugo Touvron, Ishan Misra, Herv’e J’egou, J. Mairal, Piotr Bojanowski, and Armand Joulin. Emerging properties in self-supervised vision transformers. ArXiv, abs/2104.14294, 2021.
+
+Mario Lezcano Casado and David Mart´ınez-Rubio. Cheap orthogonal constraints in neural networks: A simple parametrization of the orthogonal and unitary group. ArXiv, abs/1901.08428, 2019.
+
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey E. Hinton. A simple framework for contrastive learning of visual representations. 2020a.
+
+Xinlei Chen and Kaiming He. Exploring simple siamese representation learning. In CVPR, 2020.
+
+Xinlei Chen, Haoqi Fan, Ross B. Girshick, and Kaiming He. Improved baselines with momentum contrastive learning. ArXiv, abs/2003.04297, 2020b.
+
+Debidatta Dwibedi, Yusuf Aytar, Jonathan Tompson, Pierre Sermanet, and Andrew Zisserman. With a little help from my friends: Nearest-neighbor contrastive learning of visual representations. ArXiv, abs/2104.14548, 2021.
+
+Jean-Bastien Grill, Florian Strub, Florent Altche, Corentin Tallec, Pierre H. Richemond, Elena ´ Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, Bilal Piot, Koray Kavukcuoglu, Remi Munos, and Michal Valko. Bootstrap your own ´ latent: A new approach to self-supervised learning. In NeurIPS, 2020.
+
+Suriya Gunasekar, Blake E. Woodworth, Srinadh Bhojanapalli, Behnam Neyshabur, and Nathan Srebro. Implicit regularization in matrix factorization. 2018 Information Theory and Applications Workshop (ITA), pp. 1–10, 2018.
+
+Jeff Z. HaoChen, Colin Wei, Adrien Gaidon, and Tengyu Ma. Provable guarantees for selfsupervised deep learning with spectral contrastive loss. ArXiv, abs/2106.04156, 2021.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross B. Girshick. Momentum contrast for unsupervised visual representation learning. 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 9726–9735, 2020.
+
+Tianyu Hua, Wenxiao Wang, Zihui Xue, Yue Wang, Sucheng Ren, and Hang Zhao. On feature decorrelation in self-supervised learning. ArXiv, abs/2105.00470, 2021.
+
+Ziwei Ji and Matus Telgarsky. Gradient descent aligns the layers of deep linear networks. ArXiv, abs/1810.02032, 2019.
+
+L. Jing, J. Zbontar, and Y. LeCun. Implicit rank-minimizing autoencoder. ArXiv, abs/2010.00679, 2020.
+
+J. Lee, Qi Lei, Nikunj Saunshi, and Jiacheng Zhuo. Predicting what you already know helps: Provable self-supervised learning. ArXiv, abs/2008.01064, 2020.
+
+Junnan Li, Pan Zhou, Caiming Xiong, R. Socher, and S. Hoi. Prototypical contrastive learning of unsupervised representations. ArXiv, abs/2005.04966, 2021.
+
+Ishan Misra and L. V. D. Maaten. Self-supervised learning of pretext-invariant representations. 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 6706–6716, 2020a.
+
+Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. In CVPR, 2020b.
+
+Behnam Neyshabur, Zhiyuan Li, Srinadh Bhojanapalli, Y. LeCun, and Nathan Srebro. Towards understanding the role of over-parametrization in generalization of neural networks. ArXiv, abs/1805.12076, 2019.
+
+Adityanarayanan Radhakrishnan, Eshaan Nichani, D. Bernstein, and Caroline Uhler. On alignment in deep linear neural networks. arXiv: Learning, 2020.
+
+Andrew M. Saxe, James L. McClelland, and S. Ganguli. A mathematical theory of semantic development in deep neural networks. Proceedings of the National Academy of Sciences, 116:11537 – 11546, 2019.
+
+Daniel Soudry, E. Hoffer, Suriya Gunasekar, and Nathan Srebro. The implicit bias of gradient descent on separable data. ArXiv, abs/1710.10345, 2018.
+
+Yuandong Tian, Lantao Yu, Xinlei Chen, and Surya Ganguli. Understanding self-supervised learning with dual deep networks. arXiv preprint arXiv:2010.00578, 2020.
+
+Yuandong Tian, Xinlei Chen, and S. Ganguli. Understanding self-supervised learning dynamics without contrastive pairs. ArXiv, abs/2102.06810, 2021.
+
+Christopher Tosh, A. Krishnamurthy, and Daniel J. Hsu. Contrastive learning, multi-view redundancy, and linear models. ArXiv, abs/2008.10150, 2021.
+
+Aaron van den Oord, Y. Li, and Oriol Vinyals. Representation learning with contrastive predictive ¨ coding. ArXiv, abs/1807.03748, 2018.
+
+Jure Zbontar, Li Jing, Ishan Misra, Yann LeCun, and Stephane Deny. Barlow twins: Self-supervised ´ learning via redundancy reduction. arXiv preprint arxiv:2103.03230, 2021.
+
+# A USEFUL LEMMAS
+
+We adapt two useful lemmas from Arora et al. (2019a).
+
+Lemma 4. Given a matrix $W$ and the dynamics that $W$ evolves by $\dot { W }$ , the singular values of this matrix evolve by:
+
+$$
+\dot { \sigma ^ { k } } = \boldsymbol { \mathsf { \pmb { u } } ^ { k ^ { T } } } \dot { W } \boldsymbol { \mathsf { \pmb { \nu } } } ^ { k }
+$$
+
+where $\pmb { u } ^ { k }$ and $\nu ^ { k }$ are singular value $\sigma ^ { k }$ ’s corresponding left and right singular vectors. i.e. the $k$ -th column of matrices $U$ and $V$ respectively.
+
+Proof. Given a matrix $W$ and its singular value decomposition $W = U S V ^ { T }$ . We have the dynamics of the matrix
+
+$$
+\dot { W } = \dot { U } S V ^ { T } + U \dot { S } V ^ { T } + U S \dot { V } ^ { T }
+$$
+
+Multiplying $U ^ { T }$ from the left and multiplying $V$ from the right, considering $U$ and $V$ are orthogonal matrices, we have
+
+$$
+U ^ { T } \dot { W } V = U ^ { T } \dot { U } S + \dot { S } + { \cal S } \dot { V } ^ { T } V
+$$
+
+Since $S = d i a g ( \sigma ^ { k } )$ is a diagonal matrix, we have
+
+$$
+\dot { \sigma ^ { k } } = \mathbf { u } ^ { k ^ { T } } \dot { W } \mathbf { v } ^ { k } - \mathbf { u } ^ { k ^ { T } } \dot { \mathbf { u } } ^ { k } \sigma ^ { k } - \sigma ^ { k } \dot { \mathbf { v } ^ { k ^ { T } } } \mathbf { v } ^ { k }
+$$
+
+Again, considering $\mathbf { u } ^ { k }$ and $\mathbf { v } ^ { k }$ have unit-norm, we have $\mathbf { u } ^ { k ^ { T } } \dot { \mathbf { u } ^ { k } } = 0$ and $\dot { \mathbf { v } ^ { k } } ^ { T } \mathbf { v } ^ { k } = 0$ . Therefore, we derive
+
+$$
+\dot { \sigma ^ { k } } = \mathbf { u } ^ { k ^ { T } } \dot { W } \mathbf { v } ^ { k }
+$$
+
+Lemma 5. Given a matrix $W$ and the dynamics that $W$ evolves by $\dot { W } _ { ; }$ , the singular vectors of this matrix evolve by:
+
+$$
+\begin{array} { r } { \dot { U } = U ( H \odot ( U ^ { T } \dot { W } V S + S V ^ { T } \dot { W } ^ { T } U ) ) } \\ { \dot { V } = V ( H \odot ( V ^ { T } \dot { W } ^ { T } U S + S U ^ { T } \dot { W } V ) ) } \end{array}
+$$
+
+where $\odot$ represents Hadamard element-wise multiplication. $H$ is a skew-symmetric matrix
+
+$$
+H ^ { k , k ^ { \prime } } = { \left\{ \begin{array} { l l } { 1 / ( \sigma ^ { k ^ { 2 } } - { \sigma ^ { k ^ { \prime } } } ^ { 2 } ) } & { i f k \neq k ^ { \prime } } \\ { 0 } & { i f k = k ^ { \prime } } \end{array} \right. }
+$$
+
+Proof. Same as proof for Lemma 1, we start from the following equation
+
+$$
+U ^ { T } \dot { W } V = U ^ { T } \dot { U } S + \dot { S } + S \dot { V } ^ { T } V
+$$
+
+Considering the fact that $U ^ { T } \dot { U }$ and $\Dot { V } ^ { T } V$ are skew-symmetric matrices, whose diagonal terms are all zero, we Hadamard-multiply $\bar { I }$ to both sides of the equation. Here, $\bar { I }$ has all diagonal values equal zeros and all off-diagonal values equal to one, we have
+
+$$
+\bar { I } \odot U ^ { T } \dot { W } V = U ^ { T } \dot { U } S + S \dot { V } ^ { T } V
+$$
+
+Taking transpose, we have
+
+$$
+\bar { I } \odot V ^ { T } \dot { W } U = - S U ^ { T } \dot { U } - \dot { V } ^ { T } V S
+$$
+
+Right-multiplying $S$ to Eqn 16 and left-multiplying $S$ to Eqn 17, then adding them up, we have
+
+$$
+U ^ { T } \dot { U } S ^ { 2 } - S ^ { 2 } U ^ { T } \dot { U } = \bar { I } \odot ( U ^ { T } \dot { W } V S + S V ^ { T } \dot { W } U )
+$$
+
+Therefore, we have
+
+$$
+\dot { U } = U ( H \odot ( U ^ { T } \dot { W } V S + S V ^ { T } \dot { W } ^ { T } U ) )
+$$
+
+where
+
+$$
+H ^ { k , k ^ { \prime } } = { \left\{ \begin{array} { l l } { 1 / ( \sigma ^ { k ^ { 2 } } - { \sigma ^ { k ^ { \prime } } } ^ { 2 } ) } & { { \mathrm { i f ~ } } k \neq k ^ { \prime } } \\ { 0 } & { { \mathrm { i f ~ } } k = k ^ { \prime } } \end{array} \right. }
+$$
+
+Similar proof applies to Eqn 14.
+
+Lemma 6 (Alignment matrix dynamics). The alignment matrix $A$ , defined by $A = V _ { 2 } ^ { T } U _ { 1 }$ , evolves by:
+
+$$
+\dot { A } = - A ( H _ { 1 } \odot ( A ^ { T } F + F ^ { T } A ) ) + ( H _ { 2 } \odot ( A F ^ { T } + F A ^ { T } ) ) A
+$$
+
+where $\odot$ represents Hadamard (element-wise) multiplication. $H _ { l }$ is a skew-symmetric matrix, whose $( k , k ^ { \prime } )$ -entry is given by
+
+$$
+H _ { l } ^ { k , k ^ { \prime } } = { \left\{ \begin{array} { l l } { 1 / ( \sigma _ { l } ^ { k ^ { 2 } } - \sigma _ { l } ^ { { k ^ { \prime } } ^ { 2 } } ) } & { i f k \not = k ^ { \prime } } \\ { 0 } & { i f k = k ^ { \prime } } \end{array} \right. }
+$$
+
+and $F$ is defined by
+
+$$
+F = S _ { 2 } U _ { 2 } ^ { T } G V _ { 1 } S _ { 1 }
+$$
+
+Proof. According to Lemma. 5, we have
+
+$$
+\begin{array} { r } { \dot { U _ { 1 } } = U _ { 1 } ( H _ { 1 } \odot ( U _ { 1 } ^ { T } \dot { W _ { 1 } } V _ { 1 } S _ { 1 } + S _ { 1 } V _ { 1 } ^ { T } \dot { W } _ { 1 } ^ { T } U _ { 1 } ) ) } \\ { \dot { V _ { 2 } } = V _ { 2 } ( H _ { 2 } \odot ( V _ { 2 } ^ { T } \dot { W } _ { 2 } ^ { T } U _ { 2 } S _ { 2 } + S _ { 2 } U _ { 2 } ^ { T } \dot { W _ { 2 } } V _ { 2 } ) ) } \end{array}
+$$
+
+Plugging the above two equations and Eqn 8, the dynamics of the alignment matrix $A = V _ { 2 } ^ { T } U _ { 1 }$ can be written as
+
+$$
+\begin{array} { r c l } { { \dot { \bf 4 } } } & { { = } } & { { V _ { 2 } ^ { T } \dot { U } _ { 1 } + \dot { V } _ { 2 } ^ { T } U _ { 1 } } } \\ { { } } & { { } } & { { } } \\ { { } } & { { = } } &  { V _ { 2 } ^ { T } U _ { 1 } ( H _ { 1 } \odot ( { U _ { 1 } ^ { T } \dot { W } _ { 1 } V _ { 1 } S _ { 1 } + S _ { 1 } V _ { 1 } ^ { T } \dot { W } _ { 1 } ^ { T } U _ { 1 } ) ) + \left( H _ { 2 } \odot ( { V _ { 2 } ^ { T } \dot { W } _ { 2 } ^ { T } U _ { 2 } S _ { 2 } + S _ { 2 } U _ { 2 } ^ { T } \dot { W } _ { 2 } V _ { 2 } )  ^ { T } V _ { 2 } ^ { T } U _ { 2 } } } } \\ \right){ { } } & { { } } & { { } } \\ { { } } & { { = } } &  { - { A } ( H _ { 1 } \odot ( { U _ { 1 } ^ { T } W _ { 2 } ^ { T } G V _ { 1 } S _ { 1 } + S _ { 1 } V _ { 1 } ^ { T } G ^ { T } W _ { 2 } U _ { 1 } } ) ) + ( H _ { 2 } \odot ( { S _ { 2 } U _ { 2 } ^ { T } G W _ { 1 } ^ { T } V _ { 2 } + V _ { 2 } ^ { T } \dot { W } _ { 1 } G ^ { T } U _ { 2 } S _ { 2 } } } \\ { { } } & { { } } & { { } } \\ { { } } & { { = } } &  { - { A } ( H _ { 1 } \odot ( { U _ { 1 } ^ { T } V _ { 2 } S _ { 2 } U _ { 2 } ^ { T } G V _ { 1 } S _ { 1 } + S _ { 1 } V _ { 1 } ^ { T } G ^ { T } U _ { 2 } S _ { 2 } V _ { 2 } ^ { T } U _ { 1 } ) ) } } \\ { { } } & { { } } & { { } } \\ { { } } & { { } } &  { + ( H _ { 2 } \odot ( { S _ { 2 } U _ { 2 } ^ { T } G V _ { 1 } S _ { 1 } U _ { 1 } ^ { T } V _ { 2 } + V _ { 2 } ^ { T } U _ { 1 } S _ { 1 } V _ { 1 } ^ { T } G ^ { T } U _ { 2 } S _ { 2 } ) ) A } } \\ { { } } & { { } } & { { } } \\   \end{array}
+$$
+
+where
+
+$$
+F = S _ { 2 } U _ { 2 } ^ { T } G V _ { 1 } S _ { 1 }
+$$
+
+Lemma 7 (Singular value dynamics). The singular values of the weight matrices $W _ { 1 }$ and $W _ { 2 }$ evolve by:
+
+$$
+\begin{array} { r l } & { \dot { \sigma _ { 1 } ^ { k } } = - \displaystyle \sum _ { k ^ { \prime } } ( { \pmb { \nu } _ { 2 } ^ { k ^ { \prime } } } ^ { T } { \pmb { u } } _ { 1 } ^ { k } ) \sigma _ { 2 } ^ { k ^ { \prime } } ( { \pmb { u } } _ { 2 } ^ { k ^ { \prime } } { } ^ { T } G { \pmb { \nu } } _ { 1 } ^ { k } ) } \\ & { \dot { \sigma _ { 2 } ^ { k } } = - \displaystyle \sum _ { k ^ { \prime } } ( { \pmb { u } } _ { 1 } ^ { k ^ { \prime } } { \pmb { \nu } } _ { 2 } ^ { k } ) \sigma _ { 1 } ^ { k ^ { \prime } } ( { \pmb { u } } _ { 2 } ^ { k ^ { \prime } } G { \pmb { \nu } } _ { 1 } ^ { k ^ { \prime } } ) } \end{array}
+$$
+
+Proof. According to Lemma 4,
+
+$$
+\dot { \sigma } _ { 1 } ^ { r } = \mathbf { u } _ { 1 } ^ { r T } \dot { W } _ { 1 } \mathbf { v } _ { 1 } ^ { r }
+$$
+
+Plugging in Eqn 8, we have
+
+$$
+\begin{array} { r c l } { \dot { \boldsymbol { \sigma } } _ { 1 } ^ { k } } & { = } & { - \mathbf { u } _ { 1 } ^ { k ^ { T } } \boldsymbol { W } _ { 2 } ^ { T } \boldsymbol { G } \mathbf { v } _ { 1 } ^ { k } } \\ & { = } & { - \mathbf { u } _ { 1 } ^ { k ^ { T } } \boldsymbol { V } _ { 2 } \boldsymbol { S } _ { 2 } \boldsymbol { U } _ { 2 } ^ { T } \boldsymbol { G } \mathbf { v } _ { 1 } ^ { k } } \\ & { = } & { - \displaystyle \sum _ { k ^ { \prime } } ( \mathbf { v } _ { 2 } ^ { { k ^ { \prime } } ^ { T } } \mathbf { u } _ { 1 } ^ { k } ) \sigma _ { 2 } ^ { k ^ { \prime } } ( { \mathbf { u } _ { 2 } ^ { k ^ { \prime } } } ^ { T } \boldsymbol { G } \mathbf { v } _ { 1 } ^ { k } ) } \end{array}
+$$
+
+Similar proof applies to Eqn 22.
+
+# B DELAYED PROOFS
+
+# B.1 PROOF OF LEMMA 1
+
+The gradient on matrix $W$ is
+
+$$
+\frac { d L } { d W } = \sum _ { i } ( \frac { \partial L } { \partial \mathbf { z } _ { i } } \frac { \partial \mathbf { z } _ { i } } { \partial W } + \frac { \partial L } { \partial \mathbf { z } _ { i } ^ { \prime } } \frac { \partial \mathbf { z } _ { i } ^ { \prime } } { \partial W } )
+$$
+
+We denote the gradient on $\mathbf { z } _ { i }$ and $\mathbf { z } _ { i } ^ { \prime }$ as $\mathbf { g } _ { \mathbf { z } _ { i } }$ and $\mathbf { g } _ { \mathbf { z } _ { i } ^ { \prime } }$ , respectively. Since $\begin{array} { r } { \frac { \partial \mathbf { z } _ { i } } { \partial W } = \mathbf { x } _ { i } } \end{array}$ and $\frac { \partial \mathbf { z } _ { i } ^ { \prime } } { \partial W } = \mathbf { x } _ { i } ^ { \prime }$ , we get
+
+$$
+\dot { W } = - ( \frac { d L } { d W } ) ^ { T } = - \sum _ { i } ( \mathbf { g _ { z _ { i } } } \mathbf { x } _ { i } ^ { T } + \mathbf { g _ { z _ { i } ^ { \prime } } } \mathbf { x } _ { i } ^ { \prime T } )
+$$
+
+# B.2 PROOF OF LEMMA 2
+
+Proof. $X$ is defined in Eqn 6.
+
+$$
+\begin{array} { l c l } { { { \mathrm {  ~ { \cal ~ { \cal ~ { \cal { Y } } } ~ } } } } } & { { = } } & { { \displaystyle \sum _ { i } ( \displaystyle \sum _ { j \neq i } \alpha _ { i j } ( { \bf x } _ { i } ^ { \prime } - { \bf x } _ { j } ) + \displaystyle \sum _ { j \neq i } \alpha _ { j i } ( { \bf x } _ { i } - { \bf x } _ { j } ) ) { \bf x } _ { i } ^ { T } - \displaystyle \sum _ { i } ( 1 - \alpha _ { i i } ) ( { \bf x } _ { i } ^ { \prime } - { \bf x } _ { i } ) { \bf x } _ { i } ^ { \prime } } } \\ { { } } & { { = } } & { { \displaystyle \sum _ { i } \displaystyle \sum _ { j \neq i } \alpha _ { i j } { \bf x } _ { i } ^ { \prime } { \bf x } _ { i } ^ { T } - \displaystyle \sum _ { i } \sum _ { j \neq i } \alpha _ { i j } { \bf x } _ { j } { \bf x } _ { i } ^ { T } + \displaystyle \sum _ { i } \sum _ { j \neq i } \sum _ { j } \alpha _ { j i } ( { \bf x } _ { i } - { \bf x } _ { j } ) ( { \bf x } _ { i } - { \bf x } _ { j } ) ^ { T } } } \\ { { } } & { { } } & { { + \displaystyle \sum _ { i } \sum _ { j \neq i } \alpha _ { j i } ( { \bf x } _ { i } - { \bf x } _ { j } ) { \bf x } _ { j } ^ { T } - \displaystyle \sum _ { i } ( 1 - \alpha _ { i i } ) ( { \bf x } _ { i } ^ { \prime } - { \bf x } _ { i } ) ( { \bf x } _ { i } ^ { \prime } - { \bf x } _ { i } ) ^ { T } - \displaystyle \sum _ { i } ( 1 - \alpha _ { i i } ) ( { \bf x } _ { i } ^ { \prime } - { \bf x } _ { i } ) { \bf x } _ { i } ^ { T } } } \end{array}
+$$
+
+Given the fact that $\begin{array} { r } { \sum _ { j \neq i } \alpha _ { i j } = 1 - \alpha _ { i i } } \end{array}$ , we have $\begin{array} { r } { \sum _ { i } \sum _ { j \neq i } \alpha _ { i j } \mathbf { x } _ { i } ^ { \prime } \mathbf { x } _ { i } ^ { T } = \sum _ { i } ( 1 - \alpha _ { i i } ) \mathbf { x } _ { i } ^ { \prime } \mathbf { x } _ { i } ^ { T } } \end{array}$ . Also, since $\textstyle \sum _ { i } \sum _ { j \neq i }$ iterates all pairs of $i , j$ , we can replace the index between $i$ and $j$ , we have $\begin{array} { r } { \sum _ { i } \sum _ { j \neq i } \alpha _ { i j } \mathbf { \bar { x } } _ { j } \mathbf { x } _ { i } ^ { T } = \sum _ { i } \sum _ { j \neq i } \alpha _ { j i } \mathbf { x } _ { i } \mathbf { x } _ { j } ^ { T } } \end{array}$ .
+
+Therefore
+
+$$
+X = \sum _ { i } \sum _ { j \neq i } \alpha _ { j i } ( { \bf x } _ { i } - { \bf x } _ { j } ) ( { \bf x } _ { i } - { \bf x } _ { j } ) ^ { T } - \sum _ { i } ( 1 - \alpha _ { i i } ) ( { \bf x } _ { i } ^ { \prime } - { \bf x } _ { i } ) ( { \bf x } _ { i } ^ { \prime } - { \bf x } _ { i } ) ^ { T }
+$$
+
+# B.3 PROOF OF THEOREM 1
+
+Proof. According to Lemma 1, we have
+
+$$
+{ \frac { d } { d t } } W = W X
+$$
+
+For a fixed $X$ , we solve this equation analyically,
+
+$$
+W ( t ) = W ( 0 ) \exp ( X t )
+$$
+
+Apply eigen-decomposition on $X$ , $\boldsymbol { X } = \boldsymbol { U } \boldsymbol { \Lambda } \boldsymbol { U } ^ { T }$ . Then we have $\exp ( X t ) = U \exp ( \Lambda t ) U ^ { T }$ . Therefore,
+
+$$
+W ( t ) = W ( 0 ) U \exp ( \Lambda t ) U ^ { T }
+$$
+
+Because $X$ has negative eigenvalues, i.e., $\Lambda$ has negative terms, we have for $t \to \infty$ , $\exp ( \Lambda t )$ is rank deficient. Therefore, we know that $W ( \infty )$ is also rank deficient, the weight matrix $W$ has vanishing singular values.
+
+# B.4 PROOF OF LEMMA 3
+
+Proof. The gradient on matrix $W _ { 2 }$ is
+
+$$
+\frac { d L } { d W _ { 2 } } = \sum _ { i } ( \frac { \partial L } { \partial \mathbf { z } _ { i } } \frac { \partial \mathbf { z } _ { i } } { \partial W _ { 2 } } + \frac { \partial L } { \partial \mathbf { z } _ { i } ^ { \prime } } \frac { \partial \mathbf { z } _ { i } ^ { \prime } } { \partial W _ { 2 } } )
+$$
+
+We denote the gradient on $\mathbf { z } _ { i }$ and $\mathbf { z } _ { i } ^ { \prime }$ as $\mathbf { g } _ { \mathbf { z } _ { i } }$ and $\mathbf { g } _ { \mathbf { z } _ { i } ^ { \prime } }$ , respectively. Since $\begin{array} { r } { \frac { \partial \mathbf { z } _ { i } } { \partial W _ { 2 } } = W _ { 1 } \mathbf { x } _ { i } } \end{array}$ and $\begin{array} { r } { \frac { \partial \mathbf { z } _ { i } ^ { \prime } } { \partial W _ { 2 } } = } \end{array}$ $W _ { 1 } \mathbf { x } _ { i } ^ { \prime }$ , we get
+
+$$
+\dot { W _ { 2 } } = - ( \frac { d L } { d W _ { 2 } } ) ^ { T } = - \sum _ { i } ( \mathbf { g } _ { \mathbf { z } _ { i } } \mathbf { x } _ { i } ^ { T } + \mathbf { g } _ { \mathbf { z } _ { i } ^ { \prime } } \mathbf { x } _ { i } ^ { \prime T } ) W _ { 1 } ^ { T }
+$$
+
+Similar proof applies to $W _ { 1 }$ .
+
+# B.5 PROOF OF THEOREM 2
+
+Here, we prove that under the assumption that singular values are non-degenerate, the alignment matrix $A \doteq V _ { 2 } ^ { T } U _ { 1 }$ converges to identity matrix.
+
+Proof. According to Lemma 3, we have
+
+$$
+\begin{array} { c } { \displaystyle \frac { d } { d t } ( W _ { 1 } W _ { 1 } ^ { T } ) = - W _ { 1 } G ^ { T } W _ { 2 } - W _ { 2 } ^ { T } G W _ { 1 } ^ { T } } \\ { \displaystyle \frac { d } { d t } ( W _ { 2 } ^ { T } W _ { 2 } ) = - W _ { 2 } ^ { T } G W _ { 1 } ^ { T } - W _ { 1 } G ^ { T } W _ { 2 } } \end{array}
+$$
+
+therefore,
+
+or
+
+$$
+\begin{array} { c } { { \displaystyle \frac { d } { d t } ( W _ { 1 } W _ { 1 } ^ { T } - W _ { 2 } ^ { T } W _ { 2 } ) = 0 } } \\ { { { } } } \\ { { W _ { 1 } W _ { 1 } ^ { T } - W _ { 2 } ^ { T } W _ { 2 } = C } } \end{array}
+$$
+
+Next, we show that the Frobenius norm of each weight matrix grow to infinitely.
+
+$$
+\frac { d } { d t } | | W _ { 1 } | | _ { F } ^ { 2 } = \frac { d } { d t } t r ( W _ { 1 } W _ { 1 } ^ { T } ) = - t r ( W _ { 2 } ^ { T } G W _ { 1 } ^ { T } ) - t r ( W _ { 1 } G _ { 1 } ^ { T } W _ { 2 } )
+$$
+
+According to Eqn 9, $G = - W _ { 2 } W _ { 1 } X$ , we have
+
+$$
+\begin{array} { r l r } { - t r ( W _ { 2 } ^ { T } G W _ { 1 } ^ { T } ) } & { = } & { t r ( W _ { 2 } ^ { T } W _ { 2 } W _ { 1 } X W _ { 1 } ^ { T } ) } \\ & { = } & { t r ( W _ { 2 } W _ { 1 } X W _ { 1 } ^ { T } W _ { 2 } ^ { T } ) } \end{array}
+$$
+
+Because $X$ is a positive definite matrix and for all $t .$ , $W _ { 2 } ( t ) W _ { 1 } ( t ) ~ \neq ~ 0 .$ , we know $B : =$ $W _ { 2 } W _ { 1 } X W _ { 1 } ^ { T } W _ { 2 } ^ { T }$ is positive semi-definite and $B \neq 0$ . Therefore, $\begin{array} { r } { t r ( \dot { B } ) = \sum _ { k } \lambda _ { k } ( B ) > 0 } \end{array}$ since not all eigenvalues of $B$ are zero.
+
+Therefore, we know $| | W _ { 1 } | | _ { F } ^ { 2 } \to + \infty$ (similarly $| | W _ { 2 } | | _ { F } ^ { 2 } \to + \infty )$ . In the limit $t - > + \infty$ , we have
+
+$$
+W _ { 1 } W _ { 1 } ^ { T } = W _ { 2 } ^ { T } W _ { 2 }
+$$
+
+Plug in the singular value decomposition of $W _ { 1 }$ and $W _ { 2 }$ , we have $U _ { 1 } S _ { 1 } ^ { 2 } U _ { 1 } ^ { T } = V _ { 2 } S _ { 2 } ^ { 2 } V _ { 2 } ^ { T }$ . Assuming $W _ { 1 }$ and $W _ { 2 }$ have non-degenerate singular values, due to the uniqueness of eigen-decomposition, we have
+
+$$
+U _ { 1 } = V _ { 2 }
+$$
+
+therefore,
+
+$$
+V _ { 2 } ^ { T } U _ { 1 } = I
+$$
+
+Remark. Note that when the non-degenerate singular value assumption does not hold, the corresponding singular vectors are not unique and we will not observe the corresponding dimensions becoming aligned.
+
+# B.6 PROOF OF THEOREM 3
+
+Proof. According to Theorem 2, for $\sigma _ { 1 } ^ { k }$ and $\boldsymbol { \sigma } _ { 2 } ^ { k }$ with same index, the corresponding singular vector pairs $\mathbf { v } _ { 2 } ^ { k }$ and $\mathbf { u } _ { 1 } ^ { k }$ will get aligned, i.e., $\mathbf { v } _ { 2 } ^ { k ^ { \prime } } \mathbf { u } _ { 1 } ^ { k } \to \delta _ { i , j }$ . Therefore, Eqn 21 and Eqn 22 can be simplified to
+
+$$
+\begin{array} { r } { \dot { \sigma _ { 1 } ^ { k } }  - \sigma _ { 2 } ^ { k } ( \mathbf { u } _ { 2 } ^ { k ^ { T } } G \mathbf { v } _ { 1 } ^ { k } ) } \\ { \dot { \sigma _ { 2 } ^ { k } }  - \sigma _ { 1 } ^ { k } ( \mathbf { u } _ { 2 } ^ { k ^ { T } } G \mathbf { v } _ { 1 } ^ { k } ) } \end{array}
+$$
+
+Insert Eqn 9 and considering the alignment, we derive
+
+$$
+\begin{array} { r l } & { \dot { \sigma } _ { 1 } ^ { k } \to \sigma _ { 1 } ^ { k } ( \sigma _ { 2 } ^ { k } ) ^ { 2 } ( \mathbf { v } _ { 1 } ^ { k ^ { T } } X \mathbf { v } _ { 1 } ^ { k } ) } \\ & { \dot { \sigma } _ { 2 } ^ { k } \to \sigma _ { 2 } ^ { k } ( \sigma _ { 1 } ^ { k } ) ^ { 2 } ( \mathbf { v } _ { 1 } ^ { k ^ { T } } X \mathbf { v } _ { 1 } ^ { k } ) } \end{array}
+$$
+
+# C EFFECT OF MORE LAYERS AND NONLINEARITY
+
+In our toy model, we focused on a two-layer linear MLP setting. Here, we empirically show that our theory extends to multilayer and nonlinear cases, as shown in Figure 11a.
+
+Stronger over-parametrization leads to a stronger collapsing effect, which has been shown theoretically (Arora et al., $2 0 1 9 \mathrm { a }$ ; Barrett & Dherin, 2021) and empirically (Jing et al., 2020). This can be explained by the fact that more adjacent matrices getting aligned, and the collapsing in the product matrix gets amplified. Note that for a single-layer case, $L = 1$ , there is no dimensional collapse in the embedding space, which is consistent with our analysis.
+
+![](images/a26f9542ef0be9eccbb8e7d6ae83e3e467542dfa2b0b123852b9f8e042f6549b.jpg)  
+Figure 11: Embedding space singular value spectrum with different layers on (a) linear and (b) nonlinear networks. All models use weight matrices with a size of 16x16. Adding more layers in the network leads to more collapsed dimensions. Adding nonlinearity leads to a similar collapsing effect.
+
+We empirically show that the collapsing effect also applies to the nonlinear scenario. We insert ReLU between linear layers and observe a similar singular value collapse compared to the linear case. See Figure 11b.
+
+# D IMPLEMENTATION DETAIL
+
+# D.1 AUGMENTATIONS
+
+Each input image is transformed twice to produce the two distorted views for contrastive loss. The image augmentation pipeline includes random cropping, resizing to $2 2 4 \mathbf { x } 2 2 4$ , random horizontal flipping, color jittering, grayscale, Gaussian blurring, and solarization.
+
+# D.2 NETWORK
+
+Throughout the ImageNet experiments in this paper, we use a ResNet-50 (He et al., 2016) as an encoder. This network has an output of dimension 2048, which is called a representation vector.
+
+# D.3 OPTIMIZATION
+
+We use a LARS optimizer and train all models for 100 epochs. The batch size is 4096, which fits into 32 GPUs during training. The learning rate is 4.8 as in SimCLR (Chen et al., 2020a), which goes through a 10 epoch of warming up and then a cosine decay schedule.
+
+# E HYPERPARAMETER TUNING ON $d _ { 0 }$
+
+Here, we list the ImageNet accuracy with various $d _ { 0 }$ value in Figure 12. It’s easy to see that when $d _ { 0 } \to 0$ , there’s too little gradient information coming from the loss, the performance drops. When $d _ { 0 } \to 2 0 4 8$ , the model converges to standard SimCLR without a projector, which we know suffers from dimensional collapse in representation space.
+
+![](images/35c15544bb8f3a55059e5602061659484aa62d551d4b94f4e7c26e1ab3d0ee1a.jpg)  
+Figure 12: Hyperparameter tuning on $d _ { 0 }$ based on ImageNet linear probe Top-1 accuracy.
+
+# F ABLATION STUDY DETAIL
+
+Fixed low-rank projector vs Fixed low-rank diagonal projector: DirectCLR is equivalent to SimCLR with a fixed low-rank diagoanl projector. It performs the same as a SimCLR with fixed low-rank projector, which achieves $6 2 . 3 \%$ linear probe accuracy. Specifically, the singular values of this low-rank matrix are set to have $d _ { 0 }$ numbers of 1 and 0 for the rest, then left- and right- multiply a fixed orthogonal matrix. Therefore, their only difference is that this fixed projector has an extra fixed orthogonal matrix in between.
+
+Trainable projector vs trainable diagonal projector: We trained a SimCLR model with a trainable projector that is constrained be diagonal. The model achieves $6 0 . 2 \%$ linear probe accuracy on ImageNet, which is close to a SimCLR with a 1-layer linear projector.
+
+Orthogonal projector vs no projector: We train a single layer projector SimCLR model with orthogonal constraint using ExpM parametrization (Casado & Mart´ınez-Rubio, 2019). Therefore, the projector weight matrix has all singular values fixed to be 1. This model reaches $5 2 . 2 \%$ accuracy on ImageNet which is close to a SimCLR without projector.
+
+These ablation studies verify the propostion 1 that the SimCLR projector only needs to be diagonal. Also, according to Table 2, we find that low-rank projector setting consistently improves the performance, which verifies proposition 2.
+
+Linear probe on subvector instead of the entire vector: For DirectCLR, we perform a linear probe only on the sub-vector z and get $4 7 . 9 \%$ accuracy on ImageNet. This shows that the rest of $\mathbf { r }$ still contains useful information even though it does not see gradient directly coming from the loss function.
+
+Random dropout instead of fixed subvector: Since DirectCLR drops out a number of dimensions for the loss function, it would be natural to ask whether random dropping out can reach the same performance. We train a SimCLR model without a projector and randomly feed $d _ { 0 }$ number of features to InfoNCE loss every iteration. This model reaches only $4 3 . 0 \%$ accuracy on ImageNet. This demonstrates the importance of applying a fixed subvector, which allows the alignment effect to happen.

parse/dev/aBO5SvgSt1/aBO5SvgSt1.md

@@ -0,0 +1,473 @@
+# MIRROR DESCENT POLICY OPTIMIZATION
+
+Manan Tomar ∗ University of Alberta, Amii manan.tomar@gmail.com
+
+Lior Shani   
+Technion, Israel   
+shanlior@gmail.com
+
+Yonathan Efroni Microsoft Research NYC yefroni@microsoft.com
+
+Mohammad Ghavamzadeh Google Research ghavamza@google.com
+
+# ABSTRACT
+
+Mirror descent (MD), a well-known first-order method in constrained convex optimization, has recently been shown as an important tool to analyze trust-region algorithms in reinforcement learning (RL). However, there remains a considerable gap between such theoretically analyzed algorithms and the ones used in practice. Inspired by this, we propose an efficient RL algorithm, called mirror descent policy optimization (MDPO). MDPO iteratively updates the policy by approximately solving a trust-region problem, whose objective function consists of two terms: a linearization of the standard RL objective and a proximity term that restricts two consecutive policies to be close to each other. Each update performs this approximation by taking multiple gradient steps on this objective function. We derive on-policy and off-policy variants of MDPO, while emphasizing important design choices motivated by the existing theory of MD in RL. We highlight the connections between on-policy MDPO and two popular trust-region RL algorithms: TRPO and PPO, and show that explicitly enforcing the trust-region constraint is in fact not a necessity for high performance gains in TRPO. We then show how the popular soft actor-critic (SAC) algorithm can be derived by slight modifications of off-policy MDPO. Overall, MDPO is derived from the MD principles, offers a unified approach to viewing a number of popular RL algorithms, and performs better than or on-par with TRPO, PPO, and SAC in a number of continuous and discrete control tasks.
+
+# 1 INTRODUCTION
+
+An important class of RL algorithms consider an additional objective in their policy optimization that aims at constraining the consecutive policies to remain close to each other. These algorithms are referred to as trust region or proximity-based, resonating the fact that they make the new policy to lie within a trust-region around the old one. This class includes the theoretically grounded conservative policy iteration (CPI) algorithm [15], as well as the state-of-the-art deep RL algorithms, such as trust-region policy optimization (TRPO) [26] and proximal policy optimization (PPO) [28]. The main difference between these algorithms is in the way that they enforce the trust-region constraint. TRPO enforces it explicitly through a line-search procedure that ensures the new policy is selected such that its KL-divergence with the old policy is below a certain threshold. PPO takes a more relaxed approach and updates its policies by solving an unconstrained optimization problem in which the ratio of the new to old policies is clipped to remain bounded. It has been shown that this procedure does not prevent the policy ratios to go out of bound, and only reduces its probability [31, 9].
+
+Mirror descent (MD) [6, 4] is a first-order optimization method for solving constrained convex problems. Although MD is theoretically well-understood in optimization [3, 14], only recently, has it been investigated for policy optimization in RL [25, 12, 20, 29, 1]. Despite the progress made by these results in establishing connections between MD and trust-region policy optimization, there are still considerable gaps between the trust-region RL algorithms that have been theoretically analyzed in their tabular form [29] and those that are used in practice, such as TRPO and PPO.
+
+In this paper, motivated by the theory of MD in tabular RL, our goal is to derive scaleable and practical RL algorithms from the MD principles, and to use the MD theory to better understand and explain the popular trust-region policy optimization methods. Going beyond the tabular case, when the policy belongs to a parametric class, the trust-region problems for policy update in RL cannot be solved in closed-form. We propose an algorithm, called mirror descent policy optimization (MDPO), that addresses this issue by approximately solving these trust-region problems via taking multiple gradient steps on their objective functions. We derive on-policy and off-policy variants of MDPO (Section 4). We highlight the connection between on-policy MDPO and TRPO and PPO (Section 4.1), and empirically compare it against these algorithms on several continuous control tasks from OpenAI Gym [7] (Section 5.3). We then show that if we define the trust-region w.r.t. the uniform policy, instead of the old one, our off-policy MDPO coincides with the popular soft actor-critic (SAC) algorithm [13]. We discuss this connection in detail (Section 4.2) and empirically compare these algorithms using the same set of continuous control problems (Section 5.4).
+
+Our observations on the comparison between the MDPO algorithms and TRPO, PPO, and SAC are a result of extensive empirical studies on different versions of these algorithms (Section 5 and Appendices E and F). In particular, we first compare the vanilla versions of these algorithms in order to better understand how the core of these methods work relative to each other. We then add a number of code-level optimization techniques derived from the code-bases of TRPO, PPO, and SAC to these algorithms to compare their best form (those that obtain the best results reported in the literature) against each other, while also evaluating MDPO with PPO on 21 Atari games. We address the common belief within the community that explicitly
+
+![](images/98556dc887fc782d5df6722bf418348e2576929ca714b969880c5cc0ee66ecf4.jpg)  
+Figure 1: Overall Comparison. Between MDPO, PPO, and TRPO, MDPO provides the best trade-off in terms of best average performance, less (normalized) wall clock times, and least number of algorithm specific hyper parameters used.
+
+enforcing the trust-region constraint is a necessity for good performance in TRPO, by showing that MDPO, a trust-region method based on the MD principles, does not require enforcing a hard constraint and achieves strong performance by solely solving an unconstrained problem. We address another common belief that PPO is a better performing algorithm than TRPO. By reporting results of both the vanilla version and the version loaded with code-level optimization techniques for all algorithms, we show that in both cases, TRPO consistently outperforms PPO. This is in line with some of the findings from a recent study on PPO and TRPO [9]. Finally, we provide an optimization perspective for SAC, instead of its initial motivation as an entropy-regularized (soft) approximate dynamic programming algorithm. Through comprehensive experiments, we show that on-policy and off-policy MDPO achieve state-of-the-art performance across a number of benchmark tasks, and can be excellent alternatives to popular policy optimization algorithms, such as TRPO, PPO, and SAC.
+
+# 2 PRELIMINARIES
+
+In this paper, we assume that the agent’s interaction with the environment is modeled as a $\gamma$ -discounted Markov decision process (MDP), denoted by $\mathcal { M } = ( \mathcal { S } , \mathcal { A } , P , R , \gamma , \mu )$ , where $s$ and $\mathcal { A }$ are the state and action spaces; $P \equiv P ( s ^ { \prime } | s , a )$ is the transition kernel; $R \equiv r ( s , a )$ is the reward function; $\gamma \in ( 0 , 1 )$ is the discount factor; and $\mu$ is the initial state distribution. Let $\pi : { \mathcal { S } }  \Delta _ { \mathcal { A } }$ be a stationary Markovian policy, where $\Delta _ { \mathcal { A } }$ is the set of probability distributions on $\mathcal { A }$ . The discounted frequency of visiting a state $s$ by following a policy $\pi$ is defined as $\begin{array} { r } { \rho _ { \pi } ( s ) \equiv ( 1 - \gamma ) \mathbb { E } [ \sum _ { t \geq 0 } \gamma ^ { t } \mathbb { I } \{ s _ { t } = s \} | \dot { \mu } , \pi ] } \end{array}$ . The value function of a policy $\pi$ at a state $s \in S$ is defined as $\begin{array} { r } { V ^ { \pi } ( s ) \equiv \mathbb { E } [ \sum _ { t \geq 0 } \gamma ^ { t } r ( s _ { t } , a _ { t } ) \vert s _ { 0 } = s , \pi ] } \end{array}$ . Similarly, the action-value function of $\pi$ is defined as $\begin{array} { r } { Q ^ { \pi } ( s , a ) = \mathbb { E } [ \sum _ { t \geq 0 } \gamma ^ { t } r ( s _ { t } , a _ { t } ) | s _ { 0 } = s , a _ { 0 } = } \end{array}$ $a , \pi ]$ . The difference between the action-value $Q$ and value $V$ functions is referred to as the advantage function $A ^ { \pi } ( s , a ) = Q ^ { \pi } ( s , a ) - V ^ { \pi } ( s )$ .
+
+Since finding an optimal policy for an MDP involves solving a non-linear system of equations and the optimal policy may be deterministic (less explorative), many researchers have proposed to add a regularizer in the form of an entropy term to the reward function, and then solve the entropyregularized (or soft) MDP (e.g., [16, 30, 25]). In this formulation, the reward function is modified as $r _ { \lambda } \bar { ( } s , a ) = r ( s , a ) + \lambda H ( \pi ( \cdot \bar { | } s ) )$ , where $\lambda$ is the regularization parameter and $H$ is an entropy-related term, such as Shannon entropy [10, 23], Tsallis entropy [17, 24], or relative entropy [2, 22]. Setting $\lambda = 0$ , we return to the original formulation, also referred to as the hard MDP. In what follows, we use the terms ‘regularized’ and ‘soft’ interchangeably.
+
+# 2.1 MIRROR DESCENT IN CONVEX OPTIMIZATION
+
+Mirror Descent (MD) [4] is a first-order trust-region optimization method for solving constrained convex problems, i.e., $x ^ { * } \in \arg \operatorname* { m i n } _ { x \in C } f ( x )$ , where $f$ is a convex function and the constraint set $C$ is convex compact. In each iteration, MD minimizes a sum of two terms: 1) a linear approximation of the objective function $f$ at the previous estimate $x _ { k }$ , and 2) a proximity term that measures the distance between the updated $x _ { k + 1 }$ and current $x _ { k }$ estimates. MD is considered a trust-region method, since the proximity term keeps the updates $x _ { k }$ and $x _ { k + 1 }$ close to each other. We may write the MD update as
+
+$$
+x _ { k + 1 } \in \mathop { \arg \operatorname* { m i n } } _ { x \in C } \langle \nabla f ( x _ { k } ) , x - x _ { k } \rangle + \frac { 1 } { t _ { k } } B _ { \psi } ( x , x _ { k } ) ,
+$$
+
+where $B _ { \psi } ( x , x _ { k } ) : = \psi ( x ) - \psi ( x _ { k } ) - \langle \nabla \psi ( x _ { k } ) , x - x _ { k } \rangle$ is the Bregman divergence associated with a strongly convex potential function $\psi$ , and $t _ { k }$ is a step-size determined by the MD analysis. When $\begin{array} { r } { \psi = \frac { 1 } { 2 } \| \cdot \| _ { 2 } ^ { 2 } } \end{array}$ , the Bergman divergence is the Euclidean distance $\begin{array} { r } { B _ { \psi } ( x , x _ { k } ) = \frac 1 2 \| x - x _ { k } \| _ { 2 } ^ { 2 } } \end{array}$ , and (1) becomes the projected gradient descent algorithm [3]. When $\psi$ is the negative Shannon entropy, the Bregman divergence term takes the form of the KL divergence, i.e., $B _ { \psi } ( x , x _ { k } ) = \operatorname { K L } ( x , x _ { k } )$ . In this case, when the constraint set $C$ is the unit simplex, $C = \Delta _ { \mathcal { X } }$ , MD becomes the exponentiated gradient descent algorithm and (1) has the following closed form [4]:
+
+$$
+x _ { k + 1 } ^ { i } = \frac { x _ { k } ^ { i } \exp \big ( - t _ { k } \nabla _ { i } f ( x _ { k } ) \big ) } { \sum _ { j = 1 } ^ { n } x _ { k } ^ { j } \exp \big ( - t _ { k } \nabla _ { j } f ( x _ { k } ) \big ) } ,
+$$
+
+where $\ v x _ { k } ^ { i }$ and $\nabla _ { i } f$ are the $i ^ { \mathrm { { t h } } }$ coordinates of $x _ { k }$ and $\nabla f$ .
+
+# 3 MIRROR DESCENT IN RL
+
+The goal in RL is to find an optimal policy $\pi ^ { * }$ . Two common notions of optimality, and as a result, two distinct ways to formulate RL as an optimization problem are as follows:
+
+$$
+\pi ^ { * } ( \cdot | s ) \in \arg \operatorname* { m a x } _ { \pi } V ^ { \pi } ( s ) , \forall s \in \mathcal { S } , \qquad \quad \mathbf { ( b ) } \quad \pi ^ { * } \in \arg \operatorname* { m a x } _ { \pi } \mathbb { E } _ { s \sim \mu } \left[ V ^ { \pi } ( s ) \right] .
+$$
+
+In (3a), the value function is optimized over the entire state space $s$ . This formulation is mainly used in value function based RL algorithms. On the other hand, the formulation in (3b) is more common in policy optimization, where a scalar that is the value function at the initial state $( s \sim \mu )$ ) is optimized.
+
+Unlike the MD optimization problem, the objective function is not convex in $\pi$ in either of the above two RL optimization problems. Despite this issue, [12] and [29] have shown that we can still use the general MD update rule (1) and derive MD-style RL algorithms with the update rules
+
+$$
+\begin{array} { r l } & { \pi _ { k + 1 } ( \cdot | s ) \gets \underset { \pi \in \Pi } { \mathrm { a r g ~ m a x ~ } } \mathbb { E } _ { a \sim \pi } \big [ A ^ { \pi _ { k } } ( s , a ) \big ] - \frac { 1 } { t _ { k } } \mathrm { K L } ( s ; \pi , \pi _ { k } ) , \quad \forall s \in \mathcal { S } , } \\ & { \pi _ { k + 1 } \gets \underset { \pi \in \Pi } { \mathrm { a r g ~ m a x ~ } } \mathbb { E } _ { s \sim \rho _ { \pi _ { k } } } \Big [ \mathbb { E } _ { a \sim \pi } \big [ A ^ { \pi _ { k } } ( s , a ) \big ] - \frac { 1 } { t _ { k } } \mathrm { K L } ( s ; \pi , \pi _ { k } ) \Big ] , } \end{array}
+$$
+
+for the optimization problems (3a) and (3b), respectively. Note that while in (4), the policy is optimized uniformly over the state space $s$ , in (5), it is optimized over the measure $\rho _ { \pi _ { k } }$ , i.e., the state frequency induced by the current policy $\pi _ { k }$ .
+
+# 4 MIRROR DESCENT POLICY OPTIMIZATION
+
+In this section, we derive on-policy and off-policy RL algorithms based on the MD-style update rules (4) and (5). We refer to our algorithms as mirror descent policy optimization (MDPO). Since the trust-region optimization problems in the update rules (4) and (5) cannot be solved in closed-form, we approximate these updates with multiple steps of stochastic gradient descent (SGD) on the objective functions of these optimization problems. In our on-policy MDPO algorithm, described in Section 4.1, we use the update rule (5) and compute the SGD updates using the Monte-Carlo (MC) estimate of the advantage function $A ^ { \pi _ { k } }$ gathered by following the current policy $\pi _ { k }$ . On the other hand, our off-policy MDPO algorithm, described in Section 4.2, is based on the update rule (4) and calculates the SGD update by estimating $A ^ { \pi _ { k } }$ using samples from a replay buffer.
+
+In our MDPO algorithms, we define the policy space, $\Pi$ , as a class of smoothly parameterized stochastic polices, i.e., $\Pi = \{ \pi ( \cdot | s ; \theta ) : s \in S , \bar { \theta } \in \Theta \}$ . We refer to $\theta$ as the policy parameter. We will use $\pi$ and $\theta$ to represent a policy, and $\Pi$ and $\Theta$ to represent the policy space, interchangeably.
+
+# 4.1 ON-POLICY MDPO
+
+In this section, we derive an on-policy RL algorithm based on the MD-based update rule (5), whose pseudo-code is shown in Algorithm 1 in Appendix A. We refer to this algorithm as on-policy MDPO. We may write the update rule (5) for the policy space $\Theta$ (defined above) as
+
+$$
+\theta _ { k + 1 }  \underset { \theta \in \Theta } { \operatorname { a r g m a x } } \Psi ( \theta , \theta _ { k } ) , \quad w h e r e \quad \Psi ( \theta , \theta _ { k } ) = \mathbb { E } _ { s \sim \rho _ { \theta _ { k } } } [ \mathbb { E } _ { a \sim \pi _ { \theta } } [ A ^ { \theta _ { k } } ( s , a ) ] - \frac { 1 } { t _ { k } } \mathrm { K L } ( s ; \pi _ { \theta } , \pi _ { \theta _ { k } } ) ] .
+$$
+
+Each policy update in (6) requires solving a constrained (over $\Theta$ ) optimization problem. In on-policy MDPO, instead of solving this problem, we update the policy by performing multiple SGD steps on the objective function $\Psi ( \theta , \theta _ { k } )$ . Interestingly, performing only a single SGD step on $\Psi ( \theta , \theta _ { k } )$ is not sufficient as $\nabla _ { \boldsymbol { \theta } } \mathrm { K L } ( \cdot ; \pi _ { \boldsymbol { \theta } } , \pi _ { \boldsymbol { \theta } _ { k } } ) | _ { \boldsymbol { \theta = \theta } _ { k } } = 0$ , and thus, if we perform a single-step SGD, i.e.,
+
+$$
+\nabla _ { \theta } \Psi ( \theta , \theta _ { k } ) | _ { \theta = \theta _ { k } } = \mathbb { E } _ { s \sim _ { \theta _ { k } } } \bigl [ \nabla \log \pi _ { \theta _ { k } } ( a | s ) A ^ { \theta _ { k } } ( s , a ) \bigr ] ,
+$$
+
+the resulting algorithm would be equivalent to vanilla policy gradient and misses the entire purpose of enforcing the trust-region constraint. As a result, the policy update at each iteration $k$ of on-policy MDPO involves $m$ SGD steps as
+
+$$
+\begin{array} { r } { \iota _ { k } ^ { ( 0 ) } = \theta _ { k } , \qquad \mathrm { f o r } \quad i = 0 , \dots , m - 1 , \qquad \theta _ { k } ^ { ( i + 1 ) } \gets \theta _ { k } ^ { ( i ) } + \eta \nabla _ { \theta } \Psi ( \theta , \theta _ { k } ) | _ { \theta = \theta _ { k } ^ { ( i ) } } , \qquad \theta _ { k + 1 } = \theta _ { k } ^ { ( m ) } , } \end{array}
+$$
+
+where the gradient of the objective function
+
+$$
+\nabla _ { \theta } \Psi ( \theta , \theta _ { k } ) | _ { \theta = \theta _ { k } ^ { ( i ) } } = \mathbb { E } _ { s \sim \rho _ { \theta _ { k } } } \left[ \frac { \pi _ { \theta _ { k } } ^ { ( i ) } } { \pi _ { \theta _ { k } } } \nabla \log \pi _ { \theta _ { k } ^ { ( i ) } } ( a | s ) A ^ { \theta _ { k } } ( s , a ) \right] - \frac { 1 } { t _ { k } } \mathbb { E } _ { s \sim \rho _ { \theta _ { k } } } \left[ \nabla _ { \theta } \mathrm { K L } ( s ; \pi _ { \theta } , \pi _ { \theta _ { k } } ) | _ { \theta = \theta _ { k } ^ { ( i ) } } \right]
+$$
+
+can be estimated in an on-policy fashion using the data generated by the current policy $\pi _ { \theta _ { k } }$ . Since in practice, the policy space is often selected as Gaussian, we use the closed-form of KL in this estimation. Our on-policy MDPO algorithm (Algorithm 1, Appendix A) has close connections to two popular on-policy trust-region RL algorithms: TRPO [26] and PPO [28]. We now discuss the similarities and differences between on-policy MDPO and these algorithms.
+
+Comparison with TRPO. At each iteration $k$ , TRPO considers the constrained optimization problem
+
+$$
+\operatorname* { m a x } _ { \theta \in \Theta } \mathbb { E } _ { s \sim \rho _ { \theta _ { k } } } \Big [ \frac { \pi _ { \theta } ( a | s ) } { \pi _ { \theta _ { k } } ( a | s ) } A ^ { \theta _ { k } } ( s , a ) \Big ] , \quad \mathrm { s . t . } \qquad \mathbb { E } _ { s \sim \rho _ { \theta _ { k } } } \big [ \mathrm { K L } ( s ; \pi _ { \theta _ { k } } , \pi _ { \theta } ) \big ] \leq \delta ,
+$$
+
+and updates its policy parameter by taking a step in the direction of the natural gradient of the objective function in (8) as $\begin{array} { r l } & { \dot { \theta _ { k + 1 } }  \theta _ { k } ^ { - } + \eta { F ^ { - } } ^ { 1 } \mathbb { E } _ { s \sim \rho _ { \theta _ { k } } } [ \nabla \log \pi _ { \theta _ { k } } ( a | s ) A ^ { \theta _ { k } } ( s , a ) ] } \\ & { \quad \quad - } \end{array}$ , where $F =$ $\begin{array} { r l } { \underbrace { \mathbb { E } _ { s \sim \rho _ { \theta _ { k } } } } _ { a \sim \pi _ { \theta _ { k } } } \left[ \nabla \log \pi _ { \theta _ { k } } ( a | s ) \nabla \log \pi _ { \theta _ { k } } ( a | s ) ^ { \top } \right] } & { } \end{array}$ is the Fisher information matrix for the current policy $\pi _ { \boldsymbol { \theta } _ { k } }$ . It then explicitly enforces the trust-region constraint in (8) by a line-search: computing the KL-term for $\theta = \theta _ { k + 1 }$ and checking if it is larger than the threshold $\delta$ , in which case, the step size is reduced until the constraint is satisfied.
+
+In comparison to TRPO, first, on-policy MDPO does not explicitly enforce the trust-region constraint, but approximately satisfies it by performing multiple steps of SGD on the objective function of the optimization problem in the MD-style update rule (6). We say $^ { * * } i t$ approximately satisfies the constraint” because instead of fully solving (6), it takes multiple steps in the direction of the gradient of its objective function. Second, on-policy MDPO uses simple SGD instead of natural gradient, and thus, does not have to deal with the computational overhead of computing (or approximating) the inverse of the Fisher information matrix.1 Third, the direction of KL in on-policy MDPO, $\operatorname { K L } ( \pi , \pi _ { k } )$ , is consistent with that in the MD update rule in convex optimization and is different than that in TRPO, $\mathrm { K L } ( \pi _ { k } , \pi )$ . This does not cause any sampling problem for either algorithm, as both calculate the KL-term in closed-form (Gaussian policies). Fourth, while TRPO uses heuristics to define the step-size and to reduce it in case the trust-region constraint is violated, on-policy MDPO uses a simple schedule, motivated by the theory of MD [4], and sets $t _ { k } = 1 { - } k / K$ , where $K$ is the maximum number of iterations. This way it anneals the step-size $t _ { k }$ from 1 to 0 over the iterations of the algorithm.
+
+Comparison with PPO. At each iteration $k$ , PPO performs multiple steps of SGD on the objective function of the following unconstrained optimization problem:
+
+$$
+\operatorname* { m a x } _ { \theta \in \Theta } \mathbb { E } _ { a \sim \pi _ { \theta _ { k } } } \Big [ \operatorname* { m i n } \Big \{ \frac { \pi _ { \theta } ( a \vert s ) } { \pi _ { \theta _ { k } } ( a \vert s ) } A ^ { \theta _ { k } } ( s , a ) , \mathrm { c l i p } ( \frac { \pi _ { \theta } ( a \vert s ) } { \pi _ { \theta _ { k } } ( a \vert s ) } , 1 - \epsilon , 1 + \epsilon ) A ^ { \theta _ { k } } ( s , a ) \Big \} \Big ] ,
+$$
+
+in which the hyper-parameter $\epsilon$ determines how the policy ratio, $\pi _ { \boldsymbol { \theta } } / \pi _ { \boldsymbol { \theta } _ { k } }$ , is clipped. It is easy to see that the gradient of the objective function in (9) is zero for the state-action pairs at which the policy ratio is clipped and is non-zero, otherwise. However, since the gradient is averaged over all the state-action pairs in the batch, the policy is updated even if its ratio is out of bound for some state-action pairs. This phenomenon, which has been reported in [31] and [9], shows that clipping in PPO does not prevent the policy ratios to go out of bound, but it only reduces its probability. This means that despite using clipping, PPO does not guarantee that the trust-region constraint is always satisfied. In fact, recent results, including those in [9] and our experiments in Section 5.3, show that most of the improved performance exhibited by PPO is due to code-level optimization techniques, such as learning rate annealing, observation and reward normalization, and in particular, the use of generalized advantage estimation (GAE) [27]. Although both on-policy MDPO and PPO take multiple SGD steps on the objective function of unconstrained optimization problems (6) and (9), respectively, the way they handle the trust-region constraint is completely different.
+
+Another interesting observation is that the adaptive and fixed KL algorithms (we refer to as KL-PPO here), proposed in the PPO paper [28], have policy update rules similar to on-policy MDPO. However, these algorithms have not been used much in practice, because it was shown in the same paper that they perform much worse than PPO. Despite the similarities, there are three main differences between the update rules of KL-PPO and on-policy MDPO. First, KL-PPO uses mini-batches whereas MDPO uses the entire data for their multiple $( m )$ gradient updates at each round. Second, the scheduling scheme used for the $t _ { k }$ parameter is quite different in KL-PPO and MDPO. In particular, KL-PPO either uses a fixed $t _ { k }$ or defines an adaptive scheme that updates (increase/decrease) $t _ { k }$ based on the KL divergence magnitude at that time step. On the other hand, on-policy MDPO uses an annealed schedule to update $t _ { k }$ , starting from 1 and slowly bringing it down to near 0. Third, similar to TRPO, the direction of KL in KL-PPO, $\mathrm { K L } ( \pi _ { k } , \pi )$ , is different than that in on-policy MDPO, $\operatorname { K L } ( \pi , \pi _ { k } )$ Since in our experiments, on-policy MDPO performs significantly better than PPO (see Section 5.3), we conjecture that either any or a combination of the above differences, especially the first two, is the reason for the inferior performance of KL-PPO, compared to PPO, as reported in [28].
+
+# 4.2 OFF-POLICY MDPO
+
+In this section, we derive an off-policy RL algorithm based on the MD update rule (4). We refer to this as off-policy MDPO and provide the pseudo-code in Algorithm 2 in Appendix A. To emulate the uniform sampling over the state space required by (4), Algorithm 2 samples a batch of states from a replay buffer $\mathcal { D }$ (Line 4). While this sampling scheme is not truly uniform, it makes the update less dependent on the current policy. Similar to the on-policy case, we write the update rule (4) for the policy class $\Theta$ as
+
+$$
+\theta _ { k + 1 }  \underset { \theta \in \Theta } { \mathrm { a r g } \mathrm { m a x } } \Psi ( \theta , \theta _ { k } ) , \quad \quad w h e r e \quad \Psi ( \theta , \theta _ { k } ) = \mathbb { E } _ { s \sim \mathcal { D } } \Big [ \mathbb { E } _ { a \sim \pi _ { \theta } } \big [ A ^ { \theta _ { k } } ( s , a ) \big ] - \frac { 1 } { t _ { k } } \mathbf { K L } ( s ; \pi _ { \theta } , \pi _ { \theta _ { k } } ) \Big ] .
+$$
+
+The main idea in Algorithm 2 is to estimate the advantage or action-value function of the current policy, $A ^ { \theta _ { k } }$ or $Q ^ { \theta _ { k } }$ , in an off-policy fashion, using a batch of data randomly sampled from the replay buffer $\mathcal { D }$ . In a similar manner to the policy update of our on-policy MDPO algorithm (Algorithm 1), described in Section 4.1, we then update the policy by taking multiple SGD steps on the objective function $\Psi ( \theta , \theta _ { k } )$ of the optimization problem (10) (by keeping $\theta _ { k }$ fixed). A more presentable form of the policy loss in $\Psi$ can be written as follows:
+
+$$
+L ( \theta , \theta _ { k } ) = \mathbb { E } _ { s \sim \mathcal { D } } \big [ \log \pi _ { \theta } \big ( \widetilde { a } _ { \theta } ( \epsilon , s ) | s \big ) - \log \pi _ { \theta _ { k } } \big ( \widetilde { a } _ { \theta } ( \epsilon , s ) | s \big ) - t _ { k } Q _ { \psi } ^ { \theta _ { k } } \big ( s , \widetilde { a } _ { \theta } ( \epsilon , s ) \big ) \big ] ,
+$$
+
+In particular, the first two terms here are obtained just by opening the KL, whereas the advantage estimate is replaced by a neural network estimate $Q _ { \psi }$ , which is learned from off-policy data in a $\mathrm { T D } ( 0 )$ fashion. Furthermore, solely as an implementation detail, another neural network $V _ { \phi }$ is used in conjunction with $Q _ { \psi }$ , which is fit to the $Q _ { \psi }$ estimate of the current policy. Finally, the policy loss also uses the reparameterization trick where $\tilde { \boldsymbol { a } } _ { \boldsymbol { \theta } } ( \epsilon , s )$ is the action generated by sampling the $\epsilon$ noise from a zero-mean normal distribution $\mathcal { N }$ .
+
+We can easily modify Algorithm 2 to optimize soft (entropy regularized) MDPs. In this case, in the critic update (Line 12 of Algorithm 2), the $Q _ { \psi }$ update remains unchanged, while in the $V _ { \phi }$ update, the target changes from $\mathbb { E } _ { a \sim \pi _ { \theta _ { k + 1 } } } \left[ Q _ { \psi } ( \cdot , a ) \right]$ to $\bar { \mathbb { E } } _ { a \sim \pi _ { \theta _ { k + 1 } } } [ Q _ { \psi } ( \cdot , a ) - \lambda \log \pi ( a | \cdot ) ]$ . The loss function (11) used for the actor (policy) update (Lines 7-9 of Algorithm 2) is also modified, $Q _ { \psi }$ becomes the soft $Q$ -function and a term $\lambda t _ { k } \log \pi _ { \theta _ { k } } ( \widetilde { a } _ { \theta } ( \epsilon , s ) | s )$ is added inside the expectation. We denote these changes explicitly in Algorithm 3.
+
+Similarly to on-policy MDPO that has close connection to TRPO and PPO, discussed in Section 4.1, off-policy MDPO (Algorithm 2 and 3) is related to the popular soft actor-critic (SAC) algorithm [13]. We now derive SAC by slight modifications in the derivation of off-policy MDPO. This gives an optimization interpretation to SAC, which we then use to show strong ties between the two algorithms.
+
+Comparison with SAC. Soft actor-critic is an approximate policy iteration algorithm in soft MDPs. At each iteration $k$ , it first estimates the (soft) $Q$ -function of the current policy, $Q ^ { \pi _ { k } }$ , and then sets the next policy to the (soft) greedy policy w.r.t. the estimated $Q$ -function as
+
+$$
+\pi _ { k + 1 } ( a | s ) \gets \exp \left( Q ^ { \pi _ { k } } ( s , a ) \right) / \ : Z ^ { \mathrm { S A C } } ( s ) ,
+$$
+
+where $Z ^ { \mathrm { S A C } } ( s ) \ = \ \mathbb { E } _ { a \sim \pi _ { k } ( \cdot | s ) } \big [ \exp \big ( Q ^ { \pi _ { k } } ( s , a ) \big ) \big ]$ is a normalization term. However, since tractable policies are preferred in practice, SAC suggests to project the improved policy back into the policy space considered by the algorithm, using the following optimization problem:
+
+$$
+\theta _ { k + 1 } \gets \operatorname * { a r g m i n } _ { \theta \in \Theta } \mathcal { L } ^ { \mathrm { S A C } } ( \theta , \theta _ { k } ) , \qquad \mathcal { L } ^ { \mathrm { S A C } } ( \theta , \theta _ { k } ) = \mathbb { E } _ { s \sim \mathcal { D } } \Big [ \mathbf { K } \mathbf { L } \big ( s ; \pi _ { \theta } , \frac { \exp \big ( Q ^ { \theta _ { k } } ( s , \cdot ) \big ) } { Z ^ { \mathrm { S A C } } ( s ) } \big ) \Big ] .
+$$
+
+This update rule computes the next policy as the one with the minimum KL-divergence to the term on the RHS of (12)
+
+Since the optimization problem in (13) is invariant to the normalization term, unlike (12), the policy update (13) does not need to compute $Z ^ { \mathrm { S A C } } ( s )$ . By writing the KL definition and using the reparameterization trick in (13), SAC updates its policy by minimizing the following loss function:
+
+$$
+L ^ { \mathrm { S A C } } ( \theta , \theta _ { k } ) = \mathbb { E } _ { \underset { \epsilon \sim \mathcal { N } } { s \sim \mathcal { D } } } \big [ \lambda \log \pi _ { \theta } \big ( \widetilde { a } _ { \theta } ( \epsilon , s ) | s \big ) - Q _ { \psi } ^ { \theta _ { k } } \big ( s , \widetilde { a } _ { \theta } ( \epsilon , s ) \big ) \big ] .
+$$
+
+Comparing the loss in (14) with the one used in off-policy MDPO (Eq. 11), we notice that despite the similarities, the main difference is the absence of the current policy, $\pi _ { \theta _ { k } }$ , in the SAC loss function. To explain the relationship between off-policy MDPO and SAC, recall from Section 2.1 that if the constraint set is the unit simplex, i.e., $C = \Delta _ { \mathcal { X } }$ , the MD update has the closed-form shown in (2). Thus, if the policy class (constraint set) $\Pi$ in the update rule (4) is the entire space of stochastic policies, then we may write (4) in closed-form as (see e.g., [21, 29])
+
+$$
+\pi _ { k + 1 } ( a | s ) \gets \pi _ { k } ( a | s ) \exp \left( t _ { k } Q ^ { \pi _ { k } } ( s , a ) \right) / Z ( s ) ,
+$$
+
+where $Z ( s ) = \mathbb { E } _ { a \sim \pi _ { k } ( \cdot \vert s ) } \left[ \exp \left( t _ { k } Q ^ { \pi _ { k } } ( s , a ) \right) \right]$ is a normalization term. The closed-form solution (15) is equivalent to solving the constrained optimization problem (4) in two phases (see [14]): 1) solving the unconstrained version of (4) that leads to the numerator of (15), followed by 2) projecting this (unconstrained) solution back into the constrained set (all stochastic policies) using the same choice of Bregman divergence (KL in our case), which accounts for the normalization term in (15). Hence, when we optimize over the parameterized policy space $\Theta$ (instead of all stochastic policies), the MD update would be equivalent to finding a policy $\theta \in \Theta$ with minimum KL-divergence to the solution of the unconstrained optimization problem obtained in the first phase (the numerator of Eq. 15). This leads to the following policy update rule:
+
+$$
+\theta _ { k + 1 }  \underset { \theta \in \Theta } { \mathrm { a r g } \mathrm { m i n } } \ \mathcal { L } ( \theta , \theta _ { k } ) , \qquad \mathcal { L } ( \theta , \theta _ { k } ) = \mathbb { E } _ { s \sim \mathcal { D } } \Big [ \mathrm { K L } \big ( s ; \pi _ { \theta } , \pi _ { \theta _ { k } } \exp ( t _ { k } Q ^ { \theta _ { k } } ) \big ) \Big ] .
+$$
+
+If we write the definition of KL and use the reparameterization trick in (16), we will rederive the loss function (11) used by our off-policy MDPO algorithm.2 Note that both SAC (13) and off-policy MDPO (16) use KL projection to project back to the set of policies. For SAC, the authors argue that any projection can be chosen arbitrarily. However, our derivation clearly shows that the selection of KL projection is dictated by the choice of the Bregman divergence.
+
+As mentioned earlier, the main difference between the loss functions used in the policy updates of SAC (14) and off-policy MDPO (11) is the absence of the current policy, $\pi _ { \boldsymbol { \theta } _ { k } }$ , in the SAC’s loss function.3 The current policy, $\pi _ { \theta _ { k } }$ , appears in the policy update of off-policy MDPO, because it is a trust-region algorithm, and thus, tries to keep the new policy close to the old one. On the other hand, following the original interpretation of SAC as an approximate dynamic programming algorithm, its policy update does not contain a term to keep the new and old policies close to each other. It is interesting to note that SAC’s loss function can be re-obtained by repeating the derivation which leads to off-policy MDPO, and replacing the current policy, $\pi _ { \boldsymbol { \theta } _ { k } }$ , with the uniform policy in the objective (10) of off-policy MDPO. Therefore, SAC can be considered as a trust-region algorithm w.r.t. the uniform policy (or an entropy regularized algorithm). This means its update encourages the new policy to remain explorative, by keeping it close to the uniform policy.
+
+Trust-PCL [22] uses the path consistency idea along with entropy regularization and an additional term for remaining close to a past policy. In principle, this resembles the off-policy MDPO algorithm. However, Trust-PCL uses a multi-step consistency loss whereas off-policy MDPO uses single transitions. Moreover, besides different derivations, there remain implementation-level details between the two, as Trust-PCL only uses a $V$ network while off-policy MDPO uses a $Q$ function as well.
+
+Due to space constraints, we defer a discussion on the forward and reverse KL directions (including the ECPO [21] algorithm) to Appendix D.
+
+# 5 EXPERIMENTAL RESULTS
+
+In this section, we empirically evaluate our on-policy and off-policy MDPO algorithms on a number of continuous control tasks from OpenAI Gym [7], and compare them with state-of-the-art baselines: TRPO, PPO, and SAC. We report all experimental details, including the hyper-parameter values used by the algorithms, in Appendix B. In the tabular results, both in the main paper and in Appendices E and F, we report the final training scores averaged over 5 runs and their $9 5 \%$ confidence intervals (CI). We bold-face the values with the best mean scores. We also compare on-policy MDPO and PPO on 21 Atari games from the ALE benchmark [5], showing averages over 5 random seeds. We strictly follow the hyperparameters reported in the PPO paper, and use $m = 3$ for all games.
+
+For off-policy MDPO, we experiment with two potential functions $\psi$ to define the Bregman divergence $B _ { \psi }$ : 1) Shannon entropy, which results in the KL version (described in Section 4.2), and 2) Tsallis entropy, which results in the Tsallis version of off-policy MDPO. We refer the reader to Appendix C for the complete description and detailed derivation of the Tsallis version. Note that we did not pursue a similar bifurcation between Tsallis and KL induced Bregman divergences for the on-policy case since the exact derivations are more tedious there. Another important point to note is that the Tsallis entropy gives us a range of entropies, controlled by the parameter $q \in ( 0 , 2 ]$ (see Appendix C). Two special cases are 1) Shannon entropy for $q = 1 . 0$ , and 2) sparse Tsallis for $q = 2 . 0$ [17, 18, 24].
+
+![](images/904aac49e8caa81cf6f48a2078fc183db5645f8aa4c58189968266b6e57e75ff.jpg)  
+Figure 2: Performance of on-policy (top) and off-policy (bottom) MDPO (code level optimizations included) for different values of $m$ on the Walker2d task.
+
+Table 1: Comparisons on MuJoCo domains. Averaged (over 5 runs) returns for Loaded $\mathbf { + G A E }$ version of MDPO, TRPO, PPO, and SAC algorithms, together with their $9 5 \%$ confidence intervals. On-policy results are for 10M timesteps. The values with the best mean scores are bold-faced.   
+
+<table><tr><td colspan="5">On-Policy</td><td colspan="2">Off-Policy</td></tr><tr><td>Env</td><td>MDPO</td><td>TRPO</td><td>PPO</td><td>MDPO-KL</td><td>MDPO-Tsallis</td><td>SAC</td></tr><tr><td>Hopper-v2</td><td>2361(±518)</td><td>1979 (± 672)</td><td>2051 (± 241)</td><td>2428(±395)</td><td>2428(± 395),q = 1.0</td><td>1870 (± 404)</td></tr><tr><td>Walker2d-v2</td><td>4834 (± 607)</td><td>4473 (± 558)</td><td>1490 (± 292)</td><td>3591 (± 366)</td><td>4028(± 287),q = 2.0</td><td>3738 (± 312)</td></tr><tr><td>HalfCheetah-v2</td><td>4172 (± 1156)</td><td>3751 (± 910)</td><td>2041 (± 1319)</td><td>11823 (± 154)</td><td>11823 (± 154), q = 1.0</td><td>11928 (± 342)</td></tr><tr><td>Ant-v2</td><td>5211 (± 43)</td><td>4682 (± 278)</td><td>59 (±133)</td><td>4434 (± 749)</td><td>5486(± 737), q = 2.0</td><td>4989 (± 579)</td></tr><tr><td>Humanoid-v2</td><td>3234 (± 566)</td><td>4414 (± 132)</td><td>529 (±47)</td><td>5323 (± 348)</td><td>5611(± 260), q = 1.2</td><td>5191 (± 312)</td></tr><tr><td>H. Standup-v2</td><td>155261(± 3898)</td><td>149847 (± 2632)</td><td>97223 (±4479)</td><td>143955 (± 4499)</td><td>165882 (± 16604), q = 1.4 154765 (± 11721)</td><td></td></tr></table>
+
+# 5.1 ON MULTIPLE SGD STEPS
+
+In on-policy MDPO, we implement the multi-step update at each MD iteration of the algorithm, by sampling $M$ trajectories from the current policy, generating estimates of the advantage function, and performing $m$ gradient steps using the same set of trajectories. We evaluated on-policy MDPO for different values of $m$ in all tasks. We show the results for Walker2d in Figure 2 (top). The results for all tasks show a clear trade-off between $m$ and the performance. Moreover, $m = 1 0$ seems to be the best value across the tasks. This is why we use $m = 1 0$ in all our on-policy MDPO experiments. Our results clearly indicate that using $m = 1$ leads to inferior performance as compared to $m = 1 0$ , reaffirming the theory that suggests solving the trust-region problem in RL requires taking several gradient steps at each MD iteration. Finally, in our preliminary experiments with TRPO, we observed that performing multiple gradient steps at each iteration of TRPO does not lead to any improvement, sometimes even leading to worse performance than when performing a single-step update.
+
+For off-policy MDPO, performing multiple SGD steps at each MD iteration (Lines 6 to 10 in Algorithm 2) becomes increasingly time-consuming as the value of $m$ grows. This is because offpolicy algorithms perform substantially more gradient updates than their on-policy counterparts (a gradient step per environment step vs. a gradient step per almost 1, 000 environment steps). To address this issue, we resort to staying close to an $m$ -step old copy of the current policy, while performing a single gradient update at each iteration of the algorithm. This copy is updated every $m$ iterations with the parameters of the current policy. Our results for the Hopper domain in Appendix G.1 show that the performance of MDPO can be improved by performing $m$ gradient updates at each iteration, but we omit from performing these experiments at scale because of their unreasonably high wall-clock time. Finally, we evaluated off-policy MDPO for different values of $m$ in all tasks and show the results for Walker2d in Figure 2 (bottom). We found it hard to identify a single best value of $m$ for all tasks. However, $m = 1 0 0 0$ had the most reasonable performance across the tasks, and thus, we use it in all our off-policy MDPO experiments.
+
+# 5.2 ON CODE-LEVEL OPTIMIZATIONS
+
+There are certain “code-level optimization techniques" used in code-bases of TRPO, PPO, and SAC that result in enhanced performance. In [9], the authors provided a case study of these techniques in TRPO and PPO. We provide a detailed description of these techniques in Appendix B, and report the performance of the algorithms without these techniques (vanilla or minimal version) and with these techniques (loaded and loaded+GAE versions) in Appendices E and F. Note that the loaded+GAE version of TRPO and PPO match their state-of-the-art results in the literature.
+
+Overall, the key takeaway from our results is that MDPO performs significantly better than PPO and on-par or better than TRPO and SAC, while being much simpler to implement, and more general as being derived from the theory of MD in RL. In the next two sections, we report our main observations from our on-policy and off-policy experiments.
+
+# 5.3 ON-POLICY RESULTS
+
+We implemented three versions of on-policy MDPO, TRPO, and PPO: 1) the vanilla or minimal version, 2) the loaded version in which we add the code-level optimization techniques to these algorithms, and 3) the loaded version plus GAE, whose results are reported in Table 1. The results for all three versions are reported in Appendix E.
+
+We elicit the following observations from our results. First, on-policy MDPO performs better than or on par with TRPO and better than PPO across all tasks. This contradicts the common belief that explicitly enforcing the constraint (e.g., through line-search) as done in TRPO is necessary for achieving good performance. Second, on-policy MDPO can be implemented more efficiently than TRPO, because it does not require the extra line-search step. Notably, TRPO suffers from scaling issues as it requires computing the correct step-size of the gradient update using a line search, which presents as an incompatible part of the computation graph in popular auto-diff packages, such as TensorFlow. Moreover, MDPO performs significantly better than PPO, while remaining equally efficient in terms of implementation. Third, TRPO performs better than PPO consistently, both in the vanilla case and when the code-level optimizations (including GAE) are added to both algorithms. This is in contrast to the common belief that PPO is a better performing algorithm than TRPO. Our observation is in line with what noted in the empirical study of these two algorithms in [9], and we believe it further reinforces it. Adding code-level optimizations and GAE improve the performance of PPO, but not enough to outperform TRPO, when it also benefits from these additions. Lastly, fourth, it was shown in [31] that PPO is prone to instability issues. Our experiments show that this is indeed the case as PPO’s performance improves until the standard time-step mark of 1M, and then decreases in some tasks. For example, in the Ant-v2 domain, both PPO and TRPO get to a similar score ( 1000) around the 1M mark but then PPO’s performance decreases whereas TRPO continues to increase, as can be seen in Table 1 and Appendix E.
+
+Atari results. To show that MDPO can be robustly used as an excellent substitute for PPO, we compare the two algorithms on 21 games from the ALE benchmark. Our results show that MDPO performs better or on par than PPO on 15 out of 21 games, while performing better than PPO on 6 out of 21 games. Due to space constraints, we report the full training plots in Appendix 10. Interestingly, both MDPO and PPO behave quite differently in a lot of games. Since we do not optimize any hyperparameters for MDPO, it might be possible to get more gains with further finetuning. Note that it is well known that TRPO leads to much inferior performance than PPO on the ALE benchmark. Indeed, comparing our results with those in the TRPO paper, we see that both MDPO and PPO win in 5 out of the 6 games reported in the TRPO paper.
+
+# 5.4 OFF-POLICY RESULTS
+
+Similar to the on-policy case, we implemented both vanilla and loaded versions of off-policy MDPO and SAC. We report the results of the loaded version in this section (Table 1), and the complete results in Appendix F. We observe the following from these results. First, off-policy MDPO-KL performs on par with SAC across all tasks. Second, off-policy MDPO-Tsallis that has an extra hyper-parameter $q$ to tune can outperform SAC across all tasks. We observe that the best performing values of $q$ are different for each domain but always lie in the interval [1.0, 2.0]. Third, off-policy MDPO results in a performance increase in most tasks, both in terms of sample efficiency and final performance, in comparison to on-policy MDPO. This is consistent with the common belief about the superiority of off-policy to on-policy algorithms.
+
+Similar to off-policy MDPO, we can incorporate the Tsallis entropy in SAC. In [18], the authors showed performance improvement over SAC by properly tuning the value of $q$ in SAC-Tsallis. However, in domains like Humanoid-v2 and Ant-v2, they only reported results for the 1M time-step mark, instead of the standard 3M. In our preliminary experiments with SAC-Tsallis in Appendix G.3, we did not see much improvement over SAC by tuning $q$ , unlike what we observed in our MDPOTsallis results. More experiments and further investigation are hence needed to better understand the effect of Tsallis entropy (and $q$ ) in these algorithms.
+
+# 6 CONCLUSIONS
+
+We derived on-policy and off-policy algorithms from the theory of MD in RL. Each policy update in our MDPO algorithms is formulated as a trust-region optimization problem. However, our algorithms do not update their policies by solving these problems, instead, update them by taking multiple gradient steps on the objective function of these problems. We described in detail the relationship between on-policy MDPO and TRPO and PPO. We also discussed how SAC can be derived by slight modifications of off-policy MDPO. Finally, using a comprehensive set of experiments, we showed that on-policy and off-policy MDPO can achieve performance better than or equal to these three popular RL algorithms, and thus can be considered as excellent alternatives to them.
+
+We can think of several future directions. In addition to evaluating MDPO algorithms in more complex and realistic problems, we would like to see their performance in discrete action problems in comparison with algorithms like DQN and PPO. Investigating the use of Bregman divergences other than KL seems to be promising. Our work with Tsallis entropy is in this direction but more algorithmic and empirical work needs to be done. Finally, there are recent theoretical results on incorporating exploration into the MD-based updates. Applying exploration to MDPO could prove most beneficial, especially in complex environments.
+
+# REFERENCES
+
+[1] Alekh Agarwal, Sham M Kakade, Jason D Lee, and Gaurav Mahajan. On the theory of policy gradient methods: Optimality, approximation, and distribution shift. Journal of Machine Learning Research, 22(98):1–76, 2021.   
+[2] M. Azar, V. Gómez, and H. Kappen. Dynamic policy programming. Journal of Machine Learning Research, 13:3207–3245, 2012.   
+[3] A. Beck. First-order methods in optimization. SIAM, 25, 2017.   
+[4] A. Beck and M. Teboulle. Mirror descent and nonlinear projected subgradient methods for convex optimization. Operations Research Letters, 31(3):167–175, 2003.   
+[5] Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, 2013.   
+[6] C. Blair. Problem complexity and method efficiency in optimization (A. Nemirovsky and D. Yudin). SIAM Review, 27(2):264, 1985.   
+[7] G. Brockman, V. Cheung, L. Pettersson, J. Schneider, J. Schulman, J. Tang, and W. Zaremba. OpenAI Gym. Preprint arXiv:1606.01540, 2016.   
+[8] P. Dhariwal, C. Hesse, O. Klimov, A. Nichol, M. Plappert, A. Radford, J. Schulman, S. Sidor, Y. Wu, and P. Zhokhov. OpenAI baselines, 2017.   
+[9] L. Engstrom, A. Ilyas, S. Santurkar, D. Tsipras, F. Janoos, L. Rudolph, and A. Madry. Implementation matters in deep RL: A case study on PPO and TRPO. In Proceeding of the 8th International Conference on Learning Representations, 2020.   
+[10] R. Fox, A. Pakman, and N. Tishby. Taming the noise in reinforcement learning via soft updates. In Proceedings of the Thirty-Second Conference on Uncertainty in Artificial Intelligence, pp. 202–211, 2016.   
+[11] S. Fujimoto, H. Hoof, and D. Meger. Addressing function approximation error in actor-critic methods. In International Conference on Machine Learning, pp. 1587–1596, 2018.   
+[12] M. Geist, B. Scherrer, and O. Pietquin. A theory of regularized Markov decision processes. In Proceedings of the 36th International Conference on Machine Learning, 2019.   
+[13] T. Haarnoja, A. Zhou, P. Abbeel, and S. Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In Proceedings of the 35th International Conference on Machine Learning, pp. 1861–1870, 2018.   
+[14] E. Hazan. Introduction to online convex optimization. arXiv preprint arXiv:1909.05207, 2019.   
+[15] S. Kakade and J. Langford. Approximately optimal approximate reinforcement learning. In Proceedings of the 19th International Conference on Machine Learning, pp. 267–274, 2002.   
+[16] H. Kappen. Path integrals and symmetry breaking for optimal control theory. Journal of Statistical Mechanics, 11, 2005.   
+[17] K. Lee, S. Choi, and S. Oh. Sparse Markov decision processes with causal sparse Tsallis entropy regularization for reinforcement learning. Robotics and Automation Letters, 2018.   
+[18] K. Lee, S. Kim, S. Lim, S. Choi, and S. Oh. Tsallis reinforcement learning: A unified framework for maximum entropy reinforcement learning. Preprint arXiv:1902.00137, 2019.   
+[19] T. Lillicrap, J. Hunt, A. Pritzel, N. Heess, T. Erez, Y. Tassa, D. Silver, and D. Wierstra. Continuous control with deep reinforcement learning. Preprint arXiv:1509.02971, 2015.   
+[20] B. Liu, Q. Cai, Z. Yang, and Z. Wang. Neural trust region/proximal policy optimization attains globally optimal policy. In Proceedings of Advances in Neural Information Processing Systems, 2019.   
+[21] J. Mei, C. Xiao, R. Huang, D. Schuurmans, and M. Muller. On principled entropy exploration in policy optimization. In Proceedings of the 28th Joint Conference on Artificial Intelligence, pp. 3130–3136, 2019.   
+[22] O. Nachum, M. Norouzi, K. Xu, and D. Schuurmans. Trust-PCL: An off-policy trust region method for continuous control. Preprint arXiv:1707.01891, 2017.   
+[23] O. Nachum, M. Norouzi, K. Xu, and D. Schuurmans. Bridging the gap between value and policy based reinforcement learning. In Proceedings of the 31st Conference on Neural Information Processing Systems, pp. 2772–2782, 2017.   
+[24] O. Nachum, Y. Chow, and M. Ghavamzadeh. Path consistency learning in Tsallis entropy regularized mdps. In Proceedings of the 35th International Conference on Machine Learning, pp. 979–988, 2018.   
+[25] G. Neu, A. Jonsson, and V. Gómez. A unified view of entropy-regularized markov decision processes. Preprint arXiv:1705.07798, 2017.   
+[26] J. Schulman, S. Levine, P. Abbeel, M. Jordan, and P. Moritz. Trust region policy optimization. In Proceedings of the 32nd International conference on machine learning, pp. 1889–1897, 2015.   
+[27] J. Schulman, P. Moritz, S. Levine, M. Jordan, and P. Abbeel. High-dimensional continuous control using generalized advantage estimation. Preprint arXiv:1506.02438, 2015.   
+[28] J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov. Proximal policy optimization algorithms. Preprint arXiv:1707.06347, 2017.   
+[29] L. Shani, Y. Efroni, and S. Mannor. Adaptive trust region policy optimization: Global convergence and faster rates for regularized MDPs. In Proceedings of the 33rd AAAI Conference on Artificial Intelligence, 2020.   
+[30] E. Todorov. Linearly-solvable Markov decision problems. In Proceedings of the 19th Advances in Neural Information Processing, pp. 1369–1376, 2006.   
+[31] Y. Wang, H. He, and X. Tan. Truly proximal policy optimization. In Proceeding of the 35th Conference on Uncertainty in Artificial Intelligence, 2019.
+
+# Appendix
+
+A PSEUDOCODES
+
+Below we provide the pseudocodes for the two MDPO algorithms, on-policy and off-policy.
+
+# Algorithm 1 On-Policy MDPO
+
+1: Initialize Value network $V _ { \phi }$ ; Policy networks $\pi _ { \mathrm { n e w } }$ and $\pi _ { \mathrm { o l d } }$ ;   
+2: for $k = 1 , \ldots , K$ do   
+3: # On-policy Data Generation   
+4: Simulate the current policy $\pi _ { \theta _ { k } }$ for $M$ steps;   
+5: for $t = 1 , \ldots , M$ do   
+6: Calculate return $\begin{array} { r } { R _ { t } = R ( s _ { t } , a _ { t } ) = \sum _ { j = t } ^ { M } \gamma ^ { j - t } r _ { j } } \end{array}$ ; Estimate advantage $A ( s _ { t } , a _ { t } ) = R ( s _ { t } , a _ { t } ) - V _ { \phi } ( s _ { t } )$ ;   
+7: end for   
+8: # Policy Improvement (Actor Update)   
+9: $\theta _ { k } ^ { ( 0 ) } = \theta _ { k }$ ;   
+10: 11: for 0 $\theta _ { k } ^ { ( i + 1 ) } \gets \theta _ { k } ^ { ( i ) } + \eta \nabla _ { \theta } \Psi ( \theta , \theta _ { k } ) | _ { \theta = \theta _ { k } ^ { ( i ) } } ;$ $i = 0 , \ldots , m - 1$ do (Eq. 7)   
+12: end for   
+13: $\bar { \theta } _ { k + 1 } = \theta _ { k } ^ { ( m ) }$ ;   
+14: # Policy Evaluation (Critic Update)   
+15: Update $\phi$ by minimizing the $N$ -minibatch $N \leq M )$ loss function $\begin{array} { r } { L _ { V _ { \phi } } = \frac { 1 } { N } \sum _ { t = 1 } ^ { N } \left[ V _ { \phi } ( s _ { t } ) - R _ { t } \right] ^ { 2 } , } \end{array}$ ;   
+16: end for
+
+# Algorithm 2 Off-Policy MDPO
+
+1: Initialize Replay buffer $\mathcal { D } = \emptyset$ ; Value networks $V _ { \phi }$ and $Q _ { \psi }$ ; Policy networks $\pi _ { \mathrm { n e w } }$ and $\pi _ { \mathrm { o l d } }$ ;   
+2: for $k = 1 , \ldots , K$ do   
+3: Take action $a _ { k } \sim \pi _ { \theta _ { k } } ( \cdot | s _ { k } )$ , observe $r _ { k }$ and $s _ { k + 1 }$ , and add $\left( { { s _ { k } } , { a _ { k } } , { r _ { k } } , { s _ { k + 1 } } } \right)$ to the replay buffer $\mathcal { D }$ ;   
+4: Sample a batch $\{ ( s _ { j } , a _ { j } , r _ { j } , s _ { j + 1 } ) \} _ { j = 1 } ^ { N }$ from $\mathcal { D }$ ;   
+5: # Policy Improvement (Actor Update)   
+6: $\theta _ { k } ^ { ( 0 ) } = \stackrel { \cdot } { \theta _ { k } }$ ;   
+7: for $i = 0 , \ldots , m - 1$ do   
+8: $\theta _ { k } ^ { ( i + 1 ) } \gets \theta _ { k } ^ { ( i ) } + \eta \nabla _ { \theta } L ( \theta , \theta _ { k } ) | _ { \theta = \theta _ { k } ^ { ( i ) } } ;$ (Eq. 11)   
+9: end for   
+10: θk+1 = θ(m)k ;   
+11: # Policy Evaluation (Critic Update)   
+12: Update $\phi$ and $\psi$ by minimizing the loss functions   
+$\begin{array} { r l } & { \dot { L _ { V _ { \phi } } } = \frac { 1 } { N } \sum _ { j = 1 } ^ { N } \dot { \left[ { V _ { \phi } } ( { s _ { j } } ) - \dot { Q _ { \psi } } \left( { s _ { j } } , { \pi _ { \theta _ { k + 1 } } } ( { s _ { j } } ) \right) \right] } ^ { 2 } ; } \\ & { L _ { Q _ { \psi } } = \frac { 1 } { N } \sum _ { j = 1 } ^ { N } { \left[ { r ( { s _ { j } } , { a _ { j } } ) + \gamma { V _ { \phi } } ( { s _ { j + 1 } } ) - Q _ { \psi } ( { s _ { j } } , { a _ { j } } ) } \right] } ^ { 2 } ; } \end{array}$   
+13: end for
+
+$$
+\boxed  ( \theta , \theta _ { k } ) = \mathbb { E } _ { s \sim \mathcal { D } } \left[ \log \pi _ { \theta } \left( \widetilde { a } _ { \theta } ( \epsilon , s ) | s \right) - \log \pi _ { \theta _ { k } } \left( \widetilde { a } _ { \theta } ( \epsilon , s ) | s \right) - t _ { k } Q _ { \psi } ^ { \theta _ { k } } \left( s , \widetilde { a } _ { \theta } ( \epsilon , s ) \right) \right] \quad \mathrm { ( E q . ~ \rho ~ ( \widetilde { a } _ { \theta } ( \epsilon , s ) | \epsilon ] ~ ) }
+$$
+
+# Algorithm 3 Off-Policy MDPO (Soft)
+
+1: Initialize Replay buffer $\mathcal { D } = \emptyset$ ; Value networks $V _ { \phi }$ and $Q _ { \psi }$ ; Policy networks $\pi _ { \mathrm { n e w } }$ and $\pi _ { \mathrm { o l d } }$ ;   
+2: for $k = 1 , \ldots , K$ do   
+3: Take action $a _ { k } \sim \pi _ { \theta _ { k } } ( \cdot | s _ { k } )$ , observe $r _ { k }$ and $s _ { k + 1 }$ , and add $\left( { { s _ { k } } , { a _ { k } } , { r _ { k } } , { s _ { k + 1 } } } \right)$ to the replay buffer $\mathcal { D }$ ;   
+4: Sample a batch $\{ ( s _ { j } , a _ { j } , r _ { j } , s _ { j + 1 } ) \} _ { j = 1 } ^ { N }$ from $\mathcal { D }$ ;   
+5: # Policy Improvement (Actor Update)   
+6: $\theta _ { k } ^ { ( 0 ) } = \theta _ { k }$ ;   
+7: 8: fo $i = 0 , \ldots , m - 1$   
+$\theta _ { k } ^ { ( i + 1 ) } \gets \theta _ { k } ^ { ( i ) } + \eta \nabla _ { \theta } L ( \theta , \theta _ { k } ) | _ { \theta = \theta _ { k } ^ { ( i ) } } ;$ (Eq. 11 soft)   
+9: end for   
+10: $\theta _ { k + 1 } = \theta _ { k } ^ { ( m ) }$ ;   
+11: # Policy Evaluation (Critic Update)   
+12: Update $\phi$ and $\psi$ by minimizing the loss functions   
+$\begin{array} { r l } & { \hat { L _ { V _ { \phi } } } = \frac { 1 } { N } \sum _ { j = 1 } ^ { N } \big [ V _ { \phi } ( s _ { j } ) - \bar { Q _ { \psi } } \big ( s _ { j } , \pi _ { \theta _ { k + 1 } } ( s _ { j } ) \big ) - \lambda \log \pi _ { \theta _ { k + 1 } } ( s _ { j } ) \big ] ^ { 2 } ; } \\ & { \hat { L _ { Q _ { \psi } } } = \frac { 1 } { N } \sum _ { j = 1 } ^ { N } \big [ r ( s _ { j } , a _ { j } ) + \gamma V _ { \phi } ( s _ { j + 1 } ) - Q _ { \psi } ( s _ { j } , a _ { j } ) \big ] ^ { 2 } ; } \end{array}$
+
+13: end for
+
+$$
+L ( \theta , \theta _ { k } ) = \mathbb { E } _ { s \sim \mathcal { D } } \big [ \log \pi _ { \theta } \big ( \widetilde { a } _ { \theta } ( \epsilon , s ) | s \big ) - ( 1 - \lambda t _ { k } ) \log \pi _ { \theta _ { k } } \big ( \widetilde { a } _ { \theta } ( \epsilon , s ) | s \big ) - t _ { k } Q _ { \psi } ^ { \theta _ { k } } \big ( s , \widetilde { a } _ { \theta } ( \epsilon , s ) \big ) \big ]
+$$
+
+# B EXPERIMENTAL DETAILS
+
+# B.1 SETUP
+
+We evaluate all algorithms on OpenAI Gym [7] based continuous control tasks, including Hopper-v2, Walker2d-v2, HalfCheetah-v2, Ant-v2, Humanoid-v2 and HumanoidStandup-v2. All experiments are run across 5 random seeds. Each plot shows the empirical mean of the random runs while the shaded region represents a $9 5 \%$ confidence interval (empirical mean $\pm 1 . 9 6 \times$ empirical standard deviation / $\sqrt { n = 5 }$ ). We report results in both figure and tabular forms. The tabular results denote the mean final training performance and the best values with overlapping confidence intervals are bolded.
+
+For all off-policy experiments, we use $\lambda = 0 . 2$ across all tasks, which is known to be the best performing value for all tasks according to [13] (In our experiments, a value of 0.2 worked equally well for Humanoid as the reported 0.05 in the SAC paper). We report all details of our off-policy experiments including hyperparameter values in Table 3. Moreover, since doing multiple gradient steps at each iteration becomes quite time consuming for the off-policy case, we get around this issue by fixing the old policy $( \pi _ { \theta _ { k } } )$ for $m$ number of gradient steps, in order to mimic the effect from taking multiple gradients steps at each iteration. This ensures that the total number of environment steps are always equal to the total number of gradients steps, irrespective of the value of $m$ . Finally, for all experiments, we use a fixed Bregman stepsize $( 1 / t _ { k } )$ as opposed to an annealed version like in the on-policy case.
+
+# B.2 CODE-LEVEL OPTIMIZATION TECHNIQUES
+
+The widely available OpenAI Baselines [8] based PPO implementation uses the following five major modifications to the original algorithm presented in [28] – value function clipping, reward normalization, observation normalization, orthogonal weight initialization and an annealed learning rate schedule for the Adam optimizer. These are referred to as code level optimization techniques (as mentioned in above sections) and are originally noted in [9]. Following the original notation, we refer to the vanilla or minimal version of PPO, i.e. without these modifications as PPO-M. Then, we consider two PPO versions which include all such code level optimizations, with the hyperparameters given in [28]. One of them does not use GAE while the other version includes GAE. Therefore they are referred to as PPO-LOADED and PPO-LOADED+GAE respectively. These versions, although being far from the theory, have been shown to be the best performing ones, and so form as a good baseline. We do a similar bifurcation for TRPO and on-policy MDPO. We report all details of our on-policy experiments including hyperparameter values in Table 2.
+
+Similarly, for the off-policy MDPO versions, we again restrain from using the optimization tricks mentioned above. However we do employ three techniques that are common in actor-critic based algorithms, namely: using separate $Q$ and $V$ functions as in [13], using two $Q$ functions to reduce overestimation bias and using soft target updates for the value function. Prior work [11, 19] has shown these techniques help improve stability.
+
+Similar to the on-policy experiments, we include a minimal and loaded version for the off-policy experiments as well, which are described in Appendix D. In particular, this branching is done based on the neural network and batch sizes used. Since the standard values in all on-policy algorithms is different from the standard values used by most off-policy approaches, we show results for both set of values. This elicits a better comparison between on-policy and off-policy methods.
+
+Table 2: Hyper-parameters of all on-policy methods.   
+
+<table><tr><td>Hyperparameter</td><td>TRPO-M</td><td>TRPO-LOADED</td><td>PPO-M</td><td>PPO-LOADED</td><td>MDPO-M</td><td>MDPO-LOADED</td></tr><tr><td>Adam stepsize</td><td>=</td><td></td><td>3×10-4</td><td>Annealed from 1 to 0</td><td>3×10-4</td><td>Annealed from 1 to 0</td></tr><tr><td>minibatch size</td><td>128</td><td>128</td><td>64</td><td>64</td><td>128</td><td>128</td></tr><tr><td>number of gradient updates (m)</td><td>-</td><td></td><td>1</td><td></td><td>5</td><td>10</td></tr><tr><td>reward normalization</td><td>×</td><td></td><td>X</td><td></td><td>X</td><td>√</td></tr><tr><td>observation normalization</td><td>X</td><td></td><td>×</td><td></td><td>X</td><td>√</td></tr><tr><td>orthogonal weight initialization</td><td>X</td><td></td><td>×</td><td></td><td>×</td><td>√</td></tr><tr><td>value function clipping GAE入</td><td>X</td><td></td><td>X</td><td></td><td>X</td><td></td></tr><tr><td>horizon (T)</td><td>1.0</td><td>0.95</td><td>1.0</td><td>0.95 2048</td><td>1.0</td><td>0.95</td></tr><tr><td>entropy coefficient</td><td colspan="6"></td></tr><tr><td>discount factor</td><td colspan="6">0.0 0.99</td></tr><tr><td></td><td colspan="6">107</td></tr><tr><td>total number of timesteps</td><td colspan="6"></td></tr><tr><td>#runs used for plot averages</td><td colspan="6">5</td></tr><tr><td>confidence interval for plot runs</td><td colspan="6">~95%</td></tr></table>
+
+Table 3: Hyper-parameters of all off-policy methods.   
+
+<table><tr><td>Hyperparameter</td><td>MDPO-M KL</td><td>MDPO-M Tsallis</td><td>SAC-M</td><td>MDPO-LOADED KL</td><td>MDPO-LOADED Tsallis</td><td>SAC-LOADED</td></tr><tr><td>number of hidden units per layer minibatch size</td><td>64</td><td>64</td><td>64</td><td>256</td><td>256</td><td>256</td></tr><tr><td>entropy coefficient (λ)</td><td>64</td><td>64</td><td>64</td><td>256 0.2</td><td>256</td><td>256</td></tr><tr><td>Adam stepsize</td><td></td><td></td><td></td><td>3×10-4</td><td></td><td></td></tr><tr><td>reward normalization</td><td></td><td></td><td></td><td>×</td><td></td><td></td></tr><tr><td>observation normalization</td><td></td><td></td><td></td><td>×</td><td></td><td></td></tr><tr><td>orthogonal weight initialization</td><td></td><td></td><td></td><td>X</td><td></td><td></td></tr><tr><td>value function clipping</td><td></td><td></td><td></td><td>X</td><td></td><td></td></tr><tr><td>replay buffer size</td><td></td><td></td><td></td><td>106</td><td></td><td></td></tr><tr><td>target value function smoothing coefficient</td><td></td><td></td><td></td><td>0.005</td><td></td><td></td></tr><tr><td>number of hidden layers</td><td></td><td></td><td></td><td>2</td><td></td><td></td></tr><tr><td>discount factor</td><td></td><td></td><td></td><td>0.99</td><td></td><td></td></tr><tr><td>#runs used for plot averages</td><td></td><td></td><td></td><td>5</td><td></td><td></td></tr><tr><td>confidence interval for plot runs</td><td></td><td></td><td></td><td>~ 95%</td><td></td><td></td></tr></table>
+
+<table><tr><td></td><td>Hopper-v2</td><td>2Walker2d-v2H</td><td>HalfCheetah-v2</td><td>2Ant-v21</td><td></td><td>Humanoid-v2HumanoidStandup-v2</td></tr><tr><td>Bregman stepsize (1/tk)</td><td>0.8</td><td>0.4</td><td>0.3</td><td>0.5</td><td>0.5</td><td>0.3</td></tr></table>
+
+Table 4: Bregman stepsize for each domain, used by off-policy MDPO.
+
+# C TSALLIS-BASED BREGMAN DIVERGENCE
+
+As described in section 2.1, the MD update contains a Bregman divergence term. A Bregman divergence is a measure of distance between two points, induced by a strongly convex function $\psi$ . In the case where the potential function $\psi$ is the negative Shannon entropy, the resulting Bregman is the KL divergence. Similarly, when $\psi$ is the negative Tsallis entropy, for a real number $q$ , i.e.,
+
+$$
+\psi ( \pi ) = { \frac { 1 } { 1 - q } } { \Big ( } 1 - \sum _ { a } \pi ( a \mid s ) ^ { q } { \Big ) } ,
+$$
+
+we obtain the Tsallis Bregamn divergence, i.e.,
+
+$$
+B _ { \psi } ( \pi , \pi _ { k } ) = { \frac { q } { 1 - q } } \sum _ { a } \pi ( a \mid s ) \pi _ { k } ( a \mid s ) ^ { q - 1 } - { \frac { 1 } { 1 - q } } \sum _ { a } \pi ( a \mid s ) ^ { q } + \sum _ { a } \pi _ { k } ( a \mid s ) ^ { q } .
+$$
+
+Note that the last term on the RHS of (18) is independent of the policy $\pi$ being optimized. Also note that as $q \to 1$ , the Tsallis entropy collapses to the Shannon entropy $\begin{array} { r } { - \sum _ { a } \pi ( a \mid s ) \log \pi ( a \mid s ) } \end{array}$ , and thus, it generalizes the Shannon entropy. Moreover, for $q = 2$ , the Tsallis entropy is called the sparse Tsallis entropy.
+
+At first glance, the above expression is very different from the definition of the KL divergence. However, by defining the function $\log _ { q }$ as
+
+$$
+\log _ { q } x : = { \left\{ \begin{array} { l l } { { \frac { x ^ { q - 1 } - 1 } { q - 1 } } , } & { { \mathrm { i f ~ } } q \neq 1 { \mathrm { ~ a n d ~ } } x > 0 , } \\ { \log q , } & { { \mathrm { i f ~ } } q = 1 { \mathrm { ~ a n d ~ } } x > 0 , } \end{array} \right. }
+$$
+
+we may write the negative Tsallis entropy, defined by (17), as
+
+$$
+\psi ( \pi ) = \sum _ { a } \pi ( a \mid s ) \log _ { q } \pi ( a \mid s ) ,
+$$
+
+and the Tsallis Bregman, defined by (18), in a similar manner to the $\mathrm { K L }$ divergence as
+
+$$
+3 _ { \psi } ( \pi , \pi _ { k } ) = \underbrace { \sum _ { a } \pi ( a \mid s ) { \big ( } \log _ { q } \pi ( a \mid s ) - q \log _ { q } \pi _ { k } ( a \mid s ) { \big ) } } _ { = \mathbf { K } \mathbf { L } ( \pi , \pi _ { k } ) , { \mathrm { ~ f o r ~ } } q = 1 } - \underbrace { { \overbrace { ( 1 - q ) \sum _ { a } \pi _ { k } ( a \mid s ) \log _ { q } \pi _ { k } ( a \mid s ) } ^ { \left( 1 - q \right) \sum _ { a } } } } _ { = 0 , { \mathrm { ~ f o r ~ } } q = 1 } .
+$$
+
+With this convenient definition, we can write the Tsallis-based version of the off-policy MDPO objective defined in (11) as
+
+$$
+L ^ { \mathrm { T s a l i s } } ( \theta , \theta _ { k } ) = \mathbb { E } _ { s \sim \mathcal { D } } \big [ \log _ { q } \pi _ { \theta } \big ( \widetilde { a } _ { \theta } ( \epsilon , s ) | s \big ) - q \log _ { q } \pi _ { \theta _ { k } } \big ( \widetilde { a } _ { \theta } ( \epsilon , s ) | s \big ) - t _ { k } Q _ { \psi } ^ { \theta _ { k } } \big ( s , \widetilde { a } _ { \theta } ( \epsilon , s ) \big ) \big ] .
+$$
+
+Note that the last term on the RHS of (20) is independent of the policy being optimized (i.e., $\pi$ or $\theta$ ), and thus, does not appear in the loss function $L ^ { \mathrm { T s a l l i s } } ( \theta , \theta _ { k } )$ in (21).
+
+Note that on-policy MDPO uses a closed form version for the Bregman divergence (since both policies are Gaussian in our implementation, a closed form of their KL exists). Such a closed form version for the Tsallis based Bregman is quite cumbersome to handle in terms of implementation, and thus we did not pursue the Tsallis based version in the on-policy experiments. However, in principle, it is very much feasible and we leave this for future investigation.
+
+# D REVERSE VS. FORWARD KL DIRECTION
+
+Similar to the on-policy case, the mode-seeking or reverse direction of the KL term in off-policy MDPO (Eq. 16) is consistent with that in the MD update rule in convex optimization. With this direction of KL, the optimization problems for policy update in both off-policy MDPO and SAC are invariant to the normalization term $Z ( s )$ . Thus, these algorithms can update their policies without computing $Z ( s )$ . In [21], the authors proposed an algorithm, called exploratory conservative policy optimization (ECPO), that resembles our soft off-policy MDPO, except in the direction of KL. Switching the direction of KL to mean-seeking or forward has the extra overhead of estimating the normalization term for ECPO. However, in [21], they argue that it results in better performance. They empirically show that ECPO performs better than several algorithms, including one that is close to off-policy MDPO, which they refer to as policy mirror descent (PMD), and report poor performance for it. We did not use their code-base and exact configuration, but we did not observe such poor performance for our off-policy MDPO. In fact, experimental results of Section 5.4 show that off-policy MDPO performs better than or on-par with SAC in six commonly used MuJoCo domains. More experiments and further investigation are definitely required to better understand the effect of the KL direction in MDPO algorithms.
+
+# E ON-POLICY RESULTS
+
+Here, we report the results for all on-policy algorithms, i.e. TRPO, PPO and MDPO. We have three variants here, 1) the minimal version, i.e. {TRPO, PPO, MDPO}-M, which makes use of no code level optimizations, 2) the loaded version, i.e. {TRPO, PPO, MDPO}-LOADED, which includes all code level optimizations, and 3) the loaded $\mathbf { \xi } _ { t + G A E }$ version, i.e. {TRPO, PPO, MDPO}-LOADED $^ { + }$ GAE, which includes all code level optimizations and also includes the use of GAE. We see that the overall performance increases in most cases as compared to the minimal versions. However, the trend in performance between these algorithms remains consistent to the main results.
+
+<table><tr><td></td><td>MDPO</td><td>TRPO</td><td>PPO</td></tr><tr><td>Hopper-v2</td><td>1964 (±217)</td><td>2382 (±445)</td><td>1281 (±353)</td></tr><tr><td>Walker2d-v2</td><td>2948 (±298)</td><td>2454 (±171)</td><td>424 (±92)</td></tr><tr><td>HalfCheetah-v2</td><td>2873 (±835)</td><td>1726 (±690)</td><td>617 (±135)</td></tr><tr><td>Ant-v2</td><td>1162 (±738)</td><td>1716 (±338)</td><td>-40 (±33)</td></tr><tr><td>Humanoid-v2</td><td>635 (±46)</td><td>449 (±9)</td><td>448 (±56)</td></tr><tr><td>HumanoidStandup-v2</td><td>127901 (±6217)</td><td>100408 (±12564)</td><td>96068 (±11721)</td></tr></table>
+
+![](images/616d1d53ebd4c0de795fce0a48320d71dfa944d416310844f34bbb33d4bdcea8.jpg)  
+Table 5: Performance of MDPO-M, compared against PPO-M, TRPO-M on six MuJoCo tasks. The results are averaged over 5 runs, together with their $9 5 \%$ confidence intervals. The values with the best mean scores are bolded.   
+Figure 3: Performance of MDPO-M, compared against PPO-M, TRPO-M on six MuJoCo tasks. The results are averaged over 5 runs, with their $9 5 \%$ confidence intervals shaded.
+
+![](images/199f6c9e7af7d6e9b7ca21b4dbee343b609e7a46b925ec7ad8a8da633e7f6e71.jpg)  
+Figure 4: Performance of MDPO-LOADED, compared against loaded implementations (excluding GAE) of PPO and TRPO (PPO-LOADED, TRPO-LOADED) on six MuJoCo tasks. The results are averaged over 5 runs, with their $9 5 \%$ confidence intervals shaded.
+
+<table><tr><td></td><td>MDPO</td><td>TRPO</td><td>PPO</td></tr><tr><td>Hopper-v2</td><td>2361 (±518)</td><td>1979 (±672)</td><td>2051 (±241)</td></tr><tr><td>Walker2d-v2</td><td>4834 (±607)</td><td>4473 (±558)</td><td>1490 (±292)</td></tr><tr><td>HalfCheetah-v2</td><td>4172 (±1156)</td><td>3751 (±910)</td><td>2041 (±1319)</td></tr><tr><td>Ant-v2</td><td>5211 (±43)</td><td>4682 (±278)</td><td>59 (±133)</td></tr><tr><td>Humanoid-v2</td><td>3234 (±566)</td><td>4414 (±132)</td><td>529 (±47)</td></tr><tr><td>HumanoidStandup-v2</td><td>155261 (±3898)</td><td>149847 (±2632)</td><td>97223 (±4479)</td></tr></table>
+
+Table 6: Performance of MDPO-LOADED $^ { 1 + }$ GAE, compared against loaded implementations (including GAE) of PPO and TRPO (PPO-LOADED+GAE, TRPO-LOADED $\mathsf { \Pi } + \mathsf { G A E } ,$ ) on six MuJoCo tasks. The results are averaged over 5 runs, together with their $9 5 \%$ confidence intervals. The values with the best mean scores are bolded.
+
+![](images/7105332abaf3efeec5aed78fae3a572e983972b5a9fcc7f0574943448882b3fc.jpg)  
+Figure 5: Performance of MDPO-LOADED $^ +$ GAE, compared against loaded implementations (including GAE) of PPO and TRPO (PPO-LOADED $^ +$ GAE, TRPO-LOADED $^ { + }$ GAE) on six MuJoCo tasks. The results are averaged over 5 runs, with their $9 5 \%$ confidence intervals shaded.
+
+# F OFF-POLICY RESULTS
+
+Here, we report the results for all off-policy algorithms, i.e. MDPO and SAC. We have two variants here, 1) the minimal version, i.e. MDPO-M and SAC-M, which uses the standard neural network and batch sizes (64) and 2) the loaded version, i.e. MDPO-LOADED and SAC-LOADED, which uses a neural network and batch size of 256. We see that the overall performance increases in most cases as compared to the minimal versions, i.e. SAC-M, MDPO-M. However, the trend in performance between these algorithms remains consistent to the main results.
+
+Table 7: Performance of KL and Tsallis based versions of MDPO-M, compared with SAC-M on six MuJoCo tasks. The results are averaged over 5 runs, together with their $9 5 \%$ confidence intervals. The values with the best mean scores are bolded.   
+
+<table><tr><td></td><td>MDPO-KL</td><td>MDPO-Tsallis, qbest</td><td>SAC</td></tr><tr><td>Hopper-v2</td><td>1385 (±648)</td><td>1385 (±648), q = 1.0</td><td>1501 (±414)</td></tr><tr><td>Walker2d-v2</td><td>873 (±180)</td><td>1151 (±218), q = 1.8</td><td>635 (±137)</td></tr><tr><td>HalfCheetah-v2</td><td>8098 (±428)</td><td>8477 (±450), q = 1.4</td><td>9298 (±371)</td></tr><tr><td>Ant-v2</td><td>1051 (±284)</td><td>2348 (±338), q = 2.0</td><td>378 (±33)</td></tr><tr><td>Humanoid-v2</td><td>2258 (±372)</td><td>4426 (±229), q = 1.6</td><td>3598 (±172)</td></tr><tr><td>HumanoidStandup-v2</td><td>131702 (±7203)</td><td>138157 (±8983), q = 1.2</td><td>142774 (±4864)</td></tr></table>
+
+![](images/b517c5983be5d4879a744e42f323e8d2482a02a0e942423f4a7308446c64a77b.jpg)  
+Figure 6: Performance of KL and Tsallis based versions of MDPO-M, compared with SAC-M on six MuJoCo tasks. X-axis represents time steps in millions. The results are averaged over 5 runs, with their $9 5 \%$ confidence intervals shaded.
+
+Table 8: Performance of KL and Tsallis based versions of MDPO-LOADED, compared with SAC-LOADED on six MuJoCo tasks. The results are averaged over 5 runs, together with their $9 5 \%$ confidence intervals. The values with the best mean scores are bolded.   
+
+<table><tr><td></td><td>MDPO-KL</td><td>MDPO-Tsallis, qbest</td><td>SAC</td></tr><tr><td>Hopper-v2</td><td>2428 (±395)</td><td>2428 (±395), q = 1.0</td><td>1870 (±404)</td></tr><tr><td>Walker2d-v2</td><td>3591 (±366)</td><td>4028 (±287), q = 2.0</td><td>3738 (±312)</td></tr><tr><td>HalfCheetah-v2</td><td>11823 (±154)</td><td>11823 (±154), q = 1.0</td><td>11928 (±342)</td></tr><tr><td>Ant-v2</td><td>4434 (±749)</td><td>5486 (±737), q = 2.0</td><td>4989 (±579)</td></tr><tr><td>Humanoid-v2</td><td>5323 (±348)</td><td>5611 (±260), q = 1.2</td><td>5191 (±312)</td></tr><tr><td>HumanoidStandup-v2</td><td>143955 (±4499)</td><td>165882 (±16604), q = 1.4</td><td>154765 (±11721)</td></tr></table>
+
+![](images/826b8b364b1696f787293210717d31eb64522ea924933105d9ee0b4ae59d263c.jpg)  
+Figure 7: Performance of KL and Tsallis based versions of MDPO-LOADED, compared with SAC-LOADED on six MuJoCo tasks. X-axis represents time steps in millions. The results are averaged over 5 runs, with their $9 5 \%$ confidence intervals shaded. Note that although there is overlap in the performance of all methods, MDPO achieves a higher mean score in 5 out 6 domains.
+
+# G ADDITIONAL EXPERIMENTS
+
+# G.1 MULTI-STEP UPDATE
+
+For off-policy MDPO, we use a modified version of doing multi-step updates at each iteration (see section 5.1) due to computational reasons. In order to ensure a fair comparison, we used the single-step gradient updates for SAC in our main experiments. Here, we resort to the original algorithm presented in Algorithm 2, wherein we do $m$ gradient steps at each iteration. We compare this version of MDPO-KL with a similar multi-step version of SAC, as is originally reported in [13]. In Figure 8 we see that doing multiple updates helps improve the score of both MDPO and SAC, as is expected.
+
+![](images/aa9ecd62506828f3a77314187c8f04e1b18c2ffc046e2dc4bb2422b194e28933.jpg)  
+Figure 8: Performance of off-policy MDPO, compared with SAC on Hopper-v2, when doing both single and multiple gradient updates each iteration.
+
+# G.2 DIFFERENT TSALLIS ENTROPIES FOR BREGMAN AND MDP REGULARIZATION
+
+So far in the paper, we have used the same Tsallis entropy (same $q$ value) for defining the Bregman divergence as well as the MDP regularizer. Here, we test the performance for when the two tsallis entropies are different. For this, we sample from a set of three $q$ values $\{ 1 . 0 , 1 . 5 , 2 . 0 \}$ and report the results for every possible combination of $q$ values used for defining the Bregman divergence and the MDP regularizer. We test this on the Walker2d-v2, Humanoid-v2, and Ant-v2 domains (domains where we see the most improvement due to the addition of Tsallis entropy) and observe that sticking to the same $q$ values for both cases results in the best performance across all three domains (see Table 9).
+
+<table><tr><td rowspan="2"></td><td rowspan="2">MDP q</td><td colspan="3">Bregman q</td></tr><tr><td>q=1.0</td><td>q= 1.5</td><td>q=2.0</td></tr><tr><td rowspan="3">Walker2d-v2</td><td>q=1.0</td><td>3591 (±366)</td><td>3268(±234)</td><td>1007 (±422)</td></tr><tr><td>q= 1.5</td><td>2126 (±456)</td><td>2805 (±302)</td><td>1573 (±328)</td></tr><tr><td>q=2.0</td><td>14(±5)</td><td>2915 (±391)</td><td>4028 (±287)</td></tr><tr><td rowspan="4">Ant-v2</td><td>q=1.0</td><td>4434 (±749)</td><td>3007 (±572)</td><td>1913 (±973)</td></tr><tr><td>q=1.5</td><td>4119 (±326)</td><td>5488 (±233)</td><td>2781(±812)</td></tr><tr><td>q=2.0</td><td>-807 (±951)</td><td>4418 (±184)</td><td>5486 (±737)</td></tr><tr><td>q=1.0</td><td>5323 (±348)</td><td>4734 (±341)</td><td>4561 (±381)</td></tr><tr><td rowspan="3">Humanoid-v2</td><td>q=1.5</td><td>24(±4)</td><td>5013 (±274)</td><td>3766(±331)</td></tr><tr><td>q=2.0</td><td>12(±5)</td><td>28(±3)</td><td>2751(±304)</td></tr><tr><td></td><td></td><td></td><td></td></tr></table>
+
+Table 9: Different Tsallis Entropies. The results are averaged over 5 runs, with $9 5 \%$ confidence intervals shaded.
+
+# G.3 TSALLIS-BASED SAC
+
+We test performance of SAC-Tsallis while varying the $q$ values. In our preliminary experiments with SAC-Tsallis in Table 9, we did not see much improvement over SAC by tuning $q$ , unlike what we observed in our MDPO-Tsallis results. More experiments and further investigation are definitely needed to better understand the effect of Tsallis entropy (and $q$ ) in these algorithms.
+
+![](images/826c8b60de12395f8125e57d1bfa5adaeef698fdb46b308153727058acbd4bb0.jpg)  
+Figure 9: Performance of Tsallis SAC. The results are averaged over 5 runs, with $9 5 \%$ confidence intervals shaded.
+
+# H ATARI RESULTS
+
+![](images/49a21e74e721b7f2cb3509655310fe8ccb8922d8383c24ce7eb0d0dff515f321.jpg)  
+Figure 10: Comparison of MDPO with PPO on 21 Atari games. Order of magnitude of $\mathbf { X }$ -axis is $1 0 ^ { 3 }$ , which roughly corresponds to 10M environment time steps or 40M game frames.

parse/dev/gSdSJoenupI/gSdSJoenupI.md

@@ -0,0 +1,431 @@
+# POLYLOSS: A POLYNOMIAL EXPANSION PERSPECTIVE OF CLASSIFICATION LOSS FUNCTIONS
+
+Zhaoqi Leng1, Mingxing $\mathbf { T a n } ^ { 1 }$ , Chenxi Liu1, Ekin Dogus Cubuk2, Xiaojie $\mathbf { S h i ^ { 2 } }$ , Shuyang Cheng1,Dragomir Anguelov1
+
+1Waymo LLC 2Google LLC   
+{lengzhaoqi, tanmingxing, cxliu, shuyangcheng, dragomir}@waymo.com   
+{cubuk, xiaojies}@google.com
+
+# ABSTRACT
+
+Cross-entropy loss and focal loss are the most common choices when training deep neural networks for classification problems. Generally speaking, however, a good loss function can take on much more flexible forms, and should be tailored for different tasks and datasets. Motivated by how functions can be approximated via Taylor expansion, we propose a simple framework, named PolyLoss, to view and design loss functions as a linear combination of polynomial functions. Our PolyLoss allows the importance of different polynomial bases to be easily adjusted depending on the targeting tasks and datasets, while naturally subsuming the aforementioned cross-entropy loss and focal loss as special cases. Extensive experimental results show that the optimal choice within the PolyLoss is indeed dependent on the task and dataset. Simply by introducing one extra hyperparameter and adding one line of code, our Poly-1 formulation outperforms the crossentropy loss and focal loss on 2D image classification, instance segmentation, object detection, and 3D object detection tasks, sometimes by a large margin.
+
+Table 1: PolyLoss outperforms cross-entropy and focal loss on various models and tasks. Results are for the simplest Poly-1, which has only a single hyperparameter. On ImageNet (Deng et al., 2009), our PolyLoss improves both pretraining and finetuning for the recent EfficientNetV2 (Tan & Le, 2021); on COCO (Lin et al., 2014), PolyLoss improves both 2D detection and segmentation AR for Mask-RCNN (He et al., 2017); on Waymo Open Dataset (WOD) (Sun et al., 2020), PolyLoss improves 3D detection AP for the widely used PointPillars (Lang et al., 2019) and the very recent Range Sparse Net (RSN) (Sun et al., 2021). Details are in Table 4, 5, 7.   
+
+<table><tr><td>Task Default loss</td><td colspan="2">ImageNet classification Cross-entropy</td><td colspan="2">COCO det.and seg. Cross-entropy</td><td colspan="4">Waymo Open Dataset 3D detection Focal loss</td></tr><tr><td>Model</td><td>ENetV2-L(21K)</td><td>ENetV2-L(1K)</td><td>Mask R-CNN</td><td></td><td>PointPillars Car</td><td>PointPillars Ped</td><td>RSN Car</td><td>RSN Ped</td></tr><tr><td>Baseline</td><td>45.8</td><td>86.8</td><td>47.2</td><td>42.3</td><td>63.3</td><td>68.9</td><td>78.4</td><td>79.4</td></tr><tr><td>PolyLoss</td><td>46.4 (+0.6)</td><td>87.2 (+0.4)</td><td>49.7 (+2.5)</td><td>44.4 (+2.1)</td><td>63.7 (+0.4)</td><td>69.6 (+0.7)</td><td>78.9 (+0.5)</td><td>80.2 (+0.8)</td></tr></table>
+
+# 1 INTRODUCTION
+
+Loss functions are important in training neural networks. In principle, a loss function could be any (differentiable) function that maps predictions and labels to a scalar. Therefore, designing a good loss function is generally challenging due to its large design space, and designing a universal loss function that works across different tasks and datasets is even more challenging: for example, $\mathrm { L } 1 ~ /$ L2 losses are commonly used for regression tasks, but they are rarely used for classification tasks; focal loss is often used to alleviate the overfitting issue of cross-entropy loss for imbalanced object detection datasets (Lin et al., 2017), but it is not shown to consistently help other tasks. Many recent works have also explored new loss functions via meta-learning, ensembling or compositing different losses (Hajiabadi et al., 2017; Xu et al., 2018; Gonzalez & Miikkulainen, 2020b;a; Li et al., 2019).
+
+In this paper, we propose PolyLoss: a novel framework for understanding and designing loss functions. Our key insight is to decompose commonly used classification loss functions, such as crossentropy loss and focal loss, into a series of weighted polynomial bases. They are decomposed in the form of $\textstyle \sum _ { j = 1 } ^ { \infty } \alpha _ { j } ( 1 - P _ { t } ) ^ { j }$ , where $\alpha _ { j } \in \mathbb { R } ^ { + }$ is the polynomial coefficient and $P _ { t }$ is the prediction probability of the target class label. Each polynomial base $( 1 - P _ { t } ) ^ { j }$ is weighted by a corresponding polynomial coefficient $\alpha _ { j }$ , which enables us to easily adjust the importance of different bases for different applications. When $\alpha _ { j } = 1 / j$ for all $j$ , our PolyLoss becomes equivalent to the commonly used cross-entropy loss, but this coefficient assignment may not be optimal.
+
+Our study shows that, in order to achieve better results, it is necessary to adjust polynomial coefficients $\alpha _ { j }$ for different tasks and datasets. Since it is impossible to adjust an infinite number of $\alpha _ { j }$ , we explore various strategies with a small degree of freedom. Perhaps surprisingly, we observe that simply adjusting the single polynomial coefficient for the leading polynomial, which we denote $L _ { \mathrm { P o l y - 1 } }$ , is sufficient to achieve significant improvements over the commonly used cross-entropy loss and focal loss. Overall, our contribution can be summarized as:
+
+• Insights on common losses: We propose a unified framework, named PolyLoss, to rethink and redesign loss functions. This framework helps to explain cross-entropy loss and focal loss as two special cases of the PolyLoss family (by horizontally shifting polynomial coefficients), which was not recognized before. This new finding motivates us to investigate new loss functions that vertically adjust polynomial coefficients, shown in Figure 1.
+
+• New loss formulation: We evaluate different ways of vertically manipulating polynomial coefficients to simplify the hyperparameters search space. We propose a simple and effective Poly-1 loss formulation which only introduces one hyperparameter and one line of code.
+
+• New findings: We identify that focal loss, though effective for many detection tasks, is suboptimal for the imbalanced ImageNet-21K. We find the leading polynomial contributes to a large portion of the gradient during training, and its coefficient correlates to the prediction confidence $P _ { t }$ . In addition, we provide an intuitive explanation on how to leverage this correlation to design good PolyLoss tailored to imbalanced datasets.
+
+• Extensive experiments: We evaluate our PolyLoss on different tasks, models, and datasets. Results show PolyLoss consistently improves the performance on all fronts, summarized in Table 1, which includes the state-of-the-art classifiers EfficientNetV2 and detectors RSN.
+
+# 2 RELATED WORK
+
+Cross-entropy loss is used in popular and current state-of-the-art models for perception tasks such as classification, detection and semantic segmentation (Tan & Le, 2021; He et al., 2017; Zoph et al., 2020; Tao et al., 2020). Various losses are proposed to improve cross-entropy loss (Lin et al., 2017; Law & Deng, 2018; Cui et al., 2019; Zhao et al., 2021). Unlike prior works, the goal of this paper is to provide a unified framework for systematically designing a better classification loss function.
+
+Loss for class imbalance Training detection models, especially single-stage detectors, is difficult due to class imbalance. Common approaches such as hard example mining and reweighing are developed to address the class imbalance issue (Sung, 1996; Viola & Jones, 2001; Felzenszwalb et al., 2010; Shrivastava et al., 2016; Liu et al., 2016; Bulo et al., 2017). As one of these approaches, focal loss is designed to mitigate the class imbalance issue by focusing on the hard examples and is used to train state-of-the-art 2D and 3D detectors (Lin et al., 2017; Tan et al., 2020; Du et al., 2020; Shi et al., 2020; Sun et al., 2021). In our work, we found that focal loss is suboptimal for the imbalanced ImageNet-21K. Using the PolyLoss framework, we discover a better loss function, which performs the opposite role of focal loss. We further provide intuitive understanding of why it is important to design different loss functions tailored to different imbalanced datasets using the PolyLoss framework.
+
+Robust loss to label noise Another direction of research is to design loss functions that are robust to label noise (Ghosh et al., 2015; 2017; Zhang & Sabuncu, 2018; Wang et al., 2019; Oksuz et al., 2020; Menon et al., 2019). A commonly used approach is to incorporate noise robust loss function such as Mean Absolute Error (MAE) into cross-entropy loss. In particular, Taylor cross entropy loss is proposed to unify MAE and cross-entropy loss by expanding the cross-entropy loss in $( 1 - P _ { t } ) ^ { j }$ polynomial bases (Feng et al., 2020). By truncating the higher-order polynomials, they show truncated cross-entropy loss function is closer to MAE, which is more robust to label noise on datasets with synthetic label noise. In contrast, our PolyLoss provides a more general framework to design loss functions for different datasets by manipulating polynomial coefficients, which includes dropping higher-order polynomials proposed in Feng et al. (2020). Our experiments in subsection 4.1 show the loss proposed in Feng et al. (2020) performs worse than cross-entropy loss on the clean ImageNet dataset.
+
+Learned loss functions Several recent works demonstrate learning the loss function during training via gradient descent or meta learning (Hajiabadi et al., 2017; Xu et al., 2018; Gonzalez & Miikkulainen, 2020a; Li et al., 2019; 2020). Notably, TaylorGLO utilizes CMA-ES to optimize multivariate Taylor parameterization of a loss function and learning rate schedule during training (Hansen & Ostermeier, 1996; Gonzalez & Miikkulainen, 2020b). Due to the search space scale with the order of polynomials, the paper demonstrates that using the third-order parameterization (8 parameters), the learned loss function schedule outperforms cross-entropy loss on 10-class classification problems. Our paper (Figure 2a), on the other hand, shows for 1000-class classification tasks, hundreds of polynomials are needed. This results in a prohibitively large search space. Our proposed Poly-1 formulation mitigates the challenge of the large search space and do not rely on advanced black-box optimization algorithms. Instead, we show a simple grid search over one hyperparameter can lead to significant improvement on all tasks that we investigate.
+
+![](images/2ef883d044fcca098e2421bd4675d031cd9ede30b94cf3ca5c67e782719b1de9.jpg)  
+Figure 1: Unified view of cross-entropy loss, focal loss, and PolyLoss. PolyLoss $\textstyle \sum _ { j = 1 } ^ { \infty } \alpha _ { j } ( 1 -$ $P _ { t } ) ^ { j }$ is a more general framework, where $P _ { t }$ stands for prediction probability of the target class. Left: Polyloss is more flexible: it can be steeper (deep red) than cross-entropy loss (black) or flatter (light red) than focal loss (green). Right: Polynomial coefficients of different loss functions in the bases of $( 1 - P _ { t } ) ^ { j }$ , where $j \in \mathbb { Z } ^ { + }$ . Black dash lines are drawn to show the trend of polynomial coefficients. In the PolyLoss framework, focal loss can only shift the polynomial coefficients horizontally (green arrow), see Equation 2, whereas the proposed PolyLoss framework is more general, which also allows vertical adjustment (red arrows) of the polynomial coefficient for each polynomial term.
+
+# 3 POLYLOSS
+
+PolyLoss provides a framework for understanding and improving the commonly used cross-entropy loss and focal loss, visualized in Figure 1. It is inspired from the Taylor expansion of cross-entropy loss (Equation 1) and focal loss (Equation 2) in the bases of $( 1 - P _ { t } ) ^ { j }$ :
+
+$$
+\begin{array} { c } { { { \displaystyle { \cal L } _ { \mathrm { C E } } = - \log ( P _ { t } ) = \sum _ { j = 1 } ^ { \infty } 1 / j ( 1 - P _ { t } ) ^ { j } = ( 1 - P _ { t } ) + 1 / 2 ( 1 - P _ { t } ) ^ { 2 } . . . } } } \\ { { { } } } \\ { { { { \cal L } _ { \mathrm { F L } } = - ( 1 - P _ { t } ) ^ { \gamma } \log ( P _ { t } ) = \sum _ { j = 1 } ^ { \infty } 1 / j ( 1 - P _ { t } ) ^ { j + \gamma } = ( 1 - P _ { t } ) ^ { 1 + \gamma } + 1 / 2 ( 1 - P _ { t } ) ^ { 2 + \gamma } . . . } } } \end{array}
+$$
+
+where $P _ { t }$ is the model’s prediction probability of the target ground-truth class.
+
+Cross-entropy loss as PolyLoss Using the gradient descent method to optimize the cross-entropy loss requires taking the gradient with respect to $P _ { t }$ . In the PolyLoss framework, an interesting observation is that the coefficients $1 / j$ exactly cancel the $j$ th power of the polynomial bases, see Equation 1. Thus, the gradient of cross-entropy loss is simply the sum of polynomials $( 1 - P _ { t } ) ^ { j }$ , shown in Equation 3.
+
+$$
+- { \frac { \mathrm { d } L _ { \mathrm { C E } } } { \mathrm { d } P _ { t } } } = \sum _ { j = 1 } ^ { \infty } ( 1 - P _ { t } ) ^ { j - 1 } = 1 + ( 1 - P _ { t } ) + ( 1 - P _ { t } ) ^ { 2 } . . .
+$$
+
+The polynomial terms in the gradient expansion capture different sensitivity with respect to $P _ { t }$ . The leading gradient term is 1, which provides a constant gradient regardless of the value of $P _ { t }$ . On the contrary, when $j \gg 1$ , the $j$ th gradient term is strongly suppressed when $P _ { t }$ gets closer to 1.
+
+Focal loss as PolyLoss In the PolyLoss framework, Equation 2, it is apparent that the focal loss simply shifts the power $j$ by the power of a modulating factor $\gamma$ . This is equivalent to horizontally shifting all the polynomial coefficients by $\gamma$ as shown in Figure 1. To understand the focal loss from a gradient prospective, we take the gradient of the focal loss (Equation 2) with respect to $P _ { t }$ :
+
+$$
+- \frac { \mathrm { d } L _ { \mathrm { F L } } } { \mathrm { d } P _ { t } } = \sum _ { j = 1 } ^ { \infty } ( 1 + \gamma / j ) ( 1 - P _ { t } ) ^ { j + \gamma - 1 } = ( 1 + \gamma ) ( 1 - P _ { t } ) ^ { \gamma } + ( 1 + \gamma / 2 ) ( 1 - P _ { t } ) ^ { 1 + \gamma } \dots
+$$
+
+For a positive $\gamma$ , the gradient of focal loss drops the constant leading gradient term, 1, in the crossentropy loss, see Equation 3. As discussed in the previous paragraph, this constant gradient term causes the model to emphasize the majority class, since its gradient is simply the total number of
+
+<table><tr><td></td><td>Polynomial expansion in the basis of (1－Pt)</td><td>Loss</td></tr><tr><td>Cross-entropy loss</td><td>(1-Pt)+1/2(1-Pt)²+.+1/N(1-Pt)N +1/(N+1)(1-Pt)N+1 +...</td><td>LCE=-log(Pt)</td></tr><tr><td>Drop poly. (Sec 4.1)</td><td>(1 - Pt)+ 1/2(1- Pt)² +. +1/N(1- Pt)N (drop the remaining terms)</td><td>LDrop = LcE-∑j=N1/j(1-Pt)</td></tr><tr><td>Poly-N (Sec 4.2)</td><td>+1)(1- Pt)+.. +(∈N+1/N)DN +1/(N+1)(1- Pt)N+1 +.</td><td></td></tr><tr><td>Poly-1 (Sec 4.3)</td><td>+1)(1-Pt)+1/2(1-Pi)2+. +1/N(1- Pt) +1/(N +1)(1- Pt)N+1 +.</td><td>LPoly-1 = LCE+∈1(1-Pt)</td></tr></table>
+
+Table 2: Comparing different losses in the PolyLoss framework. Dropping higher order polynomial, proposed in prior works, truncates all higher order $( N + 1  \infty$ ) polynomial terms. We propose Poly-N loss, which perturbs the leading $_ \mathrm { N }$ polynomial coefficients. Poly-1 is the final loss formulation, which further simplifies Poly-N and only requires a simple grid search over one hyperparameter. The differences compared to cross-entropy loss are highlighted in red.
+
+examples for each class. By shifting the power of all the polynomial terms by $\gamma$ , the first term then becomes $( 1 - P _ { t } ) ^ { \gamma }$ , which is suppressed by the power of $\gamma$ to avoid overfitting to the already confident (meaning $P _ { t }$ close to 1) majority class. More details are shown in section 12.
+
+Connection to regression and general form Representing the loss function in the PolyLoss framework provides an intuitive connection to regression. For classification tasks where $y = 1$ is the effective probability of the ground-truth label, the polynomial bases $( 1 - P _ { t } ) ^ { j }$ can be expressed as $( y - P _ { t } ) ^ { j }$ . Thus both cross-entropy loss and focal loss can be interpreted as a weighted ensemble of distances between the prediction and label to the $j$ th power. However, a fundamental question in those losses: Are the coefficients in front of the regression terms optimal?
+
+In general, PolyLoss is a monotone decreasing function1 on $[ 0 , 1 ]$ which can be expressed as $\textstyle \sum _ { j = 1 } ^ { \infty } \alpha _ { j } ( \mathrm { i } - \check { P } _ { t } ) ^ { j }$ and provides a flexible framework to adjust each coefficient2. PolyLoss can be generalized to non-integer $j$ , but for simplicity we only focus on integer power $( j \in \mathbb { Z } ^ { + } )$ in this paper. In the next section, we investigate several strategies on designing better loss functions in the PolyLoss framework via manipulating $\alpha _ { j }$ .
+
+# 4 UNDERSTANDING THE EFFECT OF POLYNOMIAL COEFFICIENTS
+
+In the previous section, we established the PolyLoss framework and showed that cross-entropy loss and focal loss simply correspond to different polynomial coefficients, where focal loss horizontally shifts the polynomial coefficients of cross-entropy loss.
+
+In this section, we propose the final loss formulation Poly-1. We study in depth how vertically adjusting polynomial coefficients, shown in Figure 1, may affect training. Specifically, we explore three different strategies in assigning polynomial coefficients: dropping higher-order terms; adjusting multiple leading polynomial coefficients; and adjusting the first polynomial coefficient, summarized in Table 2. We find adjusting the first polynomial coefficient (Poly-1 formulation) leads to maximal gain while requiring minimal code change and hyperparameter tuning.
+
+In these explorations, we experiment with 1000-class ImageNet (Deng et al., 2009) classification. We abbreviate it as ImageNet-1K to differentiate it from the full version, which contains 21K classes. We use ResNet-50 (He et al., 2016) and its training hyperparameters without modification.3
+
+# 4.1 $L _ { D r o p }$ : REVISITING DROPPING HIGHER-ORDER POLYNOMIAL TERMS
+
+Prior works (Feng et al., 2020; Gonzalez & Miikkulainen, 2020b) have shown dropping the higherorder polynomials and tuning the leading polynomials can improve model robustness and perfor- mance. We adopt the same loss formulation $\begin{array} { r } { \dot { L _ { \mathrm { D r o p } } } = \sum _ { j = 1 } ^ { N } 1 / \dot { j } ( 1 - P _ { t } ) ^ { j } } \end{array}$ , as in Feng et al. (2020), and compare their performance with the baseline cross-entropy loss on ImageNet-1K. As shown in Figure 2a, we need to sum up more than 600 polynomial terms to match the accuracy of crossentropy loss. Notably, removing higher-order polynomials cannot simply be interpreted as adjusting the learning rate. To verify this, Figure 2b compares the performance for different learning rates with various cutoffs: no matter we increase or decrease the learning rate from the original value of 0.1, the accuracy worsens. Additional hyperparameter tuning is shown in section 9.
+
+![](images/876612310365b79e3055fe1b3c14d3a20be446712da276138a5631269b5de29e.jpg)  
+(b) Adjusting the learning rate (default 0.1) of $L _ { \mathrm { D r o p } }$ does not improve the classification accuracy.
+
+(a) Truncating the infinite sum of polynomials in cross-entropy loss to $N$ reduces accuracy.
+
+![](images/7537464298f565527318ca7d0dff4e6bdfb5ccaeb7ae5d6ff0e9d5a4e39dfbd3.jpg)  
+Figure 2: Training ResNet-50 on ImageNet-1K requires hundreds of polynomial terms to reproduce the same accuracy as cross-entropy loss.
+
+To understand why higher-order terms are important, we consider the residual sum after removing the first $N$ polynomial terms from cross-entropy loss: $\begin{array} { r } { R _ { \mathrm { N } } = L _ { \mathrm { C E } } - L _ { \mathrm { D r o p } } = \sum _ { j = N + 1 } ^ { \infty } 1 / j ( 1 - P _ { t } ) ^ { j } } \end{array}$
+
+Theorem 1. For any small $\zeta > 0$ , $\delta > 0$ if $N > \log _ { 1 - \delta } \left( \zeta \cdot \delta \right)$ , then for any $p \in [ \delta , 1 ]$ , we have $| R _ { N } ( p ) | < \zeta$ and $| R _ { N } ^ { \prime } ( p ) | < \zeta$ . (Proof in section 7)
+
+Hence, taking a large $N$ is necessary to ensure $L _ { \mathrm { D r o p } }$ is uniformly close to $L _ { \mathrm { C E } }$ in the perspectives of loss and loss derivative on $[ \delta , 1 ]$ . For a fixed $\zeta$ , as $\delta$ approaches 0, $N$ grows rapidly. Our experimental results align with the theorem. The higher-order $( j ~ > ~ N + 1 )$ polynomials play an important role during the early stages of training, where $P _ { t }$ is typically close to zero. For example, when $P _ { t } \sim 0 . 0 0 1$ , according to Equation 3, the coefficient of the $5 0 0 \mathrm { { t h } }$ term’s gradient is $0 . 9 9 9 ^ { \bar { 4 } 9 9 } \sim 0 . 6$ , which is fairly large. Different from aforementioned prior works, our results show that we cannot easily reduce the number of polynomial coefficients $\alpha _ { j }$ by excluding the higher-order polynomials.
+
+Dropping higher order polynomials is equivalent to pushing all the higher order $( j > N + 1 )$ polynomial coefficients $\alpha _ { j }$ vertically to zero in the PolyLoss framework. Since simply setting coefficients to zero is suboptimal for training ImageNet-1K, in the following sections, we investigate how to manipulate polynomial coefficient beyond setting them to zero in the PolyLoss framework. In particular, we aim to propose a simple and effective loss function that requires minimal tuning.
+
+# 4.2 $L _ { \mathrm { P o L Y - N } }$ : PERTURBING LEADING POLYNOMIAL COEFFICIENTS
+
+In this paper, we propose an alternative way of designing a new loss function in the PolyLoss framework, where we adjust the coefficients of each polynomial. In general, there are infinitely many polynomial coefficients $\alpha _ { j }$ need to be tuned. Thus, it is infeasible to optimize the most general loss:
+
+$$
+L _ { \mathrm { P o l y } } = \alpha _ { 1 } ( 1 - P _ { t } ) + \alpha _ { 2 } ( 1 - P _ { t } ) ^ { 2 } + \ldots + \alpha _ { N } ( 1 - P _ { t } ) ^ { N } + \ldots = \sum _ { j = 1 } ^ { \infty } \alpha _ { j } ( 1 - P _ { t } ) ^ { j }
+$$
+
+The previous section (subsection 4.1) has shown that hundreds of polynomials are required in training to do well on tasks such as ImageNet-1K classification. If we naively truncate the infinite sum in Equation 5 to the first few hundreds terms, tuning coefficients for so many polynomials still results in a prohibitively large search space. In addition, collectively tuning many coefficients also does not outperform cross-entropy loss, details in section 10.
+
+To tackle this challenge, we propose to perturb the leading polynomial coefficients in cross-entropy loss, while keeping the rest the same. We denote the proposed loss formulation as Poly-N, where $\mathbf { N }$ stands for the number of leading coefficients that will be tuned.
+
+$$
+\begin{array} { l } { { \displaystyle { \cal L } _ { \mathrm { P o l y - N } } = \underbrace { ( \epsilon _ { 1 } + 1 ) ( 1 - P _ { t } ) + \ldots + ( \epsilon _ { N } + 1 / N ) ( 1 - P _ { t } ) ^ { N } } _ { \mathrm { p e r t u n b e d b y } \epsilon _ { j } } + \underbrace { 1 / ( N + 1 ) ( 1 - P _ { t } ) ^ { N + 1 } + \ldots } _ { \mathrm { s a m e ~ a s ~ } L _ { \mathrm { C E } } } } } \\ { { \displaystyle ~ = - \log ( P _ { t } ) + \sum _ { j = 1 } ^ { N } \epsilon _ { j } ( 1 - P _ { t } ) ^ { j } } } \end{array}
+$$
+
+Here, we replace the $j$ th polynomial coefficient in crossentropy loss $1 / j$ with $1 / j + \epsilon _ { j }$ , where $\epsilon _ { j } \in [ - 1 / j , \infty )$ is the perturbation term. This allows us to pinpoint the first $N$ polynomials without the need to worry about the infinitely many higher-order $( j > N + 1 )$ coefficients, as in Equation 5.
+
+Table 3: ${ \cal L } _ { \mathrm { P o l y - N } }$ outperforms crossentropy loss on ImageNet-1K.   
+
+<table><tr><td></td><td>CEloss</td><td>N=1</td><td>N=2</td><td>N=3</td></tr><tr><td>N-dim. grid search</td><td>76.3</td><td>76.7</td><td>76.8</td><td>1</td></tr><tr><td>Greedy grid search</td><td>76.3</td><td>76.7</td><td>76.7</td><td>76.7</td></tr></table>
+
+![](images/f0f054186d0e05e950ba4d8fa1e641ba2b432f80eb66a9d3aa80293836309ed0.jpg)
+
+![](images/39a2b77ef262c787045c690c9562210ce71a5f5baaf7823ad18677141e90981b.jpg)  
+(b) Percentage of gradient from the first polynomial versus the rest (infinitely many) polynomials.
+
+(a) PolyLoss family $L _ { \mathrm { P o l y - 1 } } = - \log ( P _ { t } ) + \epsilon _ { 1 } ( 1 -$ $P _ { t }$ ), where $\epsilon _ { 1 } \in \{ - 1 , 0 , 1 , \dots , 8 \}$ .
+
+Figure 3: The first polynomial plays an important role for training ResNet-50 on ImageNet1K. (a) Increasing the coefficient of the first polynomial term $( \epsilon _ { 1 } > 0 $ ) consistently improves the ResNet50 prediction accuracy. Red dash line shows the accuracy when using cross-entropy loss. Mean and stdev of three runs are plotted. (b) The first polynomial $\left( 1 - P _ { t } \right)$ contributes more than half of the cross-entropy gradient at the last $65 \%$ of the training steps, which highlights the importance of tuning the first polynomial. The red dash line shows the crossover.
+
+Table 3 shows $L _ { \mathrm { P o l y - N } }$ outperforms the baseline cross-entropy loss accuracy. We explore Ndimensional grid search and greedy grid search of $\epsilon _ { j }$ in $L _ { \mathrm { P o l y - N } }$ up to $N = 3$ and find that simply adjusting the coefficient of the first polynomial $N = 1$ ) leads to better classification accuracy. Performing 2D grid search $N = 2$ ) can further boost the accuracy. However, the additional gain is small $( + 0 . 1 )$ compared to adjusting only the first polynomial $\left( + 0 . 4 \right)$ .
+
+# 4.3 $L _ { \mathrm { P o L Y - 1 } }$ : SIMPLE AND EFFECTIVE
+
+As shown in the previous section, we find tuning the first polynomial term leads to the most significant gain. In this section, we further simplify the Poly-N formulation and focus on evaluating Poly-1, where only the first polynomial coefficient in cross-entropy loss is modified.
+
+$$
+L _ { \mathrm { P o l y - 1 } } = ( 1 + \epsilon _ { 1 } ) ( 1 - P _ { t } ) + 1 / 2 ( 1 - P _ { t } ) ^ { 2 } + \ldots = - \log ( P _ { t } ) + \epsilon _ { 1 } ( 1 - P _ { t } )
+$$
+
+We study the effect of different first term scaling on the accuracy and observe that increasing the first polynomial coefficient can systematically increase the ResNet-50 accuracy, as shown in Figure 3a. This result suggests that the cross-entropy loss is suboptimal in terms of polynomial coefficient values, and increasing the first polynomial coefficient leads to consistent improvement, which is comparable to other training techniques (section 11).
+
+Figure 3b shows the leading polynomial contributes to more than half of the cross-entropy gradient during training for the majority of the time, which highlights the significance of the first polynomial term $\left( 1 - P _ { t } \right)$ compared to the rest of the infinite many terms. Therefore, in the remaining of the paper, we adopt the form of $L _ { \mathrm { P o l y - 1 } }$ and primarily focus on adjusting the leading polynomial coefficient. As is evident from Equation 7, it only modifies the original loss implementation by a single line of code (adding a $\epsilon _ { 1 } ( 1 - P _ { t } )$ term on top of cross-entropy loss).
+
+Note that, all the training hyperparameters are optimized for cross-entropy loss. Even so, a simple grid search on the first polynomial coefficients in the Poly-1 formulation significantly increases the classification accuracy. We find optimizing other hyperparameters for $L _ { \mathrm { P o l y - 1 } }$ leads to higher accuracy, and show more details in section 8.
+
+# 5 EXPERIMENTAL RESULTS
+
+In this section, we compare our PolyLoss against the commonly used cross-entropy loss and focal loss on various tasks, models, and datasets. For the following experiments, we adopt the default training hyperparameters in the public repositories without any tuning. Nevertheless, Poly-1 formulation leads to consistent advantage over default loss functions at the cost of a simple grid search.
+
+# 5.1 LPOLY-1 IMPROVES 2D IMAGE CLASSIFICATION ON IMAGENET
+
+Image classification is a fundamental problem in computer vision, and progress on image classification has led to progress on many related computer vision tasks. In terms of the network architecture, in addition to the ResNet-50 already used in section 4, we also experiment with the state-of-the-art EfficientNetV2 (Tan & Le, 2021). We use the ImageNet settings in (Tan & Le, 2021) except for replacing the original cross-entropy loss with our PolyLoss $L _ { P o l y - 1 }$ with different values of $\epsilon _ { 1 }$ . In terms of the dataset, in addition to the ImageNet-1K dataset already used in section 4, we also consider ImageNet-21K, which has about 13M training images with 21,841 classes. We will study both the ImageNet-21K pretraining results and the ImageNet-1K finetuning results.
+
+Pretraining EfficientNetV2-L on ImageNet-21K, then finetuning it on ImageNet-1K can improve classification accuracy (Tan & Le, 2021). Here, we follow the same pretraining and finetuning schedule as reported in Tan & Le (2021) without modification4 but replace the cross-entropy loss with $L _ { \mathrm { P o l y - 1 } } = - \log ( P _ { t } ) + \epsilon _ { 1 } ( 1 - P _ { t } )$ . We reserve 25,000 images from the training set as minival to search the optimal $\epsilon _ { 1 }$ .
+
+Pretraining on ImageNet-21K Figure 4 highlights the importance of using tailored loss function when pretraining model on ImageNet21K dataset. A simple grid search over $\epsilon _ { 1 } ~ \in$ $\{ 0 , 1 , 2 , \ldots , 7 \}$ in $L _ { \mathrm { P o l y - 1 } }$ without changing other default hyperparameters leads to around $1 \%$ accuracy gain for all SOTA EfficientNetV2 models with different sizes. The accuracy improvement of using a better loss function nearly matches the improvement of scaling up the model architecture (S to M and M to L).
+
+Surprisingly, see Figure 5a, increasing the weight of the leading polynomial coefficient improves the accuracy of pretraining on ImageNet-21K $_ { ( + 0 . 6 ) }$ , whereas reducing it low
+
+![](images/7884e7972bbde84fe12505f77b86b3c7fd365595ac636757e8ca7efae894dd85.jpg)  
+Figure 4: PolyLoss improves EfficientNetV2 family on the speed-accuracy Pareto curve. Validation accuracy of EfficientNetV2 models pretrained on ImageNet-21K are plotted. PolyLoss outperforms cross-entropy loss with about $\times 2$ speed-up.
+
+ers the accuracy (-0.9). Setting $\epsilon _ { 1 } = - 1$ truncates the leading polynomial term in the cross-entropy loss (Equation 1), which is similar to having a focal loss with $\gamma = 1$ (Equation 2). However, the opposite change, where $\epsilon _ { 1 } > 0$ , improves the accuracy on the imbalanced ImageNet-21K.
+
+We hypothesize the prediction of the imbalanced ImageNet-21K is not confident enough ( $P _ { t }$ is small), and using positive $\epsilon _ { 1 }$ PolyLoss leads to more confident predictions. To validate our hypothesis, we plot $P _ { t }$ as a function of training steps in Figure 5b. We observe that $\epsilon _ { 1 }$ directly controls the mean $P _ { t }$ over all classes. Using positive $\epsilon _ { 1 }$ PolyLoss leads to more confident prediction (higher $P _ { t }$ ). On the other hand, negative $\epsilon _ { 1 }$ PolyLoss lowers the confidence.
+
+![](images/e22c64b66f694b3701d437f65d35cd83a00405f3e7ebb451800bd09652ca2867.jpg)
+
+![](images/e8784af14799362097832888900e3a4821591aaf6269e0d016860b8ed3dff38b.jpg)  
+(b) Positive $\epsilon _ { 1 } = 1$ (dark) increases the prediction confidence, while negative $\epsilon _ { 1 } = - 1$ (light) decreases the prediction confidence.
+
+(a) Validation accuracy of EfficientNetV2-L on ImageNet-21K. PolyLoss with positive $\epsilon _ { 1 }$ outperforms baseline cross-entropy loss (red dash line).
+
+# Figure 5: PolyLoss improves EfficientNetV2-L by increasing prediction confidence $P _ { t }$
+
+Fine tuning on ImageNet-1K After pretraining on ImageNet-21K, we take the EfficientNetV2-L checkpoint and finetune it on ImageNet-1K, using the same procedure as Tan & Le (2021) except for replacing the original cross-entropy loss with the Poly-1 formulation. PolyLoss improves the finetuning accuracy by $0 . 4 \%$ , advancing the ImageNet-1K top-1 accuracy from $8 6 . 8 \%$ to $8 7 . 2 \%$ .
+
+Table 4: PolyLoss improves classification accuracy on ImageNet validation set. We set $\epsilon _ { 1 } = 2$ for both.   
+
+<table><tr><td>EfficientNetV2-L</td><td>LCE</td><td>LPoly-1</td><td>Improv.</td></tr><tr><td>ImageNet-21K</td><td>45.8</td><td>46.4</td><td>+0.6</td></tr><tr><td>ImageNet-1K</td><td>86.8</td><td>87.2</td><td>+0.4</td></tr></table>
+
+# 5.2 $L _ { \mathrm { P o L Y - 1 } }$ IMPROVES 2D INSTANCE SEGMENTATION AND OBJECT DETECTION ON COCO
+
+Instance segmentation and object detection require localizing objects in an image in addition to recognizing them: the former in the form of arbitrary shapes and the latter in the form of bounding boxes. For both instance segmentation and object detection, we use the popular COCO (Lin et al., 2014) dataset, which contains 80 object classes. We choose Mask R-CNN (He et al., 2017) as the representative model for instance segmentation and object detection. These models optimize multiple losses, e.g. $L _ { \mathrm { M a s k R C N N } } = L _ { \mathrm { c l s } } + L _ { \mathrm { b o x } } + L _ { \mathrm { m a s k } }$ . For the following experiments, we only replace the $L _ { \mathrm { c l s } }$ with PolyLoss and leave other losses intact. Results are summarized in Table 5.
+
+Table 5: PolyLoss improves detection results on COCO validation set. Bounding box and instance segmentation mask average-precision (AP) and average-recall (AR) are reported for Mask R-CNN model with a ResNet-50 backbone. Mean and stdev of three runs are reported.   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">Loss</td><td colspan="2">Box</td><td colspan="2">Mask</td></tr><tr><td>AP</td><td>AR</td><td>AP</td><td>AR</td></tr><tr><td>Mask R-CNN LCE</td><td>-log(Pt)</td><td>35.0±0.09</td><td>47.2± 0.16</td><td>31.3±0.09</td><td>42.3±0.02</td></tr><tr><td>Mask R-CNN LPoly-1</td><td>-log(Pt)-(1-Pt)</td><td>35.3 ± 0.12</td><td>49.7± 0.07</td><td>31.6 ± 0.11</td><td>44.4 ± 0.07</td></tr><tr><td>Improvement</td><td></td><td>+0.3</td><td>+2.5</td><td>+0.3</td><td>+2.1</td></tr></table>
+
+Reducing the leading polynomial coefficient improves Mask R-CNN AP and AR. In training Mask R-CNN, we use the training schedule optimized for cross-entropy loss,5 and replace the crossentropy loss with $L _ { P o l y - 1 } = - \mathrm { l o g } ( P _ { t } ) + \bar { \epsilon _ { 1 } } ( 1 - P _ { t } )$ for the classification loss $L _ { c l s }$ , where $\epsilon _ { 1 } ~ \in$ $\{ - 1 . 0 , - 0 . 8 , - 0 . 6 , - 0 . 4 , - 0 . 2 , 0 , 0 . 5 , 1 . 0 \}$ . We ensure the leading coefficient is positive, i.e. $\epsilon _ { 1 } \geq$ $- 1$ . Our results in Figure 6a show systematic improvements of box AP, box AR, mask AP, and mask AR as we reduce the weight of the first polynomial by using negative $\epsilon _ { 1 }$ values. Note that Poly-1 $\epsilon = - 1$ ) not only improves AP but also significantly increases AR, shown in Table 5.
+
+![](images/d3bc5f279780ac929949f6c9b6ba2a2b83ca9ed89198e1a5994cd1d12fcc6f97.jpg)  
+(a) Bound box AP, AR and Mask AP, AR increase as $\epsilon _ { 1 }$ decreases. Negative $\epsilon _ { 1 }$ outperforms cross-entropy loss (red dash line).
+
+![](images/06eaac6c85877bbca253512abf37fc915242c3fc25d450676fd0e665af1b251c.jpg)  
+(b) Negative $\epsilon _ { 1 } = - 1$ (light) reduces the overconfident prediction $P _ { t }$ .
+
+# Figure 6: PolyLoss improves Mask R-CNN by lowering overconfident predictions. Mean and stdev of three runs are plotted.
+
+Tailoring loss function to datasets and tasks is important. ImageNet-21K and COCO are both imbalanced but the optimal $\epsilon$ for PolyLoss are opposite in sign, i.e. $\epsilon = 2$ for ImageNet-21K classification and $\epsilon = - 1$ for Mask R-CNN detection. We plot the $P _ { t }$ of the Mask R-CNN classification head and found the original prediction is overly confident $P _ { t }$ is close to 1) on the imbalanced COCO dataset, thus using a negative $\epsilon$ lowers the prediction confidence, as shown in Figure 6b. This effect is similar to label smoothing (Szegedy et al., 2016) and confidence penalty (Pereyra et al., 2017), but unlike those methods, as long as $0 > \epsilon > - 1$ , PolyLoss lowers the gradients of overconfident predictions but will not encourage incorrect predictions or directly penalize prediction confidence.
+
+5.3 $L _ { \mathrm { P o L Y - 1 } }$ IMPROVES 3D OBJECT DETECTION ON WAYMO OPEN DATASET   
+
+<table><tr><td></td><td>Polynomial expansion in the basis of (1-Pt)</td><td>Loss</td></tr><tr><td>Focal loss</td><td>(1-Pt))+1+1/2(1-Pt)γ+2+1/3(1-Pt)γ++...</td><td>LFL =-(1-Pt)log(Pt)</td></tr><tr><td>Poly-1 (PointPillars)</td><td>(∈1 +1)(1-Pt))+1 +1/2(1- Pt)x+2 +1/3(1- Pt))+ +.</td><td></td></tr><tr><td>Poly-1*(RSN)</td><td>(drop first) (1/2+ ∈2)(1− Pt)+² +1/3(1- Pt)γ+3 +...</td><td>Py1 =LFL-(1−Pt)γ+1+∈2(1−)+2</td></tr></table>
+
+Table 6: PolyLoss vs. focal loss for 3D detection models. Differences are highlighted in red. We found the best Poly-1 for PointPillars is $\epsilon _ { 1 } = - 1$ , which is equivalent to dropping the first term. Therefore, for RSN, we drop the first term and tune the new leading polynomial $\bar { ( 1 - P _ { t } ) } ^ { \gamma + 2 }$ .
+
+Detecting 3D objects from LiDAR point clouds is an important topic and can directly benefit autonomous driving applications. We conduct these experiments on the Waymo Open Dataset (Sun et al., 2020). Similar to 2D detectors, 3D detection models are commonly based on single-stage and two-stage architectures. Here, we evaluate our PolyLoss on two models: a popular single-stage PointPillars model (Lang et al., 2019); and a state-of-the-art two-stage Range Sparse Net (RSN) model (Sun et al., 2021). Both models rely on multi-task loss functions during training. Here, we focus on improving the classification focal loss by replacing it with PolyLoss. Similar to the 2D perception cases, we adopt the Poly-1 formulation to improve upon focal loss, shown in Table 6.
+
+PolyLoss improves single-stage PointPillars model. The PointPillars model converts the raw 3D point cloud to a 2D top-down pseudo image, and then detect 3D bounding boxes from the 2D image in a similar way to RetinaNet (Lin et al., 2017). Here, we replace the classification focal loss $( \gamma = 2 )$ with ${ \cal L } _ { \mathrm { p o l y - 1 } } ^ { \mathrm { F L } } \ : = \ : - ( 1 \ : - \ : P _ { t } ) ^ { 2 } \log P _ { t } \ : + \ : \epsilon _ { 1 } ( 1 \ : - \ : P _ { t } ) ^ { 3 }$ and adopt the same training schedule optimized for focal loss without any modification6. Table 7 shows that $L _ { \mathrm { P o l y - 1 } } ^ { \mathrm { F L } }$ with $\epsilon = - 1$ leads to significant improvement on all the metrics for both vehicle and pedestrian models.
+
+Table 7: PolyLoss improves detection results on Waymo Open Dataset validation set. Two detection models: single-stage PointPillars (Lang et al., 2019) and two-stage SOTA RSN (Sun et al., 2021) are evaluated. Bird’s eye view (BEV) and 3D detection average precision (AP) and average precision with heading (APH) at Level 1 (L1) and Level 2 (L2) difficulties are reported. The IoU threshold is set to 0.7 for vehicle detection and 0.5 for pedestrian detection.   
+
+<table><tr><td rowspan="2"></td><td>Loss</td><td colspan="2">BEV</td><td colspan="2">3D</td></tr><tr><td></td><td>AP/APHL1</td><td>AP/APHL2</td><td>AP/APHL1</td><td>AP/APH L2</td></tr><tr><td colspan="6">Vehicle (IoU=0.7)</td></tr><tr><td>PointPillars LFL</td><td>(1-Pt)²log(Pt)</td><td>82.5/81.5</td><td>73.9/72.9</td><td>63.3/62.7</td><td>55.2/54.7</td></tr><tr><td>PointPillars Lpoly-</td><td>-(1- Pt)² log(Pt)-(1- Pt)3</td><td>83.6/82.5</td><td>74.8/73.7</td><td>63.7/63.1</td><td>55.5/55.0</td></tr><tr><td>Improvement RSNLFL</td><td></td><td>+1.1/+1.0</td><td>+0.9/+0.8</td><td>+0.4/+0.7</td><td>+0.3/+0.3</td></tr><tr><td>RSN LE-1*</td><td>(1-Pt)²log(Pt)</td><td>91.3/90.8</td><td>82.6/82.2</td><td>78.4/78.1</td><td>69.5/69.1</td></tr><tr><td>Improvement</td><td>-(1 - Pt)²log(Pt)-(1 - Pt)³−0.4(1 - Pt)4</td><td>91.5/90.9</td><td>82.7/82.1 +0.1/-0.1</td><td>78.9/78.4</td><td>69.9/69.5</td></tr><tr><td></td><td></td><td>+0.2/+0.1</td><td></td><td>+0.5/+0.3</td><td>+0.4/+0.4</td></tr><tr><td colspan="6">Pedestrian (IoU=0.5)</td></tr><tr><td>PointPillars LFL</td><td>-(1-Pt)²log(Pt)</td><td>76.0/62.0</td><td>67.2/54.6</td><td>68.9/56.6</td><td>60.0/49.1</td></tr><tr><td>PointPillars Lply-1</td><td>-(1- Pt)² log(Pt) -(1- Pt)3</td><td>77.1/62.9</td><td>67.7/55.1</td><td>69.6/57.1</td><td>60.2/49.3</td></tr><tr><td>Improvement</td><td></td><td>+1.1/+0.9</td><td>+0.5/+0.5</td><td>+0.7/+0.5</td><td>+0.2+0.2</td></tr><tr><td>RSN LFL</td><td>-(1-Pt)²log(Pt)</td><td>85.0/81.4</td><td>75.5/72.2</td><td>79.4/76.2</td><td>69.9/67.0</td></tr><tr><td>RSN Lp,1* Improvement</td><td>-(1 - Pt)²log(Pt) -(1 - Pt)³ +0.2(1 − Pt)4</td><td>85.4/81.8</td><td>75.8/72.5</td><td>80.2/77.0</td><td>70.6/67.7</td></tr><tr><td></td><td></td><td>+0.4/+0.4</td><td>+0.3/+0.3</td><td>+0.8/+0.8</td><td>+0.7/+0.7</td></tr></table>
+
+Advancing the state-of-the-art with RSN. RSN segments foreground points from the 3D point cloud in the first stage, and then applies sparse convolution to predict 3D bounding boxes from the selected foreground points. RSN uses the same focal loss as the PointPillars $L _ { \mathrm { P o l y - 1 } } ^ { \mathrm { F L } }$ , i.e., for $L _ { \mathrm { { F L } } } = - ( 1 - P _ { t } ) ^ { 2 } \log P _ { t }$ $\epsilon _ { 1 } = - 1$ . Since the optimalequivalent to dropmulation for RSN and tune the new leading polynomial $( 1 - P _ { t } ) ^ { 4 }$ by defining $L _ { \mathrm { P o l y - 1 } ^ { - } } ^ { \mathrm { F L } } = - ( 1 - \bar { P _ { t } } ) ^ { \hat { 2 } } \log ( P _ { t } ) -$ $( 1 - P _ { t } ) ^ { 3 } + \epsilon _ { 2 } ( 1 - P _ { t } ) ^ { 4 }$ , shown in Figure 7. We follow the same training schedule optimized for focal loss described in Sun et al. (2021) without adjustment. Our results, in Table 7, show that tuning the new leading polynomial improves all metrics (except vehicle detection BEV APH L2) for the SOTA 3D detector.
+
+![](images/bd75a8c22a0c74806e0314c5cf5ab3dc0ad3f252a91549a72ac48e63f1dedaf7.jpg)  
+Figure 7: Visualizing $L _ { \mathbf { P o l y } - 1 } ^ { F L }$ and $L _ { \mathbf { P o l y } - \mathbf { 1 } ^ { * } } ^ { F L }$ in the PolyLoss framework.
+
+# 6 CONCLUSION
+
+In this paper, we propose the PolyLoss framework, which provides a unified view on common loss functions for classification problems. We recognize that, under polynomial expansion, focal loss is a horizontal shift of the polynomial coefficients compared to the cross-entropy loss. This new insight motivates us to explore an alternative dimension. i.e. vertically modify the polynomial coefficients.
+
+Our PolyLoss framework provides flexible ways of changing the loss function shape by adjusting the polynomial coefficients. In this framework, we propose a simple and effective Poly-1 formulation. By simply adjusting the coefficient of the leading polynomial coefficient with just one extra hyperparameter $\epsilon _ { 1 }$ , we show our simple Poly-1 improves a variety of models across multiple tasks and datasets. We hope Poly-1 formulation’s simplicity (one extra line of code) and effectiveness will lead to adoption in more applications of classification than the ones we have managed to explore.
+
+More importantly, our work highlights the limitation of common loss functions, and simple modification could lead to improvements even on well established state-of-the-art models. We hope these findings will encourage exploring and rethinking the loss function design beyond the commonly used cross-entropy and focal loss, as well as the simplest Poly-1 loss proposed in this work.
+
+# ACKNOWLEDGEMENTS
+
+We thank James Philbin, Doug Eck, Tsung-Yi Lin and the rest of Waymo Research and Google Brain teams for valuable feedback.
+
+# REPRODUCIBILITY STATEMENT
+
+Our experiments are based on public datasets and open source code repositories, shown in footnote 3-6. We do not tune any default training hyperparameters and only modify the loss functions, which are shown in Table 2-7. The proposed final formulation $L _ { \mathrm { P o l y - 1 } }$ requires one line of code change. Example code for $L _ { \mathrm { P o l y - 1 } } ^ { \mathrm { C E } }$ with softmax activation is shown below.
+
+def poly1_cross_entropy(logits, labels, epsilon): # epsilon $> = - 1$ . # pt, CE, and Poly1 have shape [batch]. pt $=$ tf.reduce_sum(labels $\star$ tf.nn.softmax(logits), axis $: = - 1$ ) CE $=$ tf.nn.softmax_cross_entropy_with_logits(labels, logits) Poly1 $=$ CE $^ +$ epsilon $^ { \star }$ (1 - pt) return Poly1
+
+Example code for $L _ { \mathrm { P o l y - 1 } } ^ { \mathrm { C E } }$ with $\alpha$ label smoothing is shown below.
+
+def poly1_cross_entropy(logits, labels, epsilon, alpha = 0.1): # epsilon $> = - 1$ . # one minus pt, CE, and Poly1 have shape [batch]. num_classes $=$ labels.get_shape().as_list()[-1] smooth labels $\cdot$ labels $^ { \star }$ (1-alpha) $^ +$ alpha/num classes one_minus_pt $=$ tf.reduce_sum( smooth labels $\star$ (1 - tf.nn.softmax(logits)), axis $\mathrel { \mathop : } = - 1$ ) CE_loss $=$ tf.keras.losses.CategoricalCrossentropy( from_logits $=$ True, label_smoothing $=$ alpha, reduction $= \prime$ none’) CE $=$ CE_loss(labels, logits) Poly1 $=$ CE $^ +$ epsilon $^ { \star }$ one minus pt return Poly1
+
+Example code for $L _ { \mathrm { P o l y - 1 } } ^ { \mathrm { F L } }$ with sigmoid activation is shown below.
+
+def poly1_focal_loss(logits, labels, epsilon, gamma=2.0): # epsilon $> = - 1$ . # p, pt, FL, and Poly1 have shape [batch, num of classes]. $\mathrm { ~ p ~ } =$ tf.math.sigmoid(logits) pt $=$ labels \* p + (1 - labels) $\star$ (1 - p) FL $=$ focal_loss(pt, gamma) Poly1 $=$ FL $^ +$ epsilon $^ { \star }$ tf.math.pow(1 - pt, gamma + 1) return Poly1
+
+Example code for $L _ { \mathrm { P o l y - 1 } } ^ { \mathrm { F L } }$ with $\cdot$ balance is shown below.
+
+def poly1_focal_loss(logits, labels, epsilon, gamma=2.0, alpha=0.25): # epsilon $> = - 1$ . # p, pt, FL, weight, and Poly1 have shape [batch, num of classes]. $\mathrm { ~ p ~ } =$ tf.math.sigmoid(logits) pt $=$ labels \* p + (1 - labels) $\star$ (1 - p) FL $=$ focal_loss(pt, gamma, alpha) weight $=$ labels \* alpha $\cdot$ (1 - labels) \* (1 - alpha) Poly1 $=$ FL $^ +$ epsilon $^ { \star }$ tf.math.pow(1 - pt, gamma + 1) $^ { \star }$ weight return Poly1
+
+# SUPPLEMENTARY MATERIAL
+
+# 7 PROOF OF THEOREM 1
+
+Theorem 1. For any small $\zeta > 0$ $\mid , \delta > 0 i f N > \log _ { 1 - \delta } \left( \zeta \cdot \delta \right)$ , then for any $p \in [ \delta , 1 ]$ , we have $| R _ { N } ( p ) | < \zeta$ and $| R _ { N } ^ { \prime } ( p ) | < \zeta$ .
+
+Proof.
+
+$$
+\begin{array} { l } { \displaystyle | R _ { N } ( p ) | = \sum _ { j = N + 1 } ^ { \infty } 1 / j ( 1 - p ) ^ { j } \le \sum _ { j = N + 1 } ^ { \infty } ( 1 - p ) ^ { j } = \frac { ( 1 - p ) ^ { N + 1 } } { p } \le \frac { ( 1 - \delta ) ^ { N + 1 } } { \delta } \le \frac { ( 1 - \delta ) ^ { N } } { \delta } \le \frac { ( 1 - \delta ) ^ { N } } { \delta } } \\ { \displaystyle | R _ { N } ^ { \prime } ( p ) | = \sum _ { j = N } ^ { \infty } ( 1 - p ) ^ { j } = \frac { ( 1 - p ) ^ { N } } { p } \le \frac { ( 1 - \delta ) ^ { N } } { \delta } } \end{array}
+$$
+
+# 8 ADJUSTING OTHER TRAINING HYPERPARAMETERS LEADS TO HIGHERGAIN.
+
+All the experiments shown in the main text are based on hyperparameters optimized for the baseline loss function, which actually puts PolyLoss at a disadvantage. Here we use weight decay rate for ResNet50 as an example. The default weight decay (1e-4) is optimized for cross-entropy loss. Adjusting the decay rate may reduce the model performance of cross-entropy loss but leads to much higher gain for PolyLoss $( + 0 . 8 \% )$ , which is better than the best accuracy $( 7 6 . 3 \% )$ trained using cross-entropy loss $( + 0 . 8 \% )$ .
+
+Table 8: ResNet50 performances on ImageNet-1K using different weight decays. †The default weight decay value is 1e-4.   
+
+<table><tr><td>Weight decay</td><td>1e-4t</td><td>2e-4</td><td>9e-5</td></tr><tr><td>Cross-entropy</td><td>76.3</td><td>76.3</td><td>76.1</td></tr><tr><td>PolyLoss</td><td>76.7</td><td>77.1</td><td>76.7</td></tr><tr><td>Improv. @ the same weight decay</td><td>+0.4</td><td>+0.8</td><td>+0.6</td></tr><tr><td>Improv. compared to the best LcE (76.3%)</td><td>+0.4</td><td>+0.8</td><td>+0.4</td></tr></table>
+
+Here, we add additional ablation studies on COCO detection using RetinaNet. The optimal $\gamma$ and $\alpha$ balance values for Focal loss are (2.0, 0.25) (Lin et al., 2017). Since all the hyperparameters are optimized with respect to the optimal $( \gamma , \alpha )$ values, we observe no improvement when tuning the leading polynomial term. We suspect the detection AP is at a ’local maximum’ of hyperparameters. By adjusting $( \gamma , \alpha )$ values, we show PolyLoss consistently outperforms the best Focal Loss AP (33.4), i.e., adjusting only $\gamma$ value (column 3, 4) or both $\gamma$ and $\alpha$ values (column 5, 6).
+
+Table 9: RetinaNet (ResNet50 backbone) performances on COCO using different Focal loss $( \gamma , \alpha )$ . †The default $( \gamma , \alpha )$ used in Focal loss is (2.0, 0.25).   
+
+<table><tr><td>Focal loss (γ,α)</td><td>(2.0,0.25)+</td><td>(1.5,0.25)</td><td>(2.5,0.25)</td><td>(1.5, 0.3)</td><td>(2.5, 0.15)</td></tr><tr><td>Focal loss</td><td>33.4</td><td>33.4</td><td>33.2</td><td>33.2</td><td>32.9</td></tr><tr><td>PolyLoss</td><td>33.4</td><td>33.6</td><td>33.7</td><td>33.8</td><td>33.8</td></tr><tr><td>Improv.@ same (γ,α)</td><td>0</td><td>+0.2</td><td>+0.5</td><td>+0.6</td><td>+0.9</td></tr><tr><td>Improv. compared to the best LFL (33.4)</td><td>0</td><td>+0.2</td><td>+0.3</td><td>+0.4</td><td>+0.4</td></tr></table>
+
+# 9 $L _ { \mathrm { D R O P } }$ WITH MORE HYPERPARAMETER TUNING
+
+For $L _ { \mathrm { D r o p } } \ ( \mathrm { N } = 2 )$ , besides adjusting the learning rate, we further tune the coefficient $( \alpha )$ of the second polynomial, similar to a prior work (Gonzalez & Miikkulainen, 2020b), and weight decay.
+
+$$
+L _ { \mathrm { D r o p } ^ { * } } = ( 1 - P _ { t } ) + \alpha ( 1 - P _ { t } ) ^ { 2 }
+$$
+
+Unlike Feng et al. (2020), where $\alpha = 0 . 5$ after dropping all higher-order polynomial, we find the optimal $\alpha = 8$ , while the optimal learning rate is the same as the default setting (0.1). This alone
+
+increases the accuracy to 70.9, which shows simply dropping polynomial terms is not enough and adjusting the polynomial coefficients is critical. Further tuning weight decay leads to less than $0 . 1 \%$ model quality improvement.
+
+Comparing to prior works (Gonzalez & Miikkulainen, 2020b; Feng et al., 2020), Poly-1 is more effective and only contains one hyperparameter. Tuning weight decay of Poly-1 further increases the accuracy while having less hyperparameters compared to $L _ { \mathrm { D r o p } ^ { * } }$ , shown in Table 10.   
+Table 10: Poly-1 outperforms $L _ { \mathbf { D r o p } ^ { * } }$ with hyperparameter tuning. Accuracy of ResNet50 on ImageNet-1K is reported.   
+
+<table><tr><td></td><td>Cross-entropy</td><td>Poly-1</td><td>Poly-1 (weight decay)</td><td>LDrop*</td></tr><tr><td>Accuracy</td><td>76.3</td><td>76.7</td><td>77.1</td><td>70.9</td></tr><tr><td>Num. of parameters</td><td>1</td><td>1</td><td>2</td><td>3</td></tr></table>
+
+# 10 COLLECTIVELY TUNING MULTIPLE POLYNOMIAL COEFFICIENTS
+
+Besides adjusting individual polynomial coefficients, in this section, we explore collectively tuning multiple polynomial coefficients in the PolyLoss framwork. In particular, we change the coefficients in the original cross-entropy loss from $1 / j$ (Equation 1) to exponential decay. Here, we define
+
+$$
+L _ { \exp } = \sum _ { j = 1 } ^ { 2 N } e ^ { - ( j - 1 ) / N } ( 1 - P _ { t } ) ^ { j }
+$$
+
+where we cut off the infinite sum at twice the decay factor $N$ . We performed 2D grid search on $N \in \{ 5 , 2 0 , 8 0 , 3 2 0 \}$ and learning rate $\in \ \{ 0 . 1 , 0 . 4 , 1 . 6 , 6 . 4 \}$ . The best accuracy is 72.3, where $N = 8 0$ and learning rate $= 1 . 6$ , shown in Table 11.
+
+Table 11: Comparing Poly-1 with exponential decay coefficients. Accuracy of ResNet50 on ImageNet-1K is reported.   
+
+<table><tr><td></td><td>Cross-entropy</td><td>Poly-1</td><td>Lexp</td></tr><tr><td>Accuracy</td><td>76.3</td><td>76.7</td><td>72.3</td></tr><tr><td>Num. of parameters</td><td>1</td><td>1</td><td>2</td></tr></table>
+
+Though Poly-1 is better than using $L _ { \mathrm { e x p } }$ , there are a lot more possibilities besides using exponential decay. We believe understanding how collectively tuning multiple coefficients affects the training is an important topic.
+
+# 11 COMPARING TO OTHER TRAINING TECHNIQUES
+
+As shown in recent works (He et al., 2019; Bello et al., 2021; Wightman et al., 2021), though independent novel training techniques often lead to sub $1 \%$ improvement, combining them could lead to significant overall improvements. To put things into perspective, Poly-1 achieves similar improvements as other commonly used training techniques, such as label smoothing and dropout on FC, shown in Table 12.
+
+Table 12: Comparing Poly-1 with common training techniques. Accuracy of ResNet50 on ImageNet-1K is reported.   
+
+<table><tr><td></td><td>Cross-entropy</td><td>Poly-1</td><td>Label smoothing</td><td>Dropout on FC</td></tr><tr><td>Accuracy</td><td>76.3</td><td>76.7</td><td>76.7</td><td>76.4</td></tr><tr><td>Num. of parameters</td><td>1</td><td>1</td><td>1</td><td>1</td></tr></table>
+
+Focal loss was first developed for single-stage detector RetinaNet to address strong class imbalance presented in object detection (Lin et al., 2017). Here, we provide an additional ablation study on how to systemically discover focal loss in the PolyLoss framework and investigate how the leading terms affect training in the presence of class imbalance.
+
+Rediscovering the concept of focal loss from crossentropy loss. Here, we take a step back and attempt to systematically rediscover the concept of focal loss via our PolyLoss framework. Focal loss is commonly used for training detection models. Coming up with such an insight to address the class imbalance issue in detection requires strong domain expertise. We start with the PolyLoss representation of crossentropy loss and improve it from the PolyLoss gradient perspective.
+
+![](images/255ffcbd40b4e5ea49ec9827e51a33beced0c990b233f64775f813264878a1f4.jpg)  
+Figure 8: Dropping leading polynomial terms can improve RetinaNet.
+
+We start with the cross-entropy loss and define PolyLoss $N$   
+$\begin{array} { r } { L _ { \mathrm { D r o p - f r o n t } } ^ { \bf { \bar { \alpha } } } = \sum _ { j = N + 1 } ^ { \infty } { 1 } / { j ( 1 - P _ { t } ) ^ { j } } = { L _ { \mathrm { C E } } } ^ { \bf { \bar { \alpha } } } = } \end{array}$ $\textstyle \sum _ { j = 1 } ^ { N } 1 / j ( 1 - P _ { t } ) ^ { j }$   
+terms $( 1 - P _ { t } )$ significantly improves both the detection AP and AR, see Figure 8. Dropping the first two polynomials ( $N = 2$ ) leads to the best RetinaNet performance, which is similar to setting $\gamma = 2$ in focal loss, i.e. focal loss $\gamma = 2$ pushes all the polynomial coefficients to the right by 2, shown in Figure 1 right, which is similar to truncating the first two polynomial terms.
+
+Leading polynomials cause overfitting to the majority class. In the PolyLoss framework, the leading polynomial of cross-entropy loss is a constant, shown in Equation 3. For binary classification, the leading gradient for each class is simply $N _ { b a c k g r o u n d } - N _ { o b j e c t }$ , where $N _ { b a c k g r o u n d }$ and $N _ { o b j e c t }$ are the counts of background and object instances in the training mini-batch. When the class counts are extremely imbalanced, the majority class will dominate the gradient which will lead to significant bias towards optimizing the majority class.
+
+![](images/032018303712609c9a17d5e9f51f4bd486e47ec728836a97b8e92f9b785b1126.jpg)  
+Figure 9: Dropping leading polynomials reduces overfitting to the majority class. $P _ { t }$ during RetinaNet training are plotted. Top: overall. Bottom left: background. Bottom right: foreground object. Dark blue curves represents $P _ { t }$ for cross-entropy loss. Blue curves represents dropping the first polynomial in the cross-entropy loss. Light blue curves represents dropping both the first and second polynomials in the cross-entropy loss.
+
+Dropping polynomials reduces the extremely confident prediction $P _ { t }$ , see Figure 9. To examine the composition of the overall prediction confidence, we also plot the $P _ { t }$ for background only and $P _ { t }$ for object only. Due to the extreme imbalance between the background and the object class, the overall $P _ { t }$ is dominated by the background only $P _ { t }$ . So reducing the overall $P _ { t }$ decreases the background $P _ { t }$ . On the other hand, reducing overfitting to the majority background class leads to more confident prediction $P _ { t }$ on the object class.
+
+# REFERENCES
+
+Irwan Bello, William Fedus, Xianzhi Du, Ekin D Cubuk, Aravind Srinivas, Tsung-Yi Lin, Jonathon Shlens, and Barret Zoph. Revisiting resnets: Improved training and scaling strategies. arXiv preprint arXiv:2103.07579, 2021.
+
+Samuel Rota Bulo, Gerhard Neuhold, and Peter Kontschieder. Loss max-pooling for semantic image segmentation. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 7082–7091. IEEE, 2017.
+
+Yin Cui, Menglin Jia, Tsung-Yi Lin, Yang Song, and Serge Belongie. Class-balanced loss based on effective number of samples. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 9268–9277, 2019.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009.
+
+Xianzhi Du, Tsung-Yi Lin, Pengchong Jin, Golnaz Ghiasi, Mingxing Tan, Yin Cui, Quoc V Le, and Xiaodan Song. Spinenet: Learning scale-permuted backbone for recognition and localization. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 11592–11601, 2020.
+
+Pedro F Felzenszwalb, Ross B Girshick, and David McAllester. Cascade object detection with deformable part models. In 2010 IEEE Computer society conference on computer vision and pattern recognition, pp. 2241–2248. IEEE, 2010.
+
+Lei Feng, Senlin Shu, Zhuoyi Lin, Fengmao Lv, Li Li, and Bo An. Can cross entropy loss be robust to label noise. In Proceedings of the 29th International Joint Conferences on Artificial Intelligence, pp. 2206–2212, 2020.
+
+Aritra Ghosh, Naresh Manwani, and PS Sastry. Making risk minimization tolerant to label noise. Neurocomputing, 160:93–107, 2015.
+
+Aritra Ghosh, Himanshu Kumar, and PS Sastry. Robust loss functions under label noise for deep neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 31, 2017.
+
+Santiago Gonzalez and Risto Miikkulainen. Improved training speed, accuracy, and data utilization through loss function optimization. In 2020 IEEE Congress on Evolutionary Computation (CEC), pp. 1–8. IEEE, 2020a.
+
+Santiago Gonzalez and Risto Miikkulainen. Optimizing loss functions through multivariate taylor polynomial parameterization. arXiv preprint arXiv:2002.00059, 2020b.
+
+Hamideh Hajiabadi, Diego Molla-Aliod, and Reza Monsefi. On extending neural networks with loss ensembles for text classification. arXiv preprint arXiv:1711.05170, 2017.
+
+Nikolaus Hansen and Andreas Ostermeier. Adapting arbitrary normal mutation distributions in evolution strategies: The covariance matrix adaptation. In Proceedings of IEEE international conference on evolutionary computation, pp. 312–317. IEEE, 1996.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Kaiming He, Georgia Gkioxari, Piotr Dollar, and Ross Girshick. Mask r-cnn. In ´ Proceedings of the IEEE international conference on computer vision, pp. 2961–2969, 2017.
+
+Tong He, Zhi Zhang, Hang Zhang, Zhongyue Zhang, Junyuan Xie, and Mu Li. Bag of tricks for image classification with convolutional neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 558–567, 2019.
+
+Alex H Lang, Sourabh Vora, Holger Caesar, Lubing Zhou, Jiong Yang, and Oscar Beijbom. Pointpillars: Fast encoders for object detection from point clouds. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 12697–12705, 2019.
+
+Hei Law and Jia Deng. Cornernet: Detecting objects as paired keypoints. In Proceedings of the European conference on computer vision (ECCV), pp. 734–750, 2018.
+
+Chuming Li, Xin Yuan, Chen Lin, Minghao Guo, Wei Wu, Junjie Yan, and Wanli Ouyang. Am-lfs: Automl for loss function search. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 8410–8419, 2019.
+
+Hao Li, Chenxin Tao, Xizhou Zhu, Xiaogang Wang, Gao Huang, and Jifeng Dai. Auto seg-loss: Searching metric surrogates for semantic segmentation. arXiv preprint arXiv:2010.07930, 2020.
+
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ European conference on computer vision, pp. 740–755. Springer, 2014.
+
+Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense ´ object detection. In Proceedings of the IEEE international conference on computer vision, pp. 2980–2988, 2017.
+
+Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, and Alexander C Berg. Ssd: Single shot multibox detector. In European conference on computer vision, pp. 21–37. Springer, 2016.
+
+Aditya Krishna Menon, Ankit Singh Rawat, Sashank J Reddi, and Sanjiv Kumar. Can gradient clipping mitigate label noise? In International Conference on Learning Representations, 2019.
+
+Kemal Oksuz, Baris Can Cam, Sinan Kalkan, and Emre Akbas. Imbalance problems in object detection: A review. IEEE transactions on pattern analysis and machine intelligence, 2020.
+
+Gabriel Pereyra, George Tucker, Jan Chorowski, Łukasz Kaiser, and Geoffrey Hinton. Regularizing neural networks by penalizing confident output distributions. arXiv preprint arXiv:1701.06548, 2017.
+
+Shaoshuai Shi, Chaoxu Guo, Li Jiang, Zhe Wang, Jianping Shi, Xiaogang Wang, and Hongsheng Li. Pv-rcnn: Point-voxel feature set abstraction for 3d object detection. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10529–10538, 2020.
+
+Abhinav Shrivastava, Abhinav Gupta, and Ross Girshick. Training region-based object detectors with online hard example mining. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 761–769, 2016.
+
+Pei Sun, Henrik Kretzschmar, Xerxes Dotiwalla, Aurelien Chouard, Vijaysai Patnaik, Paul Tsui, James Guo, Yin Zhou, Yuning Chai, Benjamin Caine, et al. Scalability in perception for autonomous driving: Waymo open dataset. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2446–2454, 2020.
+
+Pei Sun, Weiyue Wang, Yuning Chai, Gamaleldin Elsayed, Alex Bewley, Xiao Zhang, Christian Sminchisescu, and Dragomir Anguelov. Rsn: Range sparse net for efficient, accurate lidar 3d object detection. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2021.
+
+Kah-Kay Sung. Learning and example selection for object and pattern detection. 1996.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818–2826, 2016.
+
+Mingxing Tan and Quoc V Le. Efficientnetv2: Smaller models and faster training. In International Conference on Machine Learning, 2021.
+
+Mingxing Tan, Ruoming Pang, and Quoc V Le. Efficientdet: Scalable and efficient object detection. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 10781–10790, 2020.
+
+Andrew Tao, Karan Sapra, and Bryan Catanzaro. Hierarchical multi-scale attention for semantic segmentation. arXiv preprint arXiv:2005.10821, 2020.
+
+Paul Viola and Michael Jones. Rapid object detection using a boosted cascade of simple features. In Proceedings of the 2001 IEEE computer society conference on computer vision and pattern recognition. CVPR 2001, volume 1, pp. I–I. IEEE, 2001.
+
+Yisen Wang, Xingjun Ma, Zaiyi Chen, Yuan Luo, Jinfeng Yi, and James Bailey. Symmetric cross entropy for robust learning with noisy labels. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 322–330, 2019.
+
+Ross Wightman, Hugo Touvron, and Herve J ´ egou. Resnet strikes back: An improved training ´ procedure in timm. arXiv preprint arXiv:2110.00476, 2021.
+
+Haowen Xu, Hao Zhang, Zhiting Hu, Xiaodan Liang, Ruslan Salakhutdinov, and Eric Xing. Autoloss: Learning discrete schedules for alternate optimization. arXiv preprint arXiv:1810.02442, 2018.
+
+Zhilu Zhang and Mert R Sabuncu. Generalized cross entropy loss for training deep neural networks with noisy labels. arXiv preprint arXiv:1805.07836, 2018.
+
+Guangxiang Zhao, Wenkai Yang, Xuancheng Ren, Lei Li, and Xu Sun. Well-classified examples are underestimated in classification with deep neural networks. arXiv preprint arXiv:2110.06537, 2021.
+
+Barret Zoph, Golnaz Ghiasi, Tsung-Yi Lin, Yin Cui, Hanxiao Liu, Ekin D Cubuk, and Quoc V Le. Rethinking pre-training and self-training. arXiv preprint arXiv:2006.06882, 2020.

parse/dev/tq_J_MqB3UB/tq_J_MqB3UB.md

@@ -0,0 +1,337 @@
+# Diverse Weight Averaging for Out-of-Distribution Generalization
+
+Alexandre Ramé1,\*, Matthieu Kirchmeyer1,2,\*   
+Thibaud Rahier2, Alain Rakotomamonjy2,4, Patrick Gallinari1,2, Matthieu Cord1,3   
+1Sorbonne Université, CNRS, ISIR, F-75005 Paris, France 2Criteo AI Lab, Paris, France 3Valeo.ai, Paris, France 4Université de Rouen, LITIS, France \*Equal contribution
+
+# Abstract
+
+Standard neural networks struggle to generalize under distribution shifts in computer vision. Fortunately, combining multiple networks can consistently improve out-of-distribution generalization. In particular, weight averaging (WA) strategies were shown to perform best on the competitive DomainBed benchmark; they directly average the weights of multiple networks despite their nonlinearities. In this paper, we propose Diverse Weight Averaging (DiWA), a new WA strategy whose main motivation is to increase the functional diversity across averaged models. To this end, DiWA averages weights obtained from several independent training runs: indeed, models obtained from different runs are more diverse than those collected along a single run thanks to differences in hyperparameters and training procedures. We motivate the need for diversity by a new bias-variance-covariancelocality decomposition of the expected error, exploiting similarities between WA and standard functional ensembling. Moreover, this decomposition highlights that WA succeeds when the variance term dominates, which we show occurs when the marginal distribution changes at test time. Experimentally, DiWA consistently improves the state of the art on DomainBed without inference overhead.
+
+# 1 Introduction
+
+Learning robust models that generalize well is critical for many real-world applications [1, 2]. Yet, the classical Empirical Risk Minimization (ERM) lacks robustness to distribution shifts [3, 4, 5]. To improve out-of-distribution (OOD) generalization in classification, several recent works proposed to train models simultaneously on multiple related but different domains [6]. Though theoretically appealing, domain-invariant approaches [7] either underperform [8, 9] or only slightly improve [10, 11] ERM on the reference DomainBed benchmark [12]. The state-of-the-art strategy on DomainBed is currently to average the weights obtained along a training trajectory [13]. [14] argues that this weight averaging (WA) succeeds in OOD because it finds solutions with flatter loss landscapes.
+
+In this paper, we show the limitations of this flatness-based analysis and provide a new explanation for the success of WA in OOD. It is based on WA’s similarity with ensembling [15], a well-known strategy to improve robustness [16, 17], that averages the predictions from various models. Based on [18], we present a bias-variance-covariance-locality decomposition of WA’s expected error. It contains four terms: first the bias that we show increases under shift in label posterior distributions (i.e., correlation shift [19]); second, the variance that we show increases under shift in input marginal distributions (i.e., diversity shift [19]); third, the covariance that decreases when models are diverse; finally, a locality condition on the weights of averaged models.
+
+Based on this analysis, we aim at obtaining diverse models whose weights are averageable with our Diverse Weight Averaging (DiWA) approach. In practice, DiWA averages in weights the models obtained from independent training runs that share the same initialization. The motivation is that those models are more diverse than those obtained along a single run [20, 21]. Yet, averaging the weights of independently trained networks with batch normalization [22] and ReLU layers [23] may be counter-intuitive. Such averaging is efficient especially when models can be connected linearly in the weight space via a low loss path. Interestingly, this linear mode connectivity property [24] was empirically validated when the runs start from a shared pretrained initialization [25]. This insight is at the heart of DiWA but also of other recent works [26, 27, 28], as discussed in Section 6.
+
+In summary, our main contributions are the following:
+
+• We propose a new theoretical analysis of WA for OOD based on a bias-variance-covariancelocality decomposition of its expected error (Section 2). By relating correlation shift to its bias and diversity shift to its variance, we show that WA succeeds under diversity shift. • We empirically tackle the covariance term by increasing the diversity across models averaged in weights. In our DiWA approach, we decorrelate their training procedures: in practice, these models are obtained from independent runs (Section 3). We then empirically validate that diversity improves OOD performance (Section 4) and show that DiWA is state of the art on all real-world datasets from the DomainBed benchmark [12] (Section 5).
+
+# 2 Theoretical insights
+
+Under the setting described in Section 2.1, we introduce WA in Section 2.2 and decompose its expected OOD error in Section 2.3. Then, we separately consider the four terms of this bias-variancecovariance-locality decomposition in Section 2.4. This theoretical analysis will allow us to better understand when WA succeeds, and most importantly, how to improve it empirically in Section 3.
+
+# 2.1 Notations and problem definition
+
+Notations. We denote $\mathcal { X }$ the input space of images, $\mathcal { V }$ the label space and $\ell : \mathcal { V } ^ { 2 } \to \mathbb { R } _ { + }$ a loss function. $S$ is the training (source) domain with distribution $p _ { S }$ , and $T$ is the test (target) domain with distribution $p _ { T }$ . For simplicity, we will indistinctly use the notations $p _ { S }$ and $p _ { T }$ to refer to the joint, posterior and marginal distributions of $( X , Y )$ . We note $f _ { S } , f _ { T } : \mathcal { X } \to \mathcal { Y }$ the source and target labeling functions. We assume that there is no noise in the data: then $f _ { S }$ is defined on $\mathcal { X } _ { S } \ \triangleq \ \{ x \ \in \ \mathcal { X } / p _ { S } ( x ) \ > \ 0 \}$ by $\forall ( x , y ) \sim p _ { S } , f _ { S } ( x ) = y$ and similarly $f _ { T }$ is defined on $\mathcal { X } _ { T } \triangleq \{ x \in \mathcal { X } / p _ { T } ( x ) > 0 \}$ by $\forall ( x , y ) \sim p _ { T } , f _ { T } ( x ) = y$ .
+
+Problem. We consider a neural network (NN) $f ( \cdot , \theta ) : \mathcal { X } \to \mathcal { Y }$ made of a fixed architecture $f$ with weights $\theta$ . We seek $\theta$ minimizing the target generalization error:
+
+$$
+\mathcal { E } _ { T } ( \theta ) = \mathbb { E } _ { ( x , y ) \sim p _ { T } } [ \ell ( f ( x , \theta ) , y ) ] .
+$$
+
+$f ( \cdot , \theta )$ should approximate $f _ { T }$ on $\mathcal { X } _ { T }$ . However, this is complex in the OOD setup because we only have data from domain $S$ in training, related yet different from $T$ . The differences between $S$ and $T$ are due to distribution shifts (i.e., the fact that $p _ { S } ( X , Y ) \neq p _ { T } ( X , Y ) )$ which are decomposed per [19] into diversity shift (a.k.a. covariate shift), when marginal distributions differ (i.e., $p _ { S } ( { \bar { X } } ) \not = { \bar { p } } _ { T } ( X ) )$ , and correlation shift (a.k.a. concept shift), when posterior distributions differ (i.e., $p _ { S } ( Y | X ) \neq$ $p _ { T } ( Y | X )$ and $f _ { S } \neq f _ { T } ,$ ). The weights are typically learned on a training dataset $d _ { S }$ from $S$ (composed of $n _ { S }$ i.i.d. samples from $p _ { S } ( X , Y ) )$ with a configuration $c$ , which contains all other sources of randomness in learning (e.g., initialization, hyperparameters, training stochasticity, epochs, etc.). We call $l _ { S } = \{ d _ { S } , c \}$ a learning procedure on domain $S$ , and explicitly write $\theta ( l _ { S } )$ to refer to the weights obtained after stochastic minimization of $1 / n _ { S } \sum _ { ( x , y ) \in d _ { S } } \ell ( f ( x , \theta ) , y )$ w.r.t. $\theta$ under $l _ { S }$ .
+
+# 2.2 Weight averaging for OOD and limitations of current analysis
+
+Weight averaging. We study the benefits of combining $M$ individual member weights $\{ \theta _ { m } \} _ { m = 1 } ^ { M } \triangleq$ $\{ \theta ( l _ { S } ^ { ( m ) } ) \} _ { m = 1 } ^ { M }$ obtained from $M$ (potentially correlated) identically distributed (i.d.) learning procedures , {l (m)S }Mm=1 . Under conditions discussed in Section 3.2, these $M$ weights can be averaged despite nonlinearities in the architecture $f$ . Weight averaging (WA) [13], defined as:
+
+$$
+\begin{array} { r } { f _ { \mathrm { { W A } } } \triangleq f ( \cdot , \theta _ { \mathrm { { W A } } } ) , \mathrm { { w h e r e } } \theta _ { \mathrm { { W A } } } \triangleq \theta _ { \mathrm { { W A } } } ( L _ { S } ^ { M } ) \triangleq 1 / M \sum _ { m = 1 } ^ { M } \theta _ { m } , } \end{array}
+$$
+
+is the state of the art [14, 29] on DomainBed [12] when the weights $\lbrace \theta _ { m } \rbrace _ { m = 1 } ^ { M }$ are sampled along a single training trajectory (a description we refine in Remark 1 from Appendix C.2).
+
+Limitations of the flatness-based analysis. To explain this success, Cha et al. [14] argue that flat minima generalize better; indeed, WA flattens the loss landscape. Yet, as shown in Appendix B, this analysis does not fully explain WA’s spectacular results on DomainBed. First, flatness does not act on distribution shifts thus the OOD error is uncontrolled with their upper bound (see Appendix B.1). Second, this analysis does not clarify why WA outperforms Sharpness-Aware Minimizer (SAM) [30] for OOD generalization, even though SAM directly optimizes flatness (see Appendix B.2). Finally, it does not justify why combining WA and SAM succeeds in IID [31] yet fails in OOD (see Appendix B.3). These observations motivate a new analysis of WA; we propose one below that better explains these results.
+
+# 2.3 Bias-variance-covariance-locality decomposition
+
+We now introduce our bias-variance-covariance-locality decomposition which extends the biasvariance decomposition [32] to WA. In the rest of this theoretical section, $\ell$ is the Mean Squared Error for simplicity: yet, our results may be extended to other losses as in [33]. In this case, the expected error of a model with weights $\theta ( l _ { S } )$ w.r.t. the learning procedure $l _ { S }$ was decomposed in [32] into:
+
+$$
+\begin{array} { r } { \mathbb { E } _ { l _ { S } } \mathcal { E } _ { T } ( \theta ( l _ { S } ) ) = \mathbb { E } _ { ( x , y ) \sim p _ { T } } [ \mathrm { b i a s } ^ { 2 } ( x , y ) + \mathrm { v a r } ( x ) ] , } \end{array}
+$$
+
+where $\mathrm { b i a s } ( x , y ) , \mathrm { v a r } ( x )$ are the bias and variance of the considered model w.r.t. a sample $( x , y )$ , defined later in Equation (BVCL). To decompose WA’s error, we leverage the similarity (already highlighted in [13]) between WA and functional ensembling (ENS) [15, 34], a more tra$\begin{array} { r } { f _ { \mathrm { E N S } } \triangleq f _ { \mathrm { E N S } } ( \cdot , \{ \theta _ { m } \} _ { m = 1 } ^ { M } ) \triangleq 1 / M \sum _ { m = 1 } ^ { M } f ( \cdot , \theta _ { m } ) } \end{array}$ More precisely, ENS avera. Lemma 1 establishes that the weight space. $f _ { \mathrm { W A } }$ he predictions,is a first-order $f _ { \mathrm { E N S } }$ $\lbrace \theta _ { m } \rbrace _ { m = 1 } ^ { M }$
+
+Lemma 1 (WA and ENS. Proof in Appendix C.1. Adapted from [13, 28].). Given $\lbrace \theta _ { m } \rbrace _ { m = 1 } ^ { M }$ with learning procedures $L _ { S } ^ { M } \triangleq \{ l _ { S } ^ { ( m ) } \} _ { m = 1 } ^ { M }$ . Denoting $\Delta _ { L _ { S } ^ { M } } = \mathrm { m a x } _ { m = 1 } ^ { M } \| \theta _ { m } - \theta _ { W A } \| _ { 2 } , \forall ( x , y ) \in \mathcal { X } \times \mathcal { Y }$
+
+$$
+f _ { W A } ( x ) = f _ { E N S } ( x ) + O ( \Delta _ { L _ { S } ^ { M } } ^ { 2 } ) a n d \ell ( f _ { W A } ( x ) , y ) = \ell ( f _ { E N S } ( x ) , y ) + O ( \Delta _ { L _ { S } ^ { M } } ^ { 2 } ) .
+$$
+
+This similarity is useful since Equation (BV) was extended into a bias-variance-covariance decomposition for ENS in [18, 35]. We can then derive the following decomposition of WA’s expected test error. To take into account the $M$ averaged weights, the expectation is over the joint distribution describing the $M$ identically distributed (i.d.) learning procedures $L _ { S } ^ { M } \triangleq \{ l _ { S } ^ { ( m ) } \} _ { m = 1 } ^ { \tilde { M } }$ .
+
+Proposition 1 (Bias-variance-covariance-locality decomposition of the expected generalization error of WA in OOD. Proof in Appendix C.2.). Denoting $\hat { f } _ { S } ( x ) = \mathbb { E } _ { l _ { S } } [ f ( x , \cdot \theta ( l _ { S } ) ) ]$ , under identically distributed learning procedures $L _ { S } ^ { M } \triangleq \{ l _ { S } ^ { ( m ) } \} _ { m = 1 } ^ { M }$ S , the expected generalization error on domain $T$ of $\begin{array} { r } { \theta _ { W A } ( L _ { S } ^ { M } ) \triangleq \frac { 1 } { M } \sum _ { m = 1 } ^ { M } \theta _ { m } } \end{array}$ over the joint distribution of $L _ { S } ^ { M }$ is:
+
+$$
+\begin{array} { r l } & { \mathbb { E } _ { L _ { S } ^ { \scriptscriptstyle M } } \mathcal { E } _ { T } \big ( \theta _ { W \mathrm { A } } ( L _ { S } ^ { \scriptscriptstyle M } ) \big ) = \mathbb { E } _ { ( x , y ) \sim p _ { T } } \Big [ \mathrm { b i a s } ^ { 2 } ( x , y ) + \frac { 1 } { M } \mathrm { v a r } ( x ) + \frac { M - 1 } { M } \mathrm { c o v } ( x ) \Big ] + O ( \bar { \Delta } ^ { 2 } ) , } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ &  \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \end{array}
+$$
+
+cov is the prediction covariance between two member models whose weights are averaged. The locality term $\bar { \Delta } ^ { 2 }$ is the expected squared maximum distance between weights and their average.
+
+Equation (BVCL) decomposes the OOD error of WA into four terms. The bias is the same as that of each of its i.d. members. WA’s variance is split into the variance of each of its i.d. members divided by $M$ and a covariance term. The last locality term constrains the weights to ensure the validity of our approximation. In conclusion, combining $M$ models divides the variance by $M$ but introduces the covariance and locality terms which should be controlled along bias to guarantee low OOD error.
+
+# 2.4 Analysis of the bias-variance-covariance-locality decomposition
+
+We now analyze the four terms in Equation (BVCL). We show that bias dominates under correlation shift (Section 2.4.1) and variance dominates under diversity shift (Section 2.4.2). Then, we discuss a trade-off between covariance, reduced with diverse models (Section 2.4.3), and the locality term, reduced when weights are similar (Section 2.4.4). This analysis shows that WA is effective against diversity shift when $M$ is large and when its members are diverse but close in the weight space.
+
+# 2.4.1 Bias and correlation shift (and support mismatch)
+
+We relate OOD bias to correlation shift [19] under Assumption 1, where $\bar { f } _ { S } ( x ) \triangleq \mathbb { E } _ { l _ { S } } [ f ( x , \theta ( l _ { S } ) ) ]$ . As discussed in Appendix C.3.2, Assumption 1 is reasonable for a large NN trained on a large dataset representative of the source domain $S$ . It is relaxed in Proposition 4 from Appendix C.3.
+
+Assumption 1 (Small IID bias). $\exists \epsilon > 0$ small s.t. $\forall x \in \mathcal { X } _ { S } , | f _ { S } ( x ) - \bar { f } _ { S } ( x ) | \leq \epsilon .$
+
+Proposition 2 (OOD bias and correlation shift. Proof in Appendix C.3). With a bounded difference between the labeling functions $f _ { T } - f _ { S }$ on $\mathcal { X } _ { T } \cap \mathcal { X } _ { S }$ , under Assumption $\cdot$ , the bias on domain $T$ is:
+
+$$
+\begin{array} { r l } & { \mathbb { E } _ { ( x , y ) \sim p _ { T } } [ \mathrm { b i a s } ^ { 2 } ( x , y ) ] = C o r r e l a t i o n \ s h i f t + S u p p o r t \ m i s m a t c h + O ( \epsilon ) , } \\ & { w h e r e \ C o r r e l a t i o n \ s h i f t = \displaystyle \int _ { \mathbb { X } _ { T } \cap \mathbb { X } _ { S } } \big ( f _ { T } ( x ) - f _ { S } ( x ) \big ) ^ { 2 } p _ { T } ( x ) d x , } \\ & { a n d S u p p o r t \ m i s m a t c h = \displaystyle \int _ { \mathbb { X } _ { T } \setminus \mathbb { X } _ { S } } \big ( f _ { T } ( x ) - \bar { f } _ { S } ( x ) \big ) ^ { 2 } p _ { T } ( x ) d x . } \end{array}
+$$
+
+We analyze the first term by noting that $f _ { T } ( x ) \triangleq \mathbb { E } _ { p _ { T } } [ Y | X = x ]$ and $f _ { S } ( x ) \triangleq \mathbb { E } _ { p _ { S } } [ Y | X = x ]$ , $\forall x \in \mathcal { X } _ { T } \cap \mathcal { X } _ { S }$ . This expression confirms that our correlation shift term measures shifts in posterior distributions between source and target, as in [19]. It increases in presence of spurious correlations: e.g., on ColoredMNIST [8] where the color/label correlation is reversed at test time. The second term is caused by support mismatch between source and target. It was analyzed in [36] and shown irreducible in their “No free lunch for learning representations for DG”. Yet, this term can be tackled if we transpose the analysis in the feature space rather than the input space. This motivates encoding the source and target domains into a shared latent space, e.g., by pretraining the encoder on a task with minimal domain-specific information as in [36].
+
+This analysis explains why WA fails under correlation shift, as shown on ColoredMNIST in Appendix H. Indeed, combining different models does not reduce the bias. Section 2.4.2 explains that WA is however efficient against diversity shift.
+
+# 2.4.2 Variance and diversity shift
+
+Variance is known to be large in OOD [5] and to cause a phenomenon named underspecification, when models behave differently in OOD despite similar test IID accuracy. We now relate OOD variance to diversity shift [19] in a simplified setting. We fix the source dataset $d _ { S }$ (with input support $X _ { d _ { S } }$ ), the target dataset $d _ { T }$ (with input support $X _ { d _ { T } }$ ) and the network’s initialization. We get a closed-form expression for the variance of $f$ over all other sources of randomness under Assumptions 2 and 3.
+
+Assumption 2 (Kernel regime). $f$ is in the kernel regime [37, 38].
+
+This states that $f$ behaves as a Gaussian process (GP); it is reasonable if $f$ is a wide network [37, 39]. The corresponding kernel $K$ is the neural tangent kernel (NTK) [37] depending only on the initialization. GPs are useful because their variances have a closed-form expression (Appendix C.4.1). To simplify the expression of variance, we now make Assumption 3.
+
+Assumption 3 (Constant norm and low intra-sample similarity on $d _ { S }$ ). $\exists ( \lambda _ { S } , \epsilon )$ with $0 \le \epsilon \ll \lambda _ { S }$ such that $\forall x _ { S } \in X _ { d _ { S } } , K ( x _ { S } , x _ { S } ) = \lambda _ { S }$ and $\mathsf { \bar { H } } x _ { S } ^ { \prime } \neq x _ { S } \in \dot { X } _ { d s } , | K ( x _ { S } , x _ { S } ^ { \prime } ) | \leq \epsilon$ .
+
+This states that training samples have the same norm (following standard practice [39, 40, 41, 42]) and weakly interact [43, 44]. This assumption is further discussed and relaxed in Appendix C.4.2. We are now in a position to relate variance and diversity shift when $\epsilon  0$ .
+
+Proposition 3 (OOD variance and diversity shift. Proof in Appendix C.4). Given $f$ trained on source dataset $d _ { S }$ (of size $n _ { S }$ ) with NTK $K$ , under Assumptions 2 and $^ 3$ , the variance on dataset $d _ { T }$ is:
+
+$$
+\mathbb { E } _ { x _ { T } \in X _ { d _ { T } } } [ \mathrm { v a r } ( x _ { T } ) ] = \frac { n _ { S } } { 2 \lambda _ { S } } M M D ^ { 2 } ( X _ { d _ { S } } , X _ { d _ { T } } ) + \lambda _ { T } - \frac { n _ { S } } { 2 \lambda _ { S } } \beta _ { T } + O ( \epsilon ) ,
+$$
+
+where MMD is the empirical Maximum Mean Discrepancy in the RKHS of $K ^ { 2 } ( x , y ) \ =$ $( K ( x , y ) ) ^ { 2 } ; \lambda _ { T } \triangleq \mathbb { E } _ { x _ { T } \in X _ { d _ { T } } } K ( x _ { T } , x _ { T } )$ and $\beta _ { T } \ \triangleq \ \mathbb { E } _ { ( x _ { T } , x _ { T } ^ { \prime } ) \in X _ { d _ { T } } ^ { 2 } , x _ { T } \neq x _ { T } ^ { \prime } } K ^ { 2 } ( x _ { T } , x _ { T } ^ { \prime } )$ are the empirical mean similarities respectively measured between identical $( w . r . t . \ K )$ and different $( w . r . t . ~ K ^ { 2 } )$ samples averaged over $X _ { d _ { T } }$ .
+
+The MMD empirically estimates shifts in input marginals, i.e., between $p _ { S } ( X )$ and $p _ { T } ( X )$ . Our expression of variance is thus similar to the diversity shift formula in [19]: MMD replaces the $L _ { 1 }$ divergence used in [19]. The other terms, $\lambda _ { T }$ and $\beta _ { T }$ , both involve internal dependencies on the target dataset $d _ { T }$ : they are constants w.r.t. $X _ { d _ { T } }$ and do not depend on distribution shifts. At fixed $d _ { T }$ and under our assumptions, Equation (4) shows that variance on $d _ { T }$ decreases when $X _ { d _ { S } }$ and $X _ { d _ { T } }$ are closer (for the MMD distance defined by the kernel $K ^ { 2 }$ ) and increases when they deviate. Intuitively, the further $X _ { d _ { T } }$ is from $X _ { d _ { S } }$ , the less the model’s predictions on $X _ { d _ { T } }$ are constrained after fitting $d _ { S }$
+
+This analysis shows that WA reduces the impact of diversity shift as combining $M$ models divides the variance per $M$ . This is a strong property achieved without requiring data from the target domain.
+
+# 2.4.3 Covariance and diversity
+
+The covariance term increases when the predictions of $\{ f ( \cdot , \theta _ { m } ) \} _ { m = 1 } ^ { M }$ are correlated. In the worst case where all predictions are identical, covariance equals variance and WA is no longer beneficial. On the other hand, the lower the covariance, the greater the gain of WA over its members; this is derived by comparing Equations (BV) and (BVCL), as detailed in Appendix C.5. It motivates tackling covariance by encouraging members to make different predictions, thus to be functionally diverse. Diversity is a widely analyzed concept in the ensemble literature [15], for which numerous measures have been introduced [45, 46, 47]. In Section 3, we aim at decorrelating the learning procedures to increase members’ diversity and reduce the covariance term.
+
+# 2.4.4 Locality and linear mode connectivity
+
+To ensure that WA approximates ENS, the last locality term $O ( \bar { \Delta } ^ { 2 } )$ constrains the weights to be close. Yet, the covariance term analyzed in Section 2.4.3 is antagonistic, as it motivates functionally diverse models. Overall, to reduce WA’s error in OOD, we thus seek a good trade-off between diversity and locality. In practice, we consider that the main goal of this locality term is to ensure that the weights are averageable despite the nonlinearities in the NN such that WA’s error does not explode. This is why in Section 3, we empirically relax this locality constraint and simply require that the weights are linearly connectable in the loss landscape, as in the linear mode connectivity [24]. We empirically verify later in Figure 1 that the approximation $f _ { \mathrm { W A } } \approx f _ { \mathrm { E N S } }$ remains valid even in this case.
+
+# 3 DiWA: Diverse Weight Averaging
+
+# 3.1 Motivation: weight averaging from different runs for more diversity
+
+Limitations of previous WA approaches. Our analysis in Sections 2.4.1 and 2.4.2 showed that the bias and the variance terms are mostly fixed by the distribution shifts at hand. In contrast, the covariance term can be reduced by enforcing diversity across models (Section 2.4.3) obtained from learning procedur es {l (m)S }Mm=1 · Yet, previous methods [14, 29] only average weights obtained along a single run. This corresponds to highly correlated procedures sharing the same initialization, hyperparameters, batch orders, data augmentations and noise, that only differ by the number of training steps. The models are thus mostly similar: this does not leverage the full potential of WA.
+
+DiWA. Our Diverse Weight Averaging approach seeks to reduce the OOD expected error in Equation (BVCL) by decreasing covariance across predictions: DiWA decorrelates the learning procedures {l (m)S }Mm=1 . Our weights are obtained from $M \gg 1$ different runs, with diverse learning procedures:
+
+Require: $\theta _ { 0 }$ pretrained encoder and initialized classifier; $\{ h _ { m } \} _ { m = 1 } ^ { H }$ hyperparameter configurations.   
+Training: $\forall m = 1$ to $H , \theta _ { m } \triangleq { \mathrm { F i n e T u n e } } ( \theta _ { 0 } , h _ { m } )$   
+Weight selection: Uniform: $\overline { { \mathcal { M } } } = \{ 1 , \cdots , H \}$ .   
+Res R $\lbrace \theta _ { m } \rbrace _ { m = 1 } ^ { H }$ by decreasing $\mathrm { V a l A c c } ( \theta _ { m } )$ . $M \gets \emptyset$ . $m = 1$ $H$ If $\mathrm { V a l A c c } ( \theta _ { \mathcal { M } \cup \{ m \} } ) \geq \mathrm { V a l A c c } ( \theta _ { \mathcal { M } } )$ ${ \mathcal { M } } \gets { \mathcal { M } } \cup \{ m \}$   
+Inference: with $f ( \cdot , \theta _ { \mathcal { M } } )$ , where $\begin{array} { r } { \theta _ { \mathcal { M } } = \sum _ { m \in \mathcal { M } } \theta _ { m } / | \mathcal { M } | } \end{array}$ .
+
+these have different hyperparameters (learning rate, weight decay and dropout probability), batch orders, data augmentations (e.g., random crops, horizontal flipping, color jitter, grayscaling), stochastic noise and number of training steps. Thus, the corresponding models are more diverse on domain $T$ per [21] and reduce the impact of variance when $M$ is large. However, this may break the locality requirement analyzed in Section 2.4.4 if the weights are too distant. Empirically, we show that DiWA works under two conditions: shared initialization and mild hyperparameter ranges.
+
+# 3.2 Approach: shared initialization, mild hyperparameter search and weight selection
+
+Shared initialization. The shared initialization condition follows [25]: when models are fine-tuned from a shared pretrained model, their weights can be connected along a linear path where error remains low [24]. Following standard practice on DomainBed [12], our encoder is pretrained on ImageNet [48]; this pretraining is key as it controls the bias (by defining the feature support mismatch, see Section 2.4.1) and variance (by defining the kernel $K$ , see Appendix C.4.4). Regarding the classifier initialization, we test two methods. The first is the random initialization, which may distort the features [49]. The second is Linear Probing (LP) [49]: it first learns the classifier (while freezing the encoder) to serve as a shared initialization. Then, LP fine-tunes the encoder and the classifier together in the $M$ subsequent runs; the locality term is smaller as weights remain closer (see [49]).
+
+Mild hyperparameter search. As shown in Figure 5, extreme hyperparameter ranges lead to weights whose average may perform poorly. Indeed, weights obtained from extremely different hyperparameters may not be linearly connectable; they may belong to different regions of the loss landscape. In our experiments, we thus use the mild search space defined in Table 7, first introduced in SWAD [14]. These hyperparameter ranges induce diverse models that are averageable in weights.
+
+Weight selection. The last step of our approach (summarized in Algorithm 1) is to choose which weights to average among those available. We explore two simple weight selection protocols, as in [28]. The first uniform equally averages all weights; it is practical but may underperform when some runs are detrimental. The second restricted (greedy in [28]) solves this drawback by restricting the number of selected weights: weights are ranked in decreasing order of validation accuracy and sequentially added only if they improve DiWA’s validation accuracy.
+
+In the following sections, we experimentally validate our theory. First, Section 4 confirms our findings on the OfficeHome dataset [50] where diversity shift dominates [19] (see Appendix E.2 for a similar analysis on PACS [51]). Then, Section 5 shows that DiWA is state of the art on DomainBed [12].
+
+# 4 Empirical validation of our theoretical insights
+
+We consider several collections of weights $\lbrace \theta _ { m } \rbrace _ { m = 1 } ^ { M }$ $( 2 \leq M < 1 0 )$ trained on the “Clipart”, “Product” and “Photo” domains from OfficeHome [50] with a shared random initialization and mild hyperparameter ranges. These weights are first indifferently sampled from a single run (every 50 batches) or from different runs. They are evaluated on “Art”, the fourth domain from OfficeHome.
+
+WA vs. ENS. Figure 1 validates Lemma 1 and that $f _ { \mathbf { W A } } \approx f _ { \mathbf { E N S } }$ . More precisely, $f _ { \mathrm { W A } }$ slightly but consistently improves $f _ { \mathrm { E N S } }$ : we discuss this in Appendix D. Moreover, a larger $M$ improves the
+
+![](images/aa85ce32f560086ba3e663d330c23d0278377bd531b612fae2082ff26ac0f248.jpg)  
+Figure 1: Each dot displays the accuracy (") of weight averaging (WA) vs. accuracy $( \uparrow )$ of prediction averaging (ENS) for $M$ models.
+
+![](images/79497adcd65df5c314905b300a57757280a4846a86c3e4c67685368e5337fcf8.jpg)  
+Figure 2: Each dot displays the accuracy (") gain of WA over its members vs. the prediction diversity [46] ( ) for $M$ models.
+
+results; in accordance with Equation (BVCL), this motivates averaging as many weights as possible.   
+In contrast, large $M$ is computationally impractical for ENS at test time, requiring $M$ forwards.
+
+Diversity and accuracy. We validate in Figure 2 that $f _ { \mathrm { W A } }$ benefits from diversity. Here, we measure diversity with the ratio-error [46], i.e., the ratio $N _ { \mathrm { d i f f } } / N _ { \mathrm { s i m u l } }$ between the number of different errors $N _ { \mathrm { d i f f } }$ and of simultaneous errors $N _ { \mathrm { s i m u l } }$ in test for a pair in $\{ f ( \cdot , \theta _ { m } ) \} _ { m = 1 } ^ { M }$ . A higher average over the $\binom { M } { 2 }$ pairs means that members are less likely to err on the same inputs. Specifically, the gain of $\operatorname { A c c } ( \theta _ { \operatorname { W A } } )$ over the mean individual accuracy $\begin{array} { r } { \frac { 1 } { M } \sum _ { m = 1 } ^ { M } \operatorname { A c c } ( \theta _ { m } ) } \end{array}$ increases with diversity. Moreover, this phenomenon intensifies for larger $M$ : the linear regression’s slope (i.e., the accuracy gain per unit of diversity) increases with $M$ . This is consistent with the $( M - 1 ) / M$ factor of $\operatorname { c o v } ( x )$ in Equation (BVCL), as further highlighted in Appendix E.1.2. Finally, in Appendix E.1.1, we show that the conclusion also holds with CKAC [47], another established diversity measure.
+
+Increasing diversity thus accuracy via different runs. Now we investigate the difference between sampling the weights from a single run or from different runs. Figure 3 first shows that diversity increases when weights come from different runs. Second, in Figure 4, this is reflected on the accuracies in OOD. Here, we rank by validation accuracy the 60 weights obtained (1) from 60 different runs and (2) along 1 well-performing run. We then consider the WA of the top $M$ weights as $M$ increases from 1 to 60. Both have initially the same performance and improve with $M$ ; yet, WA of weights from different runs gradually outperforms the single-run WA. Finally, Figure 5 shows that this holds only for mild hyperparameter ranges and with a shared initialization. Otherwise, when hyperparameter distributions are extreme (as defined in Table 7) or when classifiers are not similarly initialized, DiWA may perform worse than its members due to a violation of the locality condition. These experiments confirm that diversity is key as long as the weights remain averageable.
+
+![](images/93d36ab5d9da3fec0b1140c4729c47999573df311e5d4ce9cca4257fd3e99364.jpg)  
+Figure 3: Frequencies of predic- Figure 4: WA accuracy $( \uparrow )$ as $M$ tion diversities ( ) [46] across 2 increases, when the $M$ weights weights obtained along a single are obtained along a single run run or from different runs. or from different runs.
+
+![](images/62fdbe233237ba75c7e4e4bfa2e49026061ed8a42b2735ff4c97e417a4f29502.jpg)  
+Figure 5: Each dot displays the accuracy ( ) gain of WA over its members vs. prediction diversity $( \uparrow )$ for $2 \leq M < 1 0$ models.
+
+# 5 Experimental results on the DomainBed benchmark
+
+Datasets. We now present our evaluation on DomainBed [12]. By imposing the code, the training procedures and the ResNet50 [52] architecture, DomainBed is arguably the fairest benchmark for OOD generalization. It includes 5 multi-domain real-world datasets: PACS [51], VLCS [53], OfficeHome [50], TerraIncognita [54] and DomainNet [55]. [19] showed that diversity shift dominates in these datasets. Each domain is successively considered as the target $T$ while other domains are merged into the source $S$ . The validation dataset is sampled from $S$ , i.e., we follow DomainBed’s training-domain model selection. The experimental setup is further described in Appendix G.1. Our code is available at https://github.com/alexrame/diwa.
+
+Baselines. ERM is the standard Empirical Risk Minimization. Coral [10] is the best approach based on domain invariance. SWAD (Stochastic Weight Averaging Densely) [14] and MA (Moving Average) [29] average weights along one training trajectory but differ in their weight selection strategy. SWAD [14] is the current state of the art (SoTA) thanks to it “overfit-aware” strategy, yet at the cost of three additional hyperparameters (a patient parameter, an overfitting patient parameter and a tolerance rate) tuned per dataset. In contrast, MA [29] is easy to implement as it simply combines all checkpoints uniformly starting from batch 100 until the end of training. Finally, we report the scores obtained in [29] for the costly Deep Ensembles (DENS) [15] (with different initializations): we discuss other ensembling strategies in Appendix D.
+
+Our runs. ERM and DiWA share the same training protocol in DomainBed: yet, instead of keeping only one run from the grid-search, DiWA leverages $M$ runs. In practice, we sample 20 configurations from the hyperparameter distributions detailed in Table 7 and report the mean and standard deviation across 3 data splits. For each run, we select the weights of the epoch with the highest validation accuracy. ERM and MA select the model with highest validation accuracy across the 20 runs, following standard practice on DomainBed. Ensembling (ENS) averages the predictions of all $M = 2 0$ models (with shared initialization). DiWA-restricted selects $1 \leq M \leq 2 0$ weights with Algorithm 1 while DiWA-uniform averages all $M = 2 0$ weights. DiWA† averages uniformly the $M = 3 \times 2 0 = 6 0$ weights from all 3 data splits. DiWA† benefits from larger $M$ (without additional inference cost) and from data diversity (see Appendix E.1.3). However, we cannot report standard deviations for DiWA† for computational reasons. Moreover, DiWA† cannot leverage the restricted weight selection, as the validation is not shared across all 60 weights that have different data splits.
+
+# 5.1 Results on DomainBed
+
+We report our main results in Table 1, detailed per domain in Appendix G.2. With a randomly initialized classifier, DiWA†-uniform is the best on PACS, VLCS and OfficeHome: DiWA-uniform is the second best on PACS and OfficeHome. On TerraIncognita and DomainNet, DiWA is penalized by some bad runs, filtered in DiWA-restricted which improves results on these datasets. Classifier initialization with linear probing (LP) [49] improves all methods on OfficeHome, TerraIncognita and DomainNet. On these datasets, DiWA† increases MA by 1.3, 0.5 and 1.1 points respectively. After averaging, DiWA† with LP establishes a new SoTA of $6 8 . 0 \%$ , improving SWAD by 1.1 points.
+
+Table 1: Accuracy $( \% , \uparrow )$ on DomainBed with ResNet50 (best in bold and second best underlined).   
+
+<table><tr><td>Algorithm</td><td>Weight selection</td><td>Init</td><td>PACS</td><td>VLCS</td><td>OfficeHome</td><td>TerraInc</td><td>DomainNet</td><td>Avg</td></tr><tr><td>ERM</td><td>N/A</td><td></td><td rowspan="5">Random</td><td>85.5±0.2 86.2±0.3</td><td>77.5 ± 0.4 78.8 ±0.6</td><td>66.5 ± 0.3 68.7 ±0.3</td><td>46.1 ± 1.8 47.6 ± 1.0</td><td>40.9 ± 0.1 41.5 ± 0.1</td><td>63.3 64.6</td></tr><tr><td>Coral[10]</td><td>N/A</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>SWAD[14]</td><td>Overfit-aware</td><td>88.1 ±0.1</td><td>79.1 ± 0.1</td><td>70.6± 0.2</td><td>50.0± 0.3</td><td>46.5 ± 0.1</td><td>66.9</td></tr><tr><td>MA [29]</td><td>Uniform</td><td>87.5 ± 0.2</td><td>78.2 ±0.2</td><td>70.6 ± 0.1</td><td>50.3 ± 0.5</td><td>46.0 ± 0.1</td><td>66.5</td></tr><tr><td>DENS [15,29]</td><td>Uniform: M=6</td><td>87.6</td><td>78.5</td><td>70.8</td><td>49.2</td><td>47.7</td><td>66.8</td></tr><tr><td rowspan="10">sun.I .ino</td><td>ERM</td><td></td><td rowspan="6">Random</td><td>85.5± 0.5</td><td>77.6± 0.2</td><td>67.4±0.6</td><td>48.3±0.8</td><td>44.1 ± 0.1</td><td>64.6</td></tr><tr><td>MA [29]</td><td>N/A Uniform</td><td>87.9 ± 0.1</td><td>78.4 ± 0.1</td><td>70.3 ± 0.1</td><td>49.9 ± 0.2</td><td>46.4 ± 0.1</td><td>66.6</td></tr><tr><td>ENS</td><td>Uniform:M= 20</td><td>88.0±0.1</td><td>78.7 ± 0.1</td><td>70.5 ± 0.1</td><td>51.0 ± 0.5</td><td>47.4 ± 0.2</td><td>67.1</td></tr><tr><td>DiWA</td><td>Restricted: M≤20</td><td>87.9±0.2</td><td>79.2 ± 0.1</td><td>70.5 ± 0.1</td><td>50.5 ± 0.5</td><td>46.7 ± 0.1</td><td>67.0</td></tr><tr><td>DiWA</td><td>Uniform:M= 20</td><td>88.8±0.4</td><td>79.1 ± 0.2</td><td>71.0 ± 0.1</td><td>48.9 ± 0.5</td><td>46.1 ± 0.1</td><td>66.8</td></tr><tr><td>DiWAt</td><td>Uniform: M= 60</td><td>89.0</td><td>79.4</td><td>71.6</td><td>49.0</td><td>46.3</td><td>67.1</td></tr><tr><td>ERM</td><td>N/A</td><td>85.9 ± 0.6</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>MA [29]</td><td>Uniform</td><td rowspan="5">LP [49]</td><td>87.8±0.3</td><td>78.1 ± 0.5 78.5 ± 0.4</td><td>69.4 ± 0.2 71.5 ± 0.3</td><td>50.4 ± 1.8 51.4 ± 0.6</td><td>44.3 ± 0.2 46.6 ± 0.0</td><td>65.6 67.1</td></tr><tr><td>ENS</td><td>Uniform:M= 20</td><td>88.1±0.3</td><td>78.5 ± 0.1</td><td>71.7 ± 0.1</td><td>50.8 ± 0.5</td><td>47.0±0.2</td><td>67.2</td></tr><tr><td>DiWA</td><td>Restricted: M≤20</td><td>88.0±0.3</td><td>78.5 ± 0.1</td><td>71.5 ± 0.2</td><td>51.6 ± 0.9</td><td>47.7 ± 0.1</td><td>67.5</td></tr><tr><td>DiWA</td><td>Uniform: M= 20</td><td>88.7±0.2</td><td>78.4± 0.2</td><td>72.1 ± 0.2</td><td>51.4 ± 0.6</td><td>47.4 ± 0.2</td><td>67.6</td></tr><tr><td>DiWAt</td><td>Uniform: M= 60</td><td>89.0</td><td>78.6</td><td>72.8</td><td>51.9</td><td>47.7</td><td>68.0</td></tr></table>
+
+DiWA with different objectives. So far we used ERM that does not leverage the domain information. Table 2 shows that DiWA-uniform benefits from averaging weights trained with Interdomain Mixup [56] and Coral [10]: accuracy gradually improves as we add more objectives. Indeed, as highlighted in Appendix E.1.3, DiWA benefits from the increased diversity brought by the various objectives. This suggests a new kind of linear connectivity across models trained with different objectives; the full analysis of this is left for future work.
+
+Table 2: Accuracy $( \% , \uparrow )$ on OfficeHome domain “Art” with various objectives.   
+
+<table><tr><td>Algorithm</td><td>No WA</td><td>MA</td><td>DiWA</td><td>DiWA†</td></tr><tr><td>ERM</td><td>62.9 ±1.3</td><td>65.0±0.2</td><td>67.3±0.2</td><td>67.7</td></tr><tr><td>Mixup</td><td>63.1 ±0.7</td><td>66.2 ± 0.3</td><td>67.8 ±0.6</td><td>68.4</td></tr><tr><td>Coral</td><td>64.4± 0.4</td><td>64.4 ± 0.4</td><td>67.7 ±0.2</td><td>68.2</td></tr><tr><td>ERM/Mixup</td><td>N/A</td><td>N/A</td><td>67.9 ± 0.7</td><td>68.9</td></tr><tr><td>ERM/Coral</td><td>N/A</td><td>N/A</td><td>68.1± 0.3</td><td>68.7</td></tr><tr><td>ERM/Mixup/Coral</td><td>N/A</td><td>N/A</td><td>68.4 ± 0.4</td><td>69.1</td></tr></table>
+
+# 5.2 Limitations of DiWA
+
+Despite this success, DiWA has some limitations. First, DiWA cannot benefit from additional diversity that would break the linear connectivity between weights — as discussed in Appendix D. Second, DiWA (like all WA approaches) can tackle diversity shift but not correlation shift: this property is explained for the first time in Section 2.4 and illustrated in Appendix H on ColoredMNIST.
+
+# 6 Related work
+
+Generalization and ensemble. To generalize under distribution shifts, invariant approaches [8, 9, 11, 10, 57, 58] try to detect the causal mechanism rather than memorize correlations: yet, they do not outperform ERM on various benchmarks [12, 19, 59]. In contrast, ensembling of deep networks [15, 60, 61] consistently increases robustness [16] and was successfully applied to domain generalization [29, 62, 63, 64, 65, 66]. As highlighted in [18] (whose analysis underlies our Equation (BVCL)), ensembling works due to the diversity among its members. This diversity comes primarily from the randomness of the learning procedure [15] and can be increased with different hyperparameters [67], data [68, 69, 70], augmentations [71, 72] or with regularizations [73, 65, 66, 74, 75].
+
+Weight averaging. Recent works [13, 76, 77, 78] combine in weights (rather than in predictions) models collected along a single run. This was shown suboptimal in IID [17] but successful in OOD [14, 29]. Following the linear mode connectivity [24, 79] and the property that many independent models are connectable [80], a second group of works average weights with fewer constraints [26, 27, 28, 81, 82, 83]. To induce greater diversity, [84] used a high constant learning rate; [80] explicitly encouraged the weights to encompass more volume in the weight space; [83] minimized cosine similarity between weights; [85] used a tempered posterior. From a loss landscape perspective [20], these methods aimed at “explor[ing] the set of possible solutions instead of simply converging to a single point”, as stated in [84]. The recent “Model soups” introduced by Wortsman et al. [28] is a WA algorithm similar to Algorithm 1; yet, the theoretical analysis and the goals of these two works are different. Theoretically, we explain why WA succeeds under diversity shift: the bias/correlation shift, variance/diversity shift and diversity-based findings are novel and are confirmed empirically. Regarding the motivation, our work aims at combining more diverse weights: it may be analyzed as a general framework to average weights obtained in various ways. In contrast, [28] challenges the standard model selection after a grid search. Regarding the task, [28] and our work complement each other: while [28] demonstrate robustness on several ImageNet variants with distribution shift, we improve the SoTA on the multi-domain DomainBed benchmark against other established OOD methods after a thorough and fair comparison. Thus, DiWA and [28] are theoretically complementary with different motivations and applied successfully for different tasks.
+
+# 7 Conclusion
+
+In this paper, we propose a new explanation for the success of WA in OOD by leveraging its ensembling nature. Our analysis is based on a new bias-variance-covariance-locality decomposition for WA, where we theoretically relate bias to correlation shift and variance to diversity shift. It also shows that diversity is key to improve generalization. This motivates our DiWA approach that averages in weights models trained independently. DiWA improves the state of the art on DomainBed, the reference benchmark for OOD generalization. Critically, DiWA has no additional inference cost — removing a key limitation of standard ensembling. Our work may encourage the community to further create diverse learning procedures and objectives — whose models may be averaged in weights.
+
+# Acknowledgements
+
+We would like to thank Jean-Yves Franceschi for his helpful comments and discussions on our paper. This work was granted access to the HPC resources of IDRIS under the allocation AD011011953 made by GENCI. We acknowledge the financial support by the French National Research Agency (ANR) in the chair VISA-DEEP (project number ANR-20-CHIA-0022-01) and the ANR projects DL4CLIM ANR-19-CHIA-0018-01, RAIMO ANR-20-CHIA-0021-01, OATMIL ANR-17-CE23- 0012 and LEAUDS ANR-18-CE23-0020.
+
+# References
+
+[1] John R. Zech, Marcus A. Badgeley, Manway Liu, Anthony B. Costa, Joseph J. Titano, and Eric Karl Oermann. Variable generalization performance of a deep learning model to detect pneumonia in chest radiographs: A cross-sectional study. PLOS Medicine, 2018. (pp. 1 and 17)   
+[2] Alex J DeGrave, Joseph D Janizek, and Su-In Lee. Ai for radiographic covid-19 detection selects shortcuts over signal. Nature Machine Intelligence, 2021. (pp. 1 and 17)   
+[3] Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. In ICLR, 2019. (p. 1)   
+[4] Harshay Shah, Kaustav Tamuly, Aditi Raghunathan, Prateek Jain, and Praneeth Netrapalli. The pitfalls of simplicity bias in neural networks. In NeurIPS, 2020. (p. 1)   
+[5] Alexander D’Amour, Katherine Heller, Dan Moldovan, Ben Adlam, Babak Alipanahi, Alex Beutel, Christina Chen, Jonathan Deaton, Jacob Eisenstein, Matthew D Hoffman, et al. Underspecification presents challenges for credibility in modern machine learning. JMLR, 2020. (pp. 1 and 4)   
+[6] Krikamol Muandet, David Balduzzi, and Bernhard Schölkopf. Domain generalization via invariant feature representation. In ICML, 2013. (p. 1)   
+[7] Jonas Peters, Peter Bühlmann, and Nicolai Meinshausen. Causal inference by using invariant prediction: identification and confidence intervals. JSTOR, 2016. (p. 1)   
+[8] Martin Arjovsky, Léon Bottou, Ishaan Gulrajani, and David Lopez-Paz. Invariant risk minimization. arXiv preprint, 2019. (pp. 1, 4, 9, and 36)   
+[9] David Krueger, Ethan Caballero, Joern-Henrik Jacobsen, Amy Zhang, Jonathan Binas, Dinghuai Zhang, Remi Le Priol, and Aaron Courville. Out-of-distribution generalization via risk extrapolation (rex). In ICML, 2021. (pp. 1 and 9)   
+[10] Baochen Sun, Jiashi Feng, and Kate Saenko. Return of frustratingly easy domain adaptation. In AAAI, 2016. (pp. 1, 8, 9, 29, 33, 34, 35, and 36)   
+[11] Alexandre Rame, Corentin Dancette, and Matthieu Cord. Fishr: Invariant gradient variances for out-of-distribution generalization. In ICML, 2022. (pp. 1, 9, and 36)   
+[12] Ishaan Gulrajani and David Lopez-Paz. In search of lost domain generalization. In ICLR, 2021. (pp. 1, 2, 3, 6, 8, 9, 16, 17, 18, 27, 32, 33, and 36)   
+[13] Pavel Izmailov, Dmitrii Podoprikhin, Timur Garipov, Dmitry Vetrov, and Andrew Gordon Wilson. Averaging weights leads to wider optima and better generalization. In UAI, 2018. (pp. 1, 2, 3, 9, and 20)   
+[14] Junbum Cha, Sanghyuk Chun, Kyungjae Lee, Han-Cheol Cho, Seunghyun Park, Yunsung Lee, and Sungrae Park. Swad: Domain generalization by seeking flat minima. In NeurIPS, 2021. (pp. 1, 3, 5, 6, 8, 9, 17, 18, 19, 20, 23, 32, 33, 34, and 35)   
+[15] Balaji Lakshminarayanan, Alexander Pritzel, and Charles Blundell. Simple and scalable predictive uncertainty estimation using deep ensembles. In NeurIPS, 2017. (pp. 1, 3, 5, 8, 9, 18, 28, 34, and 35)   
+[16] Yaniv Ovadia, Emily Fertig, Jie Ren, Zachary Nado, David Sculley, Sebastian Nowozin, Joshua Dillon, Balaji Lakshminarayanan, and Jasper Snoek. Can you trust your model’s uncertainty? evaluating predictive uncertainty under dataset shift. In NeurIPS, 2019. (pp. 1 and 9)   
+[17] Arsenii Ashukha, Alexander Lyzhov, Dmitry Molchanov, and Dmitry Vetrov. Pitfalls of in-domain uncertainty estimation and ensembling in deep learning. In ICLR, 2020. (pp. 1 and 9)   
+[18] Naonori Ueda and Ryohei Nakano. Generalization error of ensemble estimators. In ICNN, 1996. (pp. 1, 3, 9, and 21)   
+[19] Nanyang Ye, Kaican Li, Lanqing Hong, Haoyue Bai, Yiting Chen, Fengwei Zhou, and Zhenguo Li. Ood-bench: Benchmarking and understanding out-of-distribution generalization datasets and algorithms. CVPR, 2022. (pp. 1, 2, 4, 5, 6, 8, 9, 23, 33, and 36)   
+[20] Stanislav Fort, Huiyi Hu, and Balaji Lakshminarayanan. Deep ensembles: A loss landscape perspective. arXiv preprint, 2019. (pp. 2 and 9)   
+[21] Raphael Gontijo-Lopes, Yann Dauphin, and Ekin Dogus Cubuk. No one representation to rule them all: Overlapping features of training methods. In ICLR, 2022. (pp. 2, 6, 29, and 30)   
+[22] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015. (p. 2)   
+[23] Abien Fred Agarap. Deep learning using rectified linear units (relu). arXiv preprint, 2018. (p. 2)   
+[24] Jonathan Frankle, Gintare Karolina Dziugaite, Daniel M. Roy, and Michael Carbin. Linear mode connectivity and the lottery ticket hypothesis. In ICML, 2020. (pp. 2, 5, 6, and 9)   
+[25] Behnam Neyshabur, Hanie Sedghi, and Chiyuan Zhang. What is being transferred in transfer learning? In NeurIPS, 2020. (pp. 2, 6, 28, and 30)   
+[26] Mitchell Wortsman, Gabriel Ilharco, Jong Wook Kim, Mike Li, Hanna Hajishirzi, Ali Farhadi, Hongseok Namkoong, and Ludwig Schmidt. Robust fine-tuning of zero-shot models. In CVPR, 2022. (pp. 2, 9, and 28)   
+[27] Michael Matena and Colin Raffel. Merging models with fisher-weighted averaging. In NeurIPS, 2022. (pp. 2 and 9)   
+[28] Mitchell Wortsman, Gabriel Ilharco, Samir Yitzhak Gadre, Rebecca Roelofs, Raphael GontijoLopes, Ari S. Morcos, Hongseok Namkoong, Ali Farhadi, Yair Carmon, Simon Kornblith, and Ludwig Schmidt. Model soups: averaging weights of multiple fine-tuned models improves accuracy without increasing inference time. In ICML, 2022. (pp. 2, 3, 6, 9, 20, and 28)   
+[29] Devansh Arpit, Huan Wang, Yingbo Zhou, and Caiming Xiong. Ensemble of averages: Improving model selection and boosting performance in domain generalization. In NeurIPS, 2022. (pp. 3, 5, 8, 9, 18, 19, 20, 23, 28, 33, 34, 35, and 36)   
+[30] Pierre Foret, Ariel Kleiner, Hossein Mobahi, and Behnam Neyshabur. Sharpness-aware minimization for efficiently improving generalization. In ICLR, 2021. (pp. 3, 18, and 19)   
+[31] Jean Kaddour, Linqing Liu, Ricardo Silva, and Matt J. Kusner. When do flat minima optimizers work? In NeurIPS, 2022. (pp. 3 and 19)   
+[32] Ron Kohavi, David H Wolpert, et al. Bias plus variance decomposition for zero-one loss functions. In ICML, 1996. (pp. 3, 21, and 27)   
+[33] Pedro Domingos. A unified bias-variance decomposition. In ICML, 2000. (p. 3)   
+[34] Thomas G Dietterich. Ensemble methods in machine learning. In MCS, 2000. (p. 3)   
+[35] Gavin Brown, Jeremy Wyatt, and Ping Sun. Between two extremes: Examining decompositions of the ensemble objective function. In MCS, 2005. (pp. 3 and 21) [36] Yangjun Ruan, Yann Dubois, and Chris J. Maddison. Optimal representations for covariate shift. In ICLR, 2022. (pp. 4, 23, and 27) [37] Arthur Jacot, Franck Gabriel, and Clement Hongler. Neural tangent kernel: Convergence and generalization in neural networks. In NeurIPS, 2018. (pp. 4, 25, and 27) [38] Amit Daniely. Sgd learns the conjugate kernel class of the network. In NeurIPS, 2017. (p. 4) [39] Jaehoon Lee, Yasaman Bahri, Roman Novak, Samuel S Schoenholz, Jeffrey Pennington, and Jascha Sohl-Dickstein. Deep neural networks as gaussian processes. In ICLR, 2017. (pp. 4 and 25) [40] Julien Ah-Pine. Normalized kernels as similarity indices. In PAKDD, 2010. (pp. 4 and 25) [41] Benyamin Ghojogh, Ali Ghodsi, Fakhri Karray, and Mark Crowley. Reproducing kernel hilbert space, mercer’s theorem, eigenfunctions, nystrom method, and use of kernels in machine learning: Tutorial and survey. arXiv preprint, 2021. (pp. 4 and 25) [42] Jason Rennie. How to normalize a kernel matrix. MIT Computer Science - Artificial Intelligence Lab Tech Rep, 2005. (pp. 4 and 25) [43] Hangfeng He and Weijie Su. The local elasticity of neural networks. In ICLR, 2020. (pp. 4 and 25) [44] Mariia Seleznova and Gitta Kutyniok. Neural tangent kernel beyond the infinite-width limit: Effects of depth and initialization. ICML, 2022. (pp. 4 and 25) [45] Ludmila I Kuncheva and Christopher J Whitaker. Measures of diversity in classifier ensembles and their relationship with the ensemble accuracy. Machine learning, 2003. (p. 5) [46] Matti Aksela. Comparison of classifier selection methods for improving committee performance. In MCS, 2003. (pp. 5, 7, 19, 28, 29, 30, and 31) [47] Simon Kornblith, Mohammad Norouzi, Honglak Lee, and Geoffrey E. Hinton. Similarity of neural network representations revisited. In ICML, 2019. (pp. 5, 7, 28, 29, and 30) [48] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NeurIPS, 2012. (pp. 6 and 27) [49] Ananya Kumar, Aditi Raghunathan, Robbie Matthew Jones, Tengyu Ma, and Percy Liang. Fine-tuning can distort pretrained features and underperform out-of-distribution. In ICLR,   
+2022. (pp. 6, 8, 27, 32, 33, 34, and 35) [50] Hemanth Venkateswara, Jose Eusebio, Shayok Chakraborty, and Sethuraman Panchanathan. Deep hashing network for unsupervised domain adaptation. In CVPR, 2017. (pp. 6, 8, 18, and 33) [51] Da Li, Yongxin Yang, Yi-Zhe Song, and Timothy M Hospedales. Deeper, broader and artier domain generalization. In ICCV, 2017. (pp. 6, 8, and 33) [52] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. (pp. 8 and 33) [53] Chen Fang, Ye Xu, and Daniel N Rockmore. Unbiased metric learning: On the utilization of multiple datasets and web images for softening bias. In ICCV, 2013. (pp. 8 and 33) [54] Sara Beery, Grant Van Horn, and Pietro Perona. Recognition in terra incognita. In ECCV,   
+2018. (pp. 8 and 33) [55] Xingchao Peng, Qinxun Bai, Xide Xia, Zijun Huang, Kate Saenko, and Bo Wang. Moment matching for multi-source domain adaptation. In ICCV, 2019. (pp. 8, 33, and 36) [56] Shen Yan, Huan Song, Nanxiang Li, Lincan Zou, and Liu Ren. Improve unsupervised domain adaptation with mixup training. arXiv preprint, 2020. (pp. 9, 29, and 33)   
+[57] Shiori Sagawa, Pang Wei Koh, Tatsunori B. Hashimoto, and Percy Liang. Distributionally robust neural networks. In ICLR, 2020. (pp. 9 and 17)   
+[58] Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, François Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. JMLR, 2016. (p. 9)   
+[59] Pang Wei Koh, Shiori Sagawa, Henrik Marklund, Sang Michael Xie, Marvin Zhang, Akshay Balsubramani, Weihua Hu, Michihiro Yasunaga, Richard Lanas Phillips, Irena Gao, Tony Lee, Etienne David, Ian Stavness, Wei Guo, Berton Earnshaw, Imran Haque, Sara M Beery, Jure Leskovec, Anshul Kundaje, Emma Pierson, Sergey Levine, Chelsea Finn, and Percy Liang. Wilds: A benchmark of in-the-wild distribution shifts. In ICML, 2021. (p. 9)   
+[60] Lars Kai Hansen and Peter Salamon. Neural network ensembles. IEEE transactions on pattern analysis and machine intelligence, 1990. (p. 9)   
+[61] Anders Krogh and Jesper Vedelsby. Neural network ensembles, cross validation, and active learning. In NeurIPS, 1995. (p. 9)   
+[62] Kowshik Thopalli, Sameeksha Katoch, Jayaraman J. Thiagarajan, Pavan K. Turaga, and Andreas Spanias. Multi-domain ensembles for domain generalization. In NeurIPS Workshop, 2021. (p. 9)   
+[63] Yusuf Mesbah, Youssef Youssry Ibrahim, and Adil Mehood Khan. Domain generalization using ensemble learning. In ISWA, 2022. (p. 9)   
+[64] Ziyue Li, Kan Ren, Xinyang Jiang, Bo Li, Haipeng Zhang, and Dongsheng Li. Domain generalization using pretrained models without fine-tuning. arXiv preprint, 2022. (p. 9)   
+[65] Yoonho Lee, Huaxiu Yao, and Chelsea Finn. Diversify and disambiguate: Learning from underspecified data. arXiv preprint, 2022. (p. 9)   
+[66] Matteo Pagliardini, Martin Jaggi, François Fleuret, and Sai Praneeth Karimireddy. Agree to disagree: Diversity through disagreement for better transferability. arXiv preprint, 2022. (p. 9)   
+[67] Florian Wenzel, Jasper Snoek, Dustin Tran, and Rodolphe Jenatton. Hyperparameter ensembles for robustness and uncertainty quantification. In NeurIPS, 2020. (p. 9)   
+[68] Leo Breiman. Bagging predictors. Machine learning, 1996. (pp. 9 and 29)   
+[69] Jeremy Nixon, Balaji Lakshminarayanan, and Dustin Tran. Why are bootstrapped deep ensembles not better? In NeurIPS Workshop, 2020. (p. 9)   
+[70] Teresa Yeo, Oguzhan Fatih Kar, and Amir Roshan Zamir. Robustness via cross-domain ensembles. In ICCV, 2021. (p. 9)   
+[71] Yeming Wen, Ghassen Jerfel, Rafael Muller, Michael W Dusenberry, Jasper Snoek, Balaji Lakshminarayanan, and Dustin Tran. Combining ensembles and data augmentation can harm your calibration. In ICLR, 2021. (p. 9)   
+[72] Alexandre Rame, Remy Sun, and Matthieu Cord. Mixmo: Mixing multiple inputs for multiple outputs via deep subnetworks. In ICCV, 2021. (pp. 9 and 28)   
+[73] Alexandre Rame and Matthieu Cord. Dice: Diversity in deep ensembles via conditional redundancy adversarial estimation. In ICLR, 2021. (pp. 9 and 28)   
+[74] Tianyu Pang, Kun Xu, Chao Du, Ning Chen, and Jun Zhu. Improving adversarial robustness via promoting ensemble diversity. In ICML, 2019. (p. 9)   
+[75] Damien Teney, Ehsan Abbasnejad, Simon Lucey, and Anton van den Hengel. Evading the simplicity bias: Training a diverse set of models discovers solutions with superior ood generalization. arXiv preprint, 2021. (p. 9)   
+[76] Felix Draxler, Kambis Veschgini, Manfred Salmhofer, and Fred Hamprecht. Essentially no barriers in neural network energy landscape. In ICML, 2018. (p. 9)   
+[77] Hao Guo, Jiyong Jin, and Bin Liu. Stochastic weight averaging revisited. arXiv preprint, 2022. (p. 9)   
+[78] Michael Zhang, James Lucas, Jimmy Ba, and Geoffrey E Hinton. Lookahead optimizer: k steps forward, 1 step back. NeurIPS, 32, 2019. (p. 9)   
+[79] Vaishnavh Nagarajan and J Zico Kolter. Uniform convergence may be unable to explain generalization in deep learning. NeurIPS, 2019. (p. 9)   
+[80] Gregory Benton, Wesley Maddox, Sanae Lotfi, and Andrew Gordon Wilson. Loss surface simplexes for mode connecting volumes and fast ensembling. In ICML, 2021. (p. 9)   
+[81] Vipul Gupta, Santiago Akle Serrano, and Dennis DeCoste. Stochastic weight averaging in parallel: Large-batch training that generalizes well. In ICLR, 2020. (p. 9)   
+[82] Leshem Choshen, Elad Venezian, Noam Slonim, and Yoav Katz. Fusing finetuned models for better pretraining. arXiv preprint, 2022. (p. 9)   
+[83] Mitchell Wortsman, Maxwell Horton, Carlos Guestrin, Ali Farhadi, and Mohammad Rastegari. Learning neural network subspaces. ICML, 2021. (p. 9)   
+[84] Wesley J Maddox, Pavel Izmailov, Timur Garipov, Dmitry P Vetrov, and Andrew Gordon Wilson. A simple baseline for bayesian uncertainty in deep learning. In NeurIPS, 2019. (p. 9)   
+[85] Pavel Izmailov, Wesley Maddox, Polina Kirichenko, Timur Garipov, Dmitry Vetrov, and Andrew Gordon Wilson. Subspace inference for bayesian deep learning. In UAI, 2019. (p. 9)   
+[86] Polina Kirichenko, Pavel Izmailov, and Andrew Gordon Wilson. Last layer re-training is sufficient for robustness to spurious correlations. In ICML SCIS Workshop, 2022. (pp. 17 and 37)   
+[87] Su Lin Blodgett, Lisa Green, and Brendan O’Connor. Demographic dialectal variation in social media: A case study of african-american english. In EMNLP, 2016. (p. 17)   
+[88] Solon Barocas and Andrew D Selbst. Big data’s disparate impact. Calif. L. Rev., 2016. (p. 17)   
+[89] Laurent Dinh, Razvan Pascanu, Samy Bengio, and Yoshua Bengio. Sharp minima can generalize for deep nets. In ICML, 2017. (p. 18)   
+[90] Henning Petzka, Michael Kamp, Linara Adilova, Cristian Sminchisescu, and Mario Boley. Relative flatness and generalization. In NeurIPS, 2021. (p. 18)   
+[91] Zhewei Yao, Amir Gholami, Kurt Keutzer, and Michael W Mahoney. Pyhessian: Neural networks through the lens of the hessian. In Big Data, 2020. (p. 18)   
+[92] Aditya Ramesh, Prafulla Dhariwal, Alex Nichol, Casey Chu, and Mark Chen. Hierarchical text-conditional image generation with clip latents. arXiv preprint, 2022. (p. 19)   
+[93] Carl Edward Rasmussen. Gaussian processes in machine learning. In Summer school on machine learning, 2003. (p. 24)   
+[94] Fernando Pérez-Cruz, Steven Van Vaerenbergh, Juan José Murillo-Fuentes, Miguel LázaroGredilla, and Ignacio Santamaria. Gaussian processes for nonlinear signal processing: An overview of recent advances. EEE Signal Process. Mag., 2013. (p. 25)   
+[95] Greg Yang and Hadi Salman. A fine-grained spectral perspective on neural networks. arXiv preprint, 2019. (p. 25)   
+[96] Damien Brain and Geoffrey I Webb. On the effect of data set size on bias and variance in classification learning. In AKAW, 1999. (p. 25)   
+[97] Arthur Gretton, Karsten M. Borgwardt, Malte J. Rasch, Bernhard Schölkopf, and Alexander Smola. A kernel two-sample test. Journal of Machine Learning Research, 13(25):723–773, 2012. (p. 26) [98] Jan R Magnus and Heinz Neudecker. Matrix differential calculus with applications in statistics and econometrics. John Wiley & Sons, 2019. (p. 26) [99] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. In ICML, 2021. (p. 27) [100] Saurabh Singh, Derek Hoiem, and David Forsyth. Swapout: Learning an ensemble of deep architectures. In NeurIPS, 2016. (p. 28) [101] Bradley Efron. Bootstrap methods: another look at the jackknife. In Breakthroughs in statistics.   
+1992. (p. 29) [102] Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR,   
+2015. (p. 33) [103] Yann LeCun, Corinna Cortes, and Chris Burges. Mnist handwritten digit database, 2010. (p. 36) [104] Elan Rosenfeld, Pradeep Ravikumar, and Andrej Risteski. Domain-adjusted regression or: Erm may already learn features sufficient for out-of-distribution generalization. 2022. (p. 37)
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] In Section 5.2.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] In Appendix A   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] Assumption 1 discussed in Appendix C.3.2 and Assumptions 2 and 3 discussed in Appendix C.4.2. (b) Did you include complete proofs of all theoretical results? [Yes] In Appendix C
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] Our code is available at https://github.com/alexrame/diwa.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 5 and Appendix G.1   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] Defined by different data splits when possible.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] Approximately 20000 hours of GPUs (Nvidia V100) on an internal cluster, mostly for the 2640 runs needed in Table 1.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] DomainBed benchmark [12] and its datasets.   
+(b) Did you mention the license of the assets? [Yes] DomainBed is under “The MIT License”.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/dev/vGQiU5sqUe3/vGQiU5sqUe3_content_list.json

@@ -0,0 +1,1369 @@
+[
+    {
+        "type": "text",
+        "text": "Contrastive Learning as Goal-Conditioned Reinforcement Learning ",
+        "text_level": 1,
+        "bbox": [
+            240,
+            122,
+            758,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tianjun Zhangγ Sergey Levineβ,γ Ruslan Salakhutdinovα U βGoogle Research γUC Berkeley ",
+        "bbox": [
+            369,
+            224,
+            808,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            290,
+            535,
+            308
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In reinforcement learning (RL), it is easier to solve a task if given a good representation. While deep RL should automatically acquire such good representations, prior work often finds that learning representations in an end-to-end fashion is unstable and instead equip RL algorithms with additional representation learning parts (e.g., auxiliary losses, data augmentation). How can we design RL algorithms that directly acquire good representations? In this paper, instead of adding representation learning parts to an existing RL algorithm, we show (contrastive) representation learning methods can be cast as RL algorithms in their own right. To do this, we build upon prior work and apply contrastive representation learning to action-labeled trajectories, in such a way that the (inner product of) learned representations exactly corresponds to a goal-conditioned value function. We use this idea to reinterpret a prior RL method as performing contrastive learning, and then use the idea to propose a much simpler method that achieves similar performance. Across a range of goal-conditioned RL tasks, we demonstrate that contrastive RL methods achieve higher success rates than prior non-contrastive methods, including in the offline RL setting. We also show that contrastive RL outperforms prior methods on image-based tasks, without using data augmentation or auxiliary objectives. 1 ",
+        "bbox": [
+            233,
+            323,
+            766,
+            571
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            598,
+            310,
+            616
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Representation learning is an integral part of reinforcement learning $( \\mathrm { R L } ^ { 2 } )$ algorithms. While such representations might emerge from end-to-end training [7, 79, 119, 126], prior work has found it necessary to equip RL algorithms with perception-specific loss functions [32, 44, 71, 89, 91, 101, 116, 140] or data augmentations [69, 73, 116, 118], effectively decoupling the representation learning problem from the reinforcement learning problem. Given what prior work has shown about RL in the presence of function approximation and state aliasing [2, 135, 138], it is not surprising that end-to-end learning of representations is fragile [69, 73]: an algorithm needs good representations to drive the learning of the RL algorithm, but the RL algorithm needs to drive the learning of good representations. So, can we design RL algorithms that do learn good representations without the need for auxiliary perception losses? ",
+        "bbox": [
+            174,
+            631,
+            825,
+            770
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Rather than using a reinforcement learning algorithm also to solve a representation learning problem, we will use a representation learning algorithm to also solve certain types of reinforcement learning problems, namely goal-conditioned RL. Goal-conditioned RL is widely studied [6, 15, 22, 62, 80, 120], and intriguing from a representation learning perspective because it can be done in an entirely self-supervised manner, without manually-specified reward functions. We will focus on contrastive (representation) learning methods, using observations from the same trajectory (as done in prior work [95, 109]) while also including actions as an additional input (See Fig. 1). Intuitively, contrastive learning then resembles a goal-conditioned value function: nearby states have similar representations and unreachable states have different representations. We make this connection precise, showing that sampling positive pairs using the discounted state occupancy measure results in learning representations whose inner product exactly corresponds to a value function. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            859
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/cd5df224f921c81048f98a3e7493620ab5683623d594ddd76acd0280121c9b97.jpg",
+        "image_caption": [
+            "Figure 1: Reinforcement learning via contrastive learning. Our method uses contrastive learning to acquire representations of state-action pairs $( \\phi ( s , a ) )$ and future states $( \\psi ( s _ { f } ) )$ , so that the representations of future states are closer than the representations of random states. We prove that learned representation corresponds to a value function for a certain reward function. To select actions for reaching goal $s _ { g }$ , the policy chooses the action where $\\phi ( s , a )$ is closest to $\\psi ( s _ { g } )$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            61,
+            779,
+            270
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            361,
+            825,
+            430
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we show how contrastive representation learning can be used to perform goalconditioned RL. We formally relate the learned representations to reward maximization, showing that the inner product between representations corresponds to a value function. This framework of contrastive RL generalizes prior methods, such as C-learning [29], and suggests new goal-conditioned RL algorithms. One new method achieves performance similar to prior methods but is simpler; another method consistently outperforms the prior methods. On goal-conditioned RL tasks with image observations, contrastive RL methods outperform prior methods that employ data augmentation and auxiliary objectives, and do so without data augmentation or auxiliary objectives. In the offline setting, contrastive RL can outperform prior methods on benchmark goal-reaching tasks, sometimes by a wide margin. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            575
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            595,
+            321,
+            613
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper will draw a connection between RL and contrastive representation learning, building upon a long line of contrastive learning methods in NLP and computer vision, and deep metric learning [17, 53, 54, 54, 56, 77, 84, 86, 87, 94, 95, 108, 109, 113, 122, 129, 132]. Contrastive learning methods learn representations such that similar (“positive”) examples have similar representations and dissimilar (“negative”) examples have dissimilar representations.3 While most methods generate the “positive” examples via data augmentation, some methods generate similar examples using different camera viewpoints of the same scene [109, 122], or by sampling examples that occur close in time within time series data [4, 95, 109, 118]. Our analysis will focus on this latter strategy, as the dependence on time will allow us to draw a precise relationship with the time dependence in RL. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            753
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep RL algorithms promise to automatically learn good representations, in an end-to-end fashion. However, prior work has found it challenging to uphold this promise [7, 79, 119, 126], prompting many prior methods to employ separate objectives for representation learning and RL [32, 44, 71, 89, 91, 100, 101, 116, 118, 140, 143]. Many prior methods choose a representation learning objectives that reconstruct the input state [32, 47, 49, 50, 71, 91, 93, 141] while others use contrastive representation learning methods [89, 95, 111, 116, 118]. Unlike these prior methods, we will not use a separate representation learning objective, but instead use the same objective for both representation learning and reinforcement learning. Some prior RL methods have also used contrastive learning to acquire reward functions [14, 20, 33, 38, 63, 67, 92, 133, 134, 146], often in imitation learning settings [37, 55]. In contrast, we will use contrastive learning to directly acquire a value function, which (unlike a reward function) can be used directly to take actions, without any additional RL. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            885
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This paper will focus on goal-conditioned RL problems, a problem prior work has approached using temporal difference learning [6, 29, 62, 80, 103, 106], conditional imitation learning [22, 41, 83, 105, 120], model-based methods [23, 107], hierarchical RL [90], and planning-based methods [30, 93, 105, 115]. The problems of automatically sampling goals and exploration [24, 35, 85, 98, 144] are orthogonal to this work. Like prior work, we will parametrize the value function as an inner product between learned representations [34, 58, 106]. Unlike these prior methods, we will learn a value function directly via contrastive learning, without using reward functions or TD learning. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our analysis will be most similar to prior methods [11, 15, 29, 103] that view goal-conditioned RL as a data-driven problem, rather than as a reward-maximization problem. Many of these methods employ hindsight relabeling [6, 26, 62, 78], wherein experience is relabeled with an outcome that occurred in the future. Whereas hindsight relabeling is typically viewed as a trick to add on top of an RL algorithm, this paper can roughly be interpreted as showing that the hindsight relabeling is a standalone RL algorithm. Many goal-conditioned methods learn a value function that captures the similarity between two states [29, 62, 91, 125]. Such distance functions are structurally similar to the critic function learned for contrastive learning, a connection we make precisely in Sec. 4. In fact, our analysis shows that C-learning [29] is already performing contrastive learning, and our experiments show that alternative contrastive RL methods can be much simpler and achieve higher performance. ",
+        "bbox": [
+            174,
+            228,
+            825,
+            367
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Prior work has studied how representations related to reward functions using the framework of universal value functions [12, 106] and successor features [9, 52, 81]. While these methods typically require additional supervision to drive representation learning (manually-specified reward functions or features), our method is more similar to prior work that estimates the discounted state occupancy measure as an inner product between learned representations [11, 131]. While these methods use temporal difference learning, ours is akin to Monte Carlo learning. While Monte Carlo learning is often (but not always [23]) perceived as less sampling efficient, our experiments find that our approach can be as sample efficient as TD methods. Other prior work has focused on learning representations that can be used for planning [59, 82, 104, 105, 128]. Our method will learn representations using an objective similar to prior work [105, 109], but makes the key observation that the representation already encodes a value function: no additional planning or RL is necessary to choose actions. ",
+        "bbox": [
+            174,
+            373,
+            825,
+            526
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Please see Appendix A for a discussion of how our work relates to unsupervised skill learning. ",
+        "bbox": [
+            174,
+            532,
+            790,
+            546
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            564,
+            318,
+            582
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Goal-conditioned reinforcement learning. The goal-conditioned RL problem is defined by states $s _ { t } \\in S$ , actions $a _ { t }$ , an initial state distribution $p _ { 0 } \\overline { { ( } } s )$ , the dynamics $p ( \\boldsymbol { \\dot { s } } _ { t + 1 } \\mid s _ { t } , \\boldsymbol { a } _ { t } )$ , a distribution over goals $p _ { g } ( s _ { g } )$ , and a reward function $r _ { g } { \\left( s , \\bar { a } \\right) }$ for each goal. This problem is equivalent to a multi-task RL [5, 45, 121, 130, 139], where tasks correspond to reaching goals states. Following prior work [11, 15, 29, 103], we define the reward as the probability (density) of reaching the goal at the next time step:4 ",
+        "bbox": [
+            173,
+            594,
+            825,
+            674
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4be5987805a1d1d65469e3e45186a44d6db68fbcaa248094a4e03688c4b772c4.jpg",
+        "text": "$$\nr _ { g } ( s _ { t } , a _ { t } ) \\triangleq ( 1 - \\gamma ) p ( s _ { t + 1 } = s _ { g } \\ | \\ s _ { t } , a _ { t } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            678,
+            627,
+            695
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This reward function is appealing because it avoids the need for a human user to specify a distance metric (unlike, e.g., [6]). Even though our method will not estimate the reward function, we will still use the reward function for analysis. For a goal-conditioned policy $\\pi ( \\boldsymbol { a } \\mid \\boldsymbol { s } , \\boldsymbol { s } _ { g } )$ , we use $\\pi ( \\tau \\mid s _ { g } )$ to denote the probability of sampling an infinite-length trajectory $\\tau = ( s _ { 0 } , a _ { 0 } , s _ { 1 } , a _ { 1 } , \\cdot \\cdot \\cdot )$ . We defined the expected reward objective and Q-function as ",
+        "bbox": [
+            174,
+            698,
+            825,
+            763
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8d7d74c5ce4ed83e779bc7a04525811cb00d2a2fc6baea0693d22e7db7e1b29b.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\pi } \\mathbb { E } _ { p _ { g } ( s _ { g } ) , \\pi ( \\tau | s _ { g } ) } \\left[ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r _ { g } ( s _ { t } , a _ { t } ) \\right] , \\quad Q _ { s _ { g } } ^ { \\pi } ( s , a ) \\triangleq \\mathbb { E } _ { \\pi ( \\tau | s _ { g } ) } \\left[ \\sum _ { t ^ { \\prime } = t } ^ { \\infty } \\gamma ^ { t ^ { \\prime } - t } r _ { g } ( s _ { t ^ { \\prime } } , a _ { t ^ { \\prime } } ) \\mid \\mathbf { \\Pi } _ { a _ { t } = a } ^ { s _ { t } = s _ { t } } \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            196,
+            767,
+            784,
+            806
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, this objective corresponds to sampling a goal $s _ { g }$ and then optimizing the policy to go to that goal and stay there. Finally, we define the discounted state occupancy measure as [55, 142] ",
+        "bbox": [
+            174,
+            809,
+            828,
+            837
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fb1531c017274deb362168d5a902b3256c9513bbdb72c38c9e843741ac5a53e4.jpg",
+        "text": "$$\np ^ { \\pi ( \\cdot | \\cdot , s _ { g } ) } ( s _ { t + } = s ) \\triangleq ( 1 - \\gamma ) \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } p _ { t } ^ { \\pi ( \\cdot | \\cdot , s _ { g } ) } ( s _ { t } = s ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            840,
+            663,
+            877
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $p _ { t } ^ { \\pi } ( s )$ is the probability density over states that policy $\\pi$ visits after $t$ steps. Sampling from the discounted state occupancy measure is easy: the first sample a time offset from a geometric distribution $\\boldsymbol { \\mathit { t } } \\sim \\mathbf { \\mathrm { G E O M } } ( 1 - \\gamma ) )$ , and then look at what state the policy visits after exactly $t$ steps. We will use $s _ { t + }$ to denote states sampled from the discounted state occupancy measure. Because our method will combine experience collected from multiple policies, we also define the average stationary distribution as $p ^ { \\pi \\^ { \\cdot } \\mid \\cdot \\rangle } ( s _ { t + } = s \\mid s , a ) \\triangleq \\int p ^ { \\pi ( \\cdot \\mid \\cdot , s _ { g } ) } ( s _ { t + } = s \\mid s , a ) p ^ { \\pi } ( s _ { g } \\mid s , a ) d \\bar { s } _ { g \\pi }$ where $p ^ { \\pi } ( s _ { g } \\mid s , a )$ is the probability of the commanded goal given the current state-action pair. This stationary distribution is equivalent to that of the policy $\\begin{array} { r } { \\pi ( \\boldsymbol { a } \\mid \\boldsymbol { s } ) \\triangleq \\int \\pi ( \\boldsymbol { a } \\mid \\boldsymbol { s } , \\boldsymbol { s } _ { g } ) p ^ { \\pi } ( \\boldsymbol { s } _ { g } \\mid \\boldsymbol { s } ) d \\boldsymbol { s } _ { g } } \\end{array}$ [145]. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            208
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Contrastive representation learning. Contrastive representation learning methods [17, 46, 53, 54, 61, 77, 84, 86, 87, 122, 124, 129] take as input pairs of positive and negative examples, and learn representations so that positive pairs have similar representations and negative pairs have dissimilar representations. We use $( u , v )$ to denote an input pair (e.g., $u$ is an image, and $v$ is an augmented version of that image). Positive examples are sampled from a joint distribution $p ( u , v )$ , while negative examples are sampled from the product of marginal distributions, $p ( u ) p ( v )$ . We will use an objective based on binary classification [77, 86, 87, 94]. Let $f ( u , v ) = \\phi ( u ) ^ { T } \\psi ( v )$ be the similarity between the representations of $u$ and $v$ . We will call $f$ the critic function5 and note that its range is $( - \\infty , \\infty )$ . We will use NCE-binary [84] objective (also known as InfoMAX [54]): ",
+        "bbox": [
+            173,
+            210,
+            826,
+            332
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cac3d884e62a94b6890b89a474e745af53d6c67522482080ce8c4f94c0bd3f3b.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { f ( u , v ) } \\mathbb { E } _ { ( u , v ^ { + } ) \\sim p ( u , v ) } \\biggl [ \\log \\sigma \\bigl ( \\underbrace { f ( u , v ^ { + } ) } _ { \\phi ( u ) ^ { T } \\psi ( v ^ { + } ) } \\bigr ) + \\log \\bigl ( 1 - \\sigma \\bigl ( \\underbrace { f ( u , \\mathrm { ~ \\xi ~ } ) } _ { \\phi ( u ) ^ { T } \\psi ( \\mathrm { ~ \\xi ~ } ) } \\bigr ) \\bigr ) \\biggr ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            337,
+            710,
+            381
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Contrastive Learning as an RL Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            410,
+            557,
+            428
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This section shows how to use contrastive representation to directly perform goal-conditioned RL. The key idea (Lemma 4.1) is that contrastive learning estimates the Q-function for a certain policy and reward function. To prove this result, we relate the Q-function to the state occupancy measure (Sec. 4.1) and then relate the optimal critic function to the state occupancy measure (Sec. 4.2). ",
+        "bbox": [
+            173,
+            441,
+            825,
+            497
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This result allows us to propose a new algorithm for goal-conditioned RL based on contrastive learning. Unlike prior work, this algorithm is not adding contrastive learning on top of an existing RL algorithm. This framework generalizes C-learning [29], offering a cogent explanation for its good performance while also suggesting new methods that are simpler and can achieve higher performance. ",
+        "bbox": [
+            174,
+            503,
+            825,
+            560
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 Relating the Q-function to probabilities ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            575,
+            486,
+            590
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This section sets the stage for the main results of this section by providing a probabilistic perspective goal-conditioned RL. The expected reward objective and associated Q-function in (Eq. 2) can equivalently be expressed as the probability (density) of reaching a goal in the future: ",
+        "bbox": [
+            173,
+            601,
+            825,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1 (rewards probabilities). The $Q$ -function for the goal-conditioned reward function $r _ { g }$ (Eq. 1) is equivalent to the probability of state $s _ { g }$ under the discounted state occupancy measure: ",
+        "bbox": [
+            173,
+            646,
+            823,
+            675
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/547844c5ec2b355be1fe271b3938a431dd2e36f957be68aecb41bc0c955ca09f.jpg",
+        "text": "$$\nQ _ { s _ { g } } ^ { \\pi } ( s , a ) = p ^ { \\pi ( \\cdot | \\cdot , s _ { g } ) } ( s _ { t + } = s _ { g } \\mid s , a ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            681,
+            627,
+            703
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The proof is in Appendix B. Translating rewards into probabilities not only makes it easier to analyze the goal-conditioned problem, but also means that any method for estimating probabilities (e.g., contrastive learning) can be turned into a method for estimating this Q-function. ",
+        "bbox": [
+            173,
+            714,
+            825,
+            757
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 Contrastive Learning Estimates a Q-Function ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            772,
+            532,
+            787
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We will use contrastive learning to learn a value function by carefully choosing the inputs $u$ and $v$ . The first input, $u$ , will correspond to a state-action pair, $u \\dot { = } ( s _ { t } , a _ { t } \\dot { ) } \\sim p ( s , a \\dot { ) }$ . In practice, these pairs are sampled from the replay buffer. Including the actions in the input is important because it will allow us to determine which actions to take to reach a desired future state. The second variable, $v$ , is a future state, $v = s _ { f }$ . For the “positive” training pairs, the future state is sampled from the discounted state occupancy measure, $s _ { f } \\sim p ^ { \\pi ( \\cdot | \\cdot ) } ( s _ { t + } \\mid s _ { t } , a _ { t } )$ . For the “negative” training pairs, we sample a future state from a random state-action pair: $\\begin{array} { r } { \\mathfrak { s } _ { f } \\sim p ( \\mathfrak { s } _ { t + } ) \\underline { { \\triangleq } } \\int p ^ { \\pi ( \\cdot | \\cdot ) } ( \\mathfrak { s } _ { t + } \\mid \\mathfrak { s } , a ) p ( \\mathfrak { s } , a ) d \\mathfrak { s } d a } \\end{array}$ . With these inputs, the contrastive learning objective (Eq. 4) can be written as ",
+        "bbox": [
+            173,
+            796,
+            825,
+            863
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            89,
+            825,
+            135
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/02f836bb14371603f71b54b8f5cde27c4382e0f108d906f75bfc70a5e8647775.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\underset { f } { \\operatorname* { m a x } } \\mathbb { E } _ { ( s , a ) \\sim p ( s , a ) , \\quad \\sim p ( s _ { f } ) } \\left[ \\mathcal { L } ( s , a , s _ { f } ^ { + } , \\mathrm {  ~ \\lambda ~ } ) \\right] , } \\\\ & { \\quad \\quad \\quad \\quad s _ { f } ^ { + } \\sim p ^ { \\pi ( \\cdot | \\cdot ) } ( s _ { t + } | s _ { t } , a _ { t } ) } \\\\ & { \\quad \\quad \\quad \\mathrm { w h e r e } \\quad \\mathcal { L } ( s , a , s _ { f } ^ { + } , \\mathrm {  ~ \\lambda ~ } ) \\triangleq \\log \\sigma ( \\underset { \\phi ( s , a ) ^ { T } \\psi ( s _ { f } ^ { + } ) } { \\underbrace { f ( s , a , s _ { f } ^ { + } ) } } ) + \\log ( 1 - \\sigma ( \\underset { \\phi ( s , a ) ^ { T } \\psi ( \\mathrm {  ~ \\lambda ~ } ) } { \\underbrace { f ( s , a , \\mathrm {  ~ \\lambda ~ } ) } } ) ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            256,
+            142,
+            743,
+            224
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, the critic function $f ( u = ( s _ { t } , a _ { t } ) , v = s _ { f } )$ now tells us the correlation between the current state-action pair and future outcomes, analogous to a Q-function. We therefore can use the critic function in the same way as actor-critic RL algorithms [66], figuring out which actions lead to the desired outcome. Because the Bayes-optimal critic function is a function of the state occupancy measure [84], $\\begin{array} { r } { f ^ { * } ( s , a , s _ { g } ) = \\log \\Big ( \\frac { \\bar { p } ^ { \\pi ( \\cdot | \\cdot ) } \\bar { ( } s _ { t + } = s _ { g } | s , a ) } { p ( s _ { g } ) } \\Big ) } \\end{array}$ , it can be used to express the Q-function: ",
+        "bbox": [
+            173,
+            231,
+            825,
+            311
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lemma 4.1. The critic function that optimizes Eq. $6$ is a $Q$ -function for the goal-conditioned reward function (Eq. 1), up to a multiplicative constant p(sf ) : $\\begin{array} { r } { \\exp ( f ^ { * } ( s , a , s _ { f } ) ) = \\frac { 1 } { p ( s _ { f } ) } \\cdot Q _ { s _ { f } } ^ { \\pi ( \\cdot | \\cdot ) } ( s , a ) } \\end{array}$ . ",
+        "bbox": [
+            173,
+            315,
+            820,
+            352
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The critic function can be viewed as an unnormalized density model, where $p ( s _ { g } )$ is the partition function. Much of the appeal of contrastive learning is it avoids estimating the partition function [46], which can be challenging; in the RL setting, it will turn out that this constant can be ignored when selecting actions. Our experiments show that learning a normalized density model works well when $s _ { g }$ is low-dimensional, but struggles to solve higher-dimensional tasks. ",
+        "bbox": [
+            173,
+            362,
+            825,
+            433
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This lemma relates the critic function to $Q _ { s _ { f } } ^ { \\pi ( \\cdot | \\cdot ) } ( s , a )$ , not $Q _ { s _ { f } } ^ { \\pi ( \\cdot | \\cdot , s _ { f } ) } ( s , a )$ . The underlying reason is that the critic function combines together experience collected when commanding different goals. Prior goal-conditioned behavioral cloning methods [22, 41, 83, 120] perform similar sharing, but do not analyze the relationship between the learned policies and Q functions. Sec. 4.5 shows that this critic function can be used as the basis for a convergent RL algorithm under some assumptions. ",
+        "bbox": [
+            173,
+            439,
+            826,
+            513
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 Learning the Goal-Conditioned Policy ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            530,
+            478,
+            545
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The learned critic function not only tells us the likelihood of future states, but also tells us how different actions change the likelihood of a state occurring in the future. Thus, to learn a policy for reaching a goal state, we choose the actions that make that state most likely to occur in the future: ",
+        "bbox": [
+            174,
+            554,
+            826,
+            595
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d38b53a2b7dba48ea8b2859081dd2b89cdcd6bdb6545650d361af3438b57541a.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\pi ( a | s , s _ { g } ) } \\mathbb { E } _ { \\pi ( a | s , s _ { g } ) p ( s ) p ( s _ { g } ) } \\left[ f ( s , a , s _ { f } = s _ { g } ) \\right] \\approx \\mathbb { E } _ { \\pi ( a | s , s _ { g } ) p ( s ) p ( s _ { g } ) } \\left[ \\log Q _ { s _ { g } } ^ { \\pi ( \\cdot | \\cdot ) } ( s , a ) - \\log p ( s _ { g } ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            603,
+            787,
+            630
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The approximation above reflects errors in learning the optimal critic, and will allow us to prove that this policy loss corresponds to policy improvement in Sec. 4.5, under some assumptions. ",
+        "bbox": [
+            174,
+            638,
+            823,
+            667
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In practice, we parametrize the goal-conditioned policy as a neural network that takes as input the state and goal and outputs a distribution over actions. The actor loss (Eq. 7) is computed by sampling states and random goals from the replay buffer, sampling actions from the policy, and then taking gradients on the policy using a reparametrization gradient. On tasks with image observations, we add an action entropy term to the policy objective. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            743
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.4 A Complete Goal-Conditioned RL Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            760,
+            529,
+            776
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The complete algorithm alternates between fitting the critic function using contrastive learning, updating the policy using Eq. 7, and collecting more data. Alg. 1 provides a JAX [13] implementation of the actor and critic losses. Note that the critic is parameterized as an inner product between a representation of the state-action pair, and a representation of the goal state: $f ( s , \\dot { a } , s _ { g } ) = \\phi ( s , a ) ^ { T } \\psi ( \\dot { s } _ { g } )$ . This parameterization allows for efficient computation, as we can compute the goal representations just once, and use them both in the positive pairs and the negative pairs. While this is common practice in representation learning, it is not exploited by most goal-conditioned RL algorithms. We refer to this method as contrastive RL (NCE). In Appendix C, we derive a variant of this method (contrastive RL (CPC)) that uses the infoNCE bound on mutual information. ",
+        "bbox": [
+            173,
+            786,
+            826,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Contrastive RL (NCE): the actor and critic losses for our method. ",
+        "bbox": [
+            174,
+            80,
+            699,
+            94
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "from jax.numpy import einsum, eye   \nfrom optax import sigmoid_binary_cross_entropy   \ndef critic_loss(states, actions, future_states): sa_repr $=$ sa_encoder(states, actions) # (batch_dim, repr_dim) g_repr $-$ g_encoder(future_states) # (batch_dim, repr_dim) logits $-$ einsum('ik,jk->ij', sa_repr, g_repr) # <sa_repr[i], g_repr[j]> for all i,j return sigmoid_binary_cross_entropy(logits $=$ logits, labels $-$ eye(batch_size)) ",
+        "bbox": [
+            174,
+            104,
+            839,
+            193
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "def actor_loss(states, goals): actions $=$ policy.sample(states, goal $\\mathbf { \\Psi } =$ goals) # (batch_size, action_dim) sa_repr $=$ sa_encoder(states, actions) # (batch_dim, repr_dim) g_repr $-$ g_encoder(goals) # (batch_dim, repr_dim) logits $=$ einsum('ik,ik->i', sa_repr, g_repr) # <sa_repr[i], g_repr[i]> return $^ { - 1 . 0 * }$ logits ",
+        "bbox": [
+            174,
+            204,
+            741,
+            281
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Contrastive RL (NCE) is an on-policy algorithm because it only estimates the Q-function for the policy that collected the data. However, in practice, we take as many gradient steps on each transition as standard off-policy RL algorithms [40, 48]. Please see Appendix E for full implementation details. We will also release an efficient implementation based on ACME [57] and JAX [13]. On a single TPUv2, training proceeds at $1 1 0 0 \\frac { \\mathrm { b a t c h e s } } { \\mathrm { s e c } }$ for state-based tasks and $1 0 5 \\frac { \\mathrm { b a t c h e s } } { \\mathrm { s e c } }$ for image-based tasks; for comparison, our implementation of $\\mathrm { D r Q }$ on the same hardware setup runs at $2 8 \\frac { \\mathrm { b a t c h e s } } { \\sec }$ $3 . 9 \\times$ slower).6 Architectures and hyperparameters are described in Appendix E.7 ",
+        "bbox": [
+            173,
+            301,
+            826,
+            406
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.5 Convergence Guarantees ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            420,
+            387,
+            435
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In general, providing convergence guarantees for methods that perform relabeling is challenging. Most prior work offers no guarantees [6, 22, 23] or guarantees under only restrictive assumptions [41, 120]. ",
+        "bbox": [
+            173,
+            445,
+            826,
+            474
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To prove that contrastive RL converges, we will introduce an additional filtering step into the method, throwing away some training examples. Precisely, we exclude training examples $( s , a , s _ { f } )$ if the probability of the corresponding trajectory $\\tau _ { i : j } ~ = ~ ( s _ { i } , a _ { i } , s _ { i + 1 } , a _ { i + 1 } , \\cdot \\cdot \\cdot ~ , s _ { j } , a _ { j } )$ sampled from $\\pi ( \\tau \\mid s _ { g } )$ under the commanded goal $s _ { g }$ is very different from the trajectory’s probability under the actually-reached goal $s _ { j }$ : ",
+        "bbox": [
+            173,
+            479,
+            826,
+            549
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7b0b0533d88cb551a8fc316800c6477f87155dbff078626d9e3ef4be2ffd198d.jpg",
+        "text": "$$\n\\mathrm { E x c L U D E T R A J } ( \\tau _ { i : j } ) = \\delta \\left( \\left| \\frac { \\pi ( \\tau _ { i : j } \\mid s _ { g } ) } { \\pi ( \\tau _ { i : j } \\mid s _ { j } ) } - 1 \\right| > \\epsilon \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            553,
+            660,
+            584
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While this modification is necessary to prove convergence, ablation experiments in Appendix Fig. 13 show that the filtering step can actually hurt performance in practice, so we do not include this filtering step in the experiments in the main text. We can now prove that contrastive RL performs approximate policy improvement. ",
+        "bbox": [
+            173,
+            587,
+            825,
+            642
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Lemma 4.2 (Approximate policy improvement). Assume that states and actions are tabular and assume that the critic is Bayes-optimal. Let $\\pi ^ { \\prime } ( a \\mid s , s _ { g } )$ be the goal-conditioned policy obtained after one iteration of contrastive $R L$ with a filtering parameter of ϵ. Then this policy achieves higher rewards than the initial goal-conditioned policy: ",
+        "bbox": [
+            173,
+            645,
+            828,
+            696
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/73b35b2bb046261e44908390ecfdab5ce784bd45e85ae536e98d1ee1ff4e6c96.jpg",
+        "text": "$$\n\\Sigma _ { \\pi ^ { \\prime } ( \\tau | s _ { g } ) } \\left[ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r _ { s _ { g } } ( s _ { t } , a _ { t } ) \\right] \\geq \\mathbb { E } _ { \\pi ( \\tau | s _ { g } ) } \\left[ \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r _ { s _ { g } } ( s _ { t } , a _ { t } ) \\right] - \\frac { 2 \\gamma \\epsilon } { 1 - \\gamma } ~ f o r a l l g o a l s ~ s _ { g } \\in \\left\\{ s _ { g } ~ \\left| ~ p _ { g } ( s _ { g } ) > 0 \\right. \\right\\} ~ ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            700,
+            839,
+            739
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The proof is in Appendix B. This result shows that performing contrastive RL on static dataset results in one step of approximate policy improvement. Re-collecting data and then applying contrastive RL over and over again corresponds to approximate policy improvement (see [10, Lemma 6.2]). ",
+        "bbox": [
+            173,
+            757,
+            826,
+            801
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In summary, we have shown that applying contrastive learning to a particular choice of inputs results in an RL algorithm, one that learns a Q-function and (under some assumptions) converges to the reward-maximizing policy. Contrastive RL (NCE) is simple: it does not require multiple Q-values [40], target Q networks [88], data augmentation [69, 73], or auxiliary objectives [116, 137]. ",
+        "bbox": [
+            173,
+            806,
+            825,
+            863
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/1ca64a2563f82d848be02ca5d79a9b6c2d6a9a63377d212c19ae23f7a98b5dc1.jpg",
+        "image_caption": [
+            "Figure 2: Goal-conditioned RL. Contrastive RL (NCE) outperforms prior methods on most tasks. Baselines: HER [80] is a prototypical actor-critic method that uses hindsight relabeling [6]; Goal-conditioned behavioral cloning (GCBC) [22, 41, 83, 117] performs behavior cloning on relabeled experience; model-based fits a density model to the discounted state occupancy measure, similar on [21, 23, 60]. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            63,
+            816,
+            243
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.6 C-learning as Contrastive Learning ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            313,
+            459,
+            327
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "C-learning [29] is a special case of contrastive RL: it learns a critic function to distinguish future goals from random goals. Compared with contrastive RL (NCE), C-learning learns the classifier using temporal difference learning.8 Viewing C-learning as a special case of contrastive RL suggests that contrastive RL algorithms might be implemented in a variety of different ways, each with relative merits. For example, contrastive RL (NCE) is much simpler than C-learning and tends to perform a bit better. Appendix D introduces another member of the contrastive RL family (contrastive RL (NCE + C-learning)) that tends to yield the best performance . ",
+        "bbox": [
+            173,
+            338,
+            825,
+            435
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            454,
+            312,
+            472
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our experiments use goal-conditioned RL problems to compare contrastive RL algorithms to prior non-contrastive methods, including those that use data augmentation and auxiliary objectives. We then compare different members of the contrastive RL family, and show how contrastive RL can be effectively applied to the offline RL setting. Appendices E, F, and G contain experiments, visualizations, and failed experiments. ",
+        "bbox": [
+            174,
+            486,
+            826,
+            555
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Comparing to prior goal-conditioned RL methods ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            571,
+            560,
+            587
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Baselines. We compare three baselines. “HER” [80] is a goal-conditioned RL method that uses hindsight relabeling [6] with a high-performance actor-critic algorithm (TD3). This baseline is representative of a large class of prior work that uses hindsight relabeling [6, 76, 102, 106]. Like contrastive RL, this baseline does not assume access to a reward function. The second baseline is ",
+        "bbox": [
+            173,
+            597,
+            483,
+            720
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/24bf4c78e2ba76c9727632380dd31f4b4da6d0eed9bfd40baba1900e44491f7a.jpg",
+        "image_caption": [
+            "Figure 3: Environments. We show a subset of the goal-conditioned environments used in our experiments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            509,
+            602,
+            812,
+            679
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "goal-conditioned behavioral cloning (“GCBC”) [16, 22, 25, 41, 83, 96, 117, 120], which trains a policy to reach goal $s _ { g }$ by performing behavioral cloning on trajectories that reach state $s _ { g }$ . GCBC is a simple method that achieves excellent results [16, 25] and has the same inputs as our method $( ( s , a , s _ { f } )$ triplets). A third baseline is a model-based approach that fits a density model to the future state distribution $p ^ { \\pi ( \\cdot | \\cdot ) } ( s _ { t + } \\mid s , a )$ and trains a goal-conditioned policy to maximize the probability of the commanded goal. This baseline is similar to successor representations [21] and prior multi-step models [23, 60]. Both contrastive RL (Alg. 1) and this model-based approach encode the future state distribution, but the output dimension of this model-based method depends on the state dimension. We, therefore, expect this approach to excel in low-dimensional settings but struggle with image-based tasks. Where possible, we use the same hyperparameters for all methods. We will include additional representation learning baselines when studying representations in the subsequent section. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            862
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0324fcf7af9daa045c58010e6953799e910ecb3fa84c8569ea4158d45379765d.jpg",
+        "image_caption": [
+            "Figure 4: Representation learning for image-based tasks. While adding data augmentation and auxiliary representation objectives can boost the performance of the $_ { \\mathrm { T D } 3 + \\mathrm { H E R } }$ baseline, replacing the underlying goalconditioned RL algorithm with one that resembles contrastive representation learning (i.e., ours) yields a larger increase in success rates. Baselines: $\\mathtt { D r Q }$ [69] augments images and averages the Q-values across 4 augmentations; auto encoder (AE) adds an auxiliary reconstruction loss [32, 91, 93, 137]; CURL [116] applies RL on top of representations learned via augmentation-based contrastive learning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            65,
+            818,
+            191
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            285,
+            821,
+            313
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Tasks. We compare it to a suite of goal-conditioned tasks, mostly taken from prior work. Four standard manipulation tasks include fetch reach and fetch push from Plappert et al. [97] and sawyer push and sawyer bin from Yu et al. [139]. We evaluate these tasks both with state-based observations and (unlike most prior work) image-based observations. The sawyer bin task poses an exploration challenge, as the agent must learn to pick up an object from one bin and place it at a goal location in another bin; the agent does not receive any reward shaping or demonstrations. We include two navigation tasks: point Spiral11x11 is a 2D maze task with image observations and ant umaze [36] is a 111-dimensional locomotion task that presents a challenging low-level control problem. Where possible, we use the same initial state distribution, goal distribution, observations, and definition of success as prior work. Goals have the same dimension as the states, with one exception: on the ant umaze task, we used the global $X Y$ position as the goal. We illustrate three of the tasks to the right. The agent does not have access to any ground truth reward function. ",
+        "bbox": [
+            174,
+            329,
+            825,
+            494
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We report results in Fig. 2, using five random seeds for each experiment and plotting the mean and standard deviation across those random seeds. On the state-based tasks (Fig. 2a), most methods solve the easiest task (fetch reach) while only our method solves the most challenging task (sawyer bin). Our method also outperforms all prior methods on the two pushing tasks. The model-based baseline performs best on the ant umaze task, likely because learning a model is relatively easy when the goal is lower-dimensional (just the $X Y$ location). On the image-based tasks (Fig. 2b), most methods make progress on the two easiest tasks (fetch reach and point Spiral11x11); our method outperforms the baselines on the three more challenging tasks. Of particular note is the success on sawyer push and sawyer bin: while the success rate of our method remains below $50 \\%$ , no baselines make any progress on learning these tasks. These results suggest that contrastive RL (NCE) is a competitive goal-conditioned RL algorithm. ",
+        "bbox": [
+            174,
+            501,
+            825,
+            654
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 Comparing to prior representation learning methods ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            671,
+            580,
+            686
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We hypothesize that contrastive RL may automatically learn good representations. To test this hypothesis, we compare contrastive RL (NCE) to techniques proposed by prior work for representation learning. These include data augmentation [69, 73, 136] (“DrQ”) and auxiliary objectives based on an autoencoder [32, 91, 93, 137] (“AE”) and a contrastive learning objective (“CURL”) that generates positive examples using data augmentation, similar to prior work [89, 116, 118]. Because prior work has demonstrated these techniques in combination with actor-critic RL algorithms, we will use these techniques in combination with the actor-critic baseline from the previous section $( ^ { 6 6 } \\mathrm { T D } 3 + \\mathrm { H E R } ^ { \\prime \\prime } )$ ). While contrastive RL (NCE) resembles a contrastive representation learning method, it does not include any data augmentation or auxiliary representation learning objectives. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            821
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We show results in Fig. 4, with error bars again showing the mean and standard deviation across 5 random seeds. While adding the autoencoder improves the baseline on the fetch reach and adding DrQ improves the baseline on the sawyer push, contrastive RL (NCE) outperforms the prior methods on all tasks. Unlike these methods, contrastive RL does not use auxiliary objectives or additional domain knowledge in the form of image-appropriate data augmentations. These experiments do not show that representation learning is never useful, and do not show that contrastive ",
+        "bbox": [
+            174,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/7e580f4f14c0433f5ed7ccbf2ee289aa28efe0ce128a7053ace894649b8ff6f2.jpg",
+        "image_caption": [
+            "Figure 5: Contrastive RL design decisions. Generalizing C-learning to a family of contrastive RL algorithms allowed us to identify algorithms that are much simpler (contrastive RL (NCE)) and that consistently achieve higher performance (contrastive RL $\\mathrm { N C E } + \\mathrm { C } .$ -learning)). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            63,
+            816,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "RL cannot be improved with additional representation learning machinery. Rather, they show that designing RL algorithms that structurally resemble contrastive representation learning yields bigger improvements than simply adding representation learning tricks on top of existing RL algorithms. ",
+        "bbox": [
+            174,
+            318,
+            825,
+            359
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 Probing the dimensions of contrastive RL ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            387,
+            500,
+            402
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Up to now, we have focused on the specific instantiation of contrastive RL spelled out in Alg. 1. However, there is a whole family of RL algorithms with contrastive characteristics. C-learning is a contrastive RL algorithm that uses temporal difference learning (Sec. 4.6). Contrastive RL (CPC) is a variant of Alg. 1 based on the infoNCE objective [95] that we derive in Appendix C Contrastive RL $\\mathrm { \\Delta N C E + C }$ -learning) is a variant that combines C-learning with Alg. D (see Appendix D.). The aim of these experiments are to study whether generalizing C-learning to a family of contrastive RL algorithms was useful: do the simpler methods achieve similar performance, and do other methods achieve better performance? ",
+        "bbox": [
+            173,
+            417,
+            825,
+            529
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We present results in Fig. 5, again plotting the mean and standard deviation across five random seeds. Contrastive RL (CPC) outperforms contrastive RL (NCE) on three, suggesting that swapping one mutual information estimator for another can sometimes improve performance, though both estimators can be effective. C-learning outperforms contrastive RL (NCE) on three tasks but performs worse on other tasks. Contrastive RL $\\mathrm { \\mathrm { N C E } } + \\mathrm { C } .$ -learning) consistently ranks among the best methods. These experiments demonstrate that the prior contrastive RL method, C-learning [29], achieves good results on most tasks; generalizing C-learning to a family of contrastive RL algorithms resulting in new algorithms that achieve higher performance and can be much simpler. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            646
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 Partial Observability and Moving Cameras ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            674,
+            513,
+            689
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Many realistic robotics tasks exhibit partial observability, and have cameras that are not fixed but rather attached to moving robot parts. Our next experiment tests if contrastive RL can cope with these sorts of challenges. To study this question, we modified the sawyer push task so that the camera tracks the hand at a fixed distance, as if it were rigidly mounted to the arm. This means that, at the start of the episode, the scene is occluded by the wall at the edge of the table, so the agent cannot see the location of the puck (see Fig. 6 (left)). Nonetheless, contrastive RL (NCE) successfully handles this partial observability, achieving a success rate of around $3 5 \\%$ . Fig. 6 (left) shows an example rollout and Fig. 6 (right) shows the learning curve. For comparison, the success rate when using the fixed static camera was $7 5 \\%$ . Taken together, these results suggest that contrastive RL can cope with moving cameras and partial observability, while also suggesting that improved strategies (e.g., non-Markovian architectures) might achieve even better results. ",
+        "bbox": [
+            174,
+            704,
+            549,
+            842
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/88f16492b8f6fb5daa983d7e7bc5f87499a49a07a960c64339e857b73a76a74a.jpg",
+        "image_caption": [
+            "Figure 6: Partial observability and moving cameras. Contrastive RL can solve partially observed tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            566,
+            699,
+            820,
+            801
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/658b6d26ba0b153c421a4773957ce045e4165edba13e437dc5e11c9b769b6142.jpg",
+        "table_caption": [
+            "Table 1: Offline RL on D4RL AntMaze [36]. Contrastive RL outperforms all baselines in 5 out of 6 tasks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"5\">no TD</td><td colspan=\"2\">uses TD</td></tr><tr><td>BC</td><td>DT</td><td>GCBC</td><td>ContrastiveRL + BC 2 nets</td><td>5 nets</td><td>TD3+BC*</td><td>IQL*</td></tr><tr><td>umaze-v2</td><td>54.6</td><td>65.6</td><td>65.4</td><td>81.9 (±1.7)</td><td>79.8 (±1.4)</td><td>78.6</td><td>87.5</td></tr><tr><td>umaze-diverse-v2</td><td>45.6</td><td>51.2</td><td>60.9</td><td>75.4 (±3.5)</td><td>77.6 (±2.8)</td><td>71.4</td><td>62.2</td></tr><tr><td>medium-play-v2</td><td>0.0</td><td>1.0</td><td>58.1</td><td>71.5 (±5.2)</td><td>72.6 (±2.9)</td><td>10.6</td><td>71.2</td></tr><tr><td>medium-diverse-v2</td><td>0.0</td><td>0.6</td><td>67.3</td><td>72.5 (±2.8)</td><td>71.5 (±1.3)</td><td>3.0</td><td>70.0</td></tr><tr><td>large-play-v2</td><td>0.0</td><td>0.0</td><td>32.4</td><td>41.6 (±6.0)</td><td>48.6 (±4.4)</td><td>0.2</td><td>39.6</td></tr><tr><td>large-diverse-v2</td><td>0.0</td><td>0.2</td><td>36.9</td><td>49.3 (±6.3)</td><td>54.1 (±5.5)</td><td>0.0</td><td>47.5</td></tr><tr><td colspan=\"10\">* While TD3+BCand IQLreport results onthe-vO tasks,the change to-v2 has anegligible effecton TD methods [8].</td></tr></table>",
+        "bbox": [
+            199,
+            87,
+            794,
+            233
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.5 Contrastive RL for Offline RL ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            244,
+            423,
+            260
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our final experiment studies whether the benefits from contrastive RL (NCE) transfer to the offline RL setting, where the agent is prohibited from interacting with the environment. We use the benchmark AntMaze tasks from the D4RL benchmark [36], as these are goal-conditioned tasks commonly studied in the offline setting. ",
+        "bbox": [
+            173,
+            270,
+            825,
+            327
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We adapt contrastive RL (NCE) to the offline setting by adding an additional (goal-conditioned) behavioral cloning term to the policy objective (Eq. 7), using a coefficient of $\\lambda$ : ",
+        "bbox": [
+            169,
+            330,
+            825,
+            358
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/21bcd1611b2d50552ac7bc278cabbf6d151a481f344169657c3cc1c4f27ec368.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\pi ( a \\mid s , s _ { g } ) } \\mathbb { E } _ { \\pi ( a \\mid s , s _ { g } ) p ( s , a _ { \\mathrm { o i g } } , s _ { g } ) } \\left[ ( 1 - \\lambda ) \\cdot f ( s , a , s _ { f } = s _ { g } ) + \\lambda \\cdot \\log \\pi ( a _ { \\mathrm { o i g } } \\mid s , s _ { g } ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            359,
+            745,
+            383
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Note that setting $\\lambda = 1$ corresponds to GCBC [16, 22, 25, 41, 83, 96, 117, 120], which we will include as a baseline. Following $\\mathrm { T D } 3 { + } \\mathrm { B C }$ [39], we learn multiple critic functions (2 and 5) and take the minimum when computing the actor update. We also compare to prior offline RL methods that eschew TD learning: (unconditional) behavioral cloning (BC), the implementation of GCBC from [25] (which refers to GCBC as RvS-G), and a recent method based on the transformer architecture (DT [16]). Lastly, we compare with two more complex methods that use TD learning: $\\mathrm { T D } 3 { + } \\mathrm { B C }$ [39] and IQL [68]. Unlike contrastive RL and GCBC, these TD learning methods do not perform goal relabeling. We use the numbers reported for these baselines in prior work [25, 68]. ",
+        "bbox": [
+            173,
+            385,
+            825,
+            497
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 1, contrastive RL (NCE) outperforms all baselines on five of the six benchmark tasks. Of particular note are the most challenging “-large” tasks, where contrastive RL achieves a $7 \\%$ to $9 \\%$ absolute improvement over IQL. We note that IQL does not use goal relabeling, which is the bedrock of contrastive RL. Compared to baselines that do not use TD learning, the benefits are more pronounced, with a median (absolute) improvement over GCBC of $15 \\%$ . The performance of contrastive RL improves when increasing the number of critics from 2 to 5, suggesting that the key to solving more challenging offline RL tasks may be increased capacity, rather than TD learning. Taken together, these results show the value of contrastive RL for offline goal-conditioned tasks. ",
+        "bbox": [
+            173,
+            502,
+            825,
+            614
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            632,
+            299,
+            650
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we showed how contrastive representation learning can be used for goal-conditioned RL. This connection not only lets us re-interpret a prior RL method as performing contrastive learning, but also suggests a family of contrastive RL methods, which includes simpler algorithms, as well as algorithms that attain better overall performance. While this paper might be construed to imply that RL is more or less important than representation learning [72, 75, 112, 114], we have a different takeaway: that it may be enough to build RL algorithms that look like representation learning. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            746
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "One limitation of this work is that it looks only at the goal-conditioned RL problems. How these methods might be applied to arbitrary RL problems remains an open problem, though we note that recent algorithms for this setting [28] already bear a resemblance to contrastive RL. Whether the rich set of ideas from contrastive learning might be used to construct even better RL algorithms likewise remains an open question. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            821
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements. Thanks to Hubert Tsai, Martin Ma, and Simon Kornblith for discussions about contrastive learning. Thanks to Kamyar Ghasemipour, Suraj Nair, and anonymous reviewers for feedback on the paper. Thanks to Ofir Nachum, Daniel Zheng, and the JAX and Acme teams for helping to release and debug the code. This material is supported by the Fannie and John Hertz Foundation and the NSF GRFP (DGE1745016). UC Berkeley research is also supported by gifts from Alibaba, Amazon Web Services, Ant Financial, CapitalOne, Ericsson, Facebook, Futurewei, Google, Intel, Microsoft, Nvidia, Scotiabank, Splunk and VMware. ",
+        "bbox": [
+            174,
+            834,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Achiam, J., Edwards, H., Amodei, D., and Abbeel, P. (2018). Variational option discovery algorithms. arXiv preprint arXiv:1807.10299.   \n[2] Achiam, J., Knight, E., and Abbeel, P. (2019). Towards characterizing divergence in deep Q-learning. arXiv preprint arXiv:1903.08894.   \n[3] Alain, G. and Bengio, Y. (2016). Understanding intermediate layers using linear classifier probes. arXiv preprint arXiv:1610.01644.   \n[4] Anand, A., Racah, E., Ozair, S., Bengio, Y., Côté, M.-A., and Hjelm, R. D. (2019). Unsupervised state representation learning in Atari. Advances in Neural Information Processing Systems, 32.   \n[5] Andreas, J., Klein, D., and Levine, S. (2017). Modular multitask reinforcement learning with policy sketches. In International Conference on Machine Learning, pages 166–175. PMLR.   \n[6] Andrychowicz, M., Crow, D., Ray, A., Schneider, J., Fong, R., Welinder, P., McGrew, B., Tobin, J., Abbeel, P., and Zaremba, W. (2017). Hindsight experience replay. In NeurIPS.   \n[7] Annasamy, R. M. and Sycara, K. (2019). Towards better interpretability in deep Q-networks. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 4561–4569.   \n[8] Authors, I. (2022). Private Communication.   \n[9] Barreto, A., Dabney, W., Munos, R., Hunt, J. J., Schaul, T., van Hasselt, H. P., and Silver, D. (2017). Successor features for transfer in reinforcement learning. Advances in neural information processing systems, 30.   \n[10] Bertsekas, D. P. and Tsitsiklis, J. N. (1996). Neuro-dynamic programming. Athena Scientific.   \n[11] Blier, L., Tallec, C., and Ollivier, Y. (2021). Learning successor states and goal-dependent values: A mathematical viewpoint. arXiv preprint arXiv:2101.07123.   \n[12] Borsa, D., Barreto, A., Quan, J., Mankowitz, D., Munos, R., Van Hasselt, H., Silver, D., and Schaul, T. (2018). Universal successor features approximators. arXiv preprint arXiv:1812.07626.   \n[13] Bradbury, J., Frostig, R., Hawkins, P., Johnson, M. J., Leary, C., Maclaurin, D., Necula, G., Paszke, A., VanderPlas, J., Wanderman-Milne, S., and Zhang, Q. (2018). JAX: composable transformations of Python+NumPy programs.   \n[14] Brown, D., Goo, W., Nagarajan, P., and Niekum, S. (2019). Extrapolating beyond suboptimal demonstrations via inverse reinforcement learning from observations. In International conference on machine learning, pages 783–792. PMLR.   \n[15] Chane-Sane, E., Schmid, C., and Laptev, I. (2021). Goal-conditioned reinforcement learning with imagined subgoals. In International Conference on Machine Learning, pages 1430–1440. PMLR.   \n[16] Chen, L., Lu, K., Rajeswaran, A., Lee, K., Grover, A., Laskin, M., Abbeel, P., Srinivas, A., and Mordatch, I. (2021). Decision transformer: Reinforcement learning via sequence modeling. Advances in neural information processing systems, 34.   \n[17] Chen, T., Kornblith, S., Norouzi, M., and Hinton, G. E. (2020). A simple framework for contrastive learning of visual representations. ArXiv, abs/2002.05709.   \n[18] Chen, X. and He, K. (2021). Exploring simple siamese representation learning. 2021 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 15745–15753.   \n[19] Choi, J., Sharma, A., Lee, H., Levine, S., and Gu, S. S. (2021). Variational empowerment as representation learning for goal-conditioned reinforcement learning. In International Conference on Machine Learning, pages 1953–1963. PMLR.   \n[20] Christiano, P., Leike, J., Brown, T. B., Martic, M., Legg, S., and Amodei, D. (2017). Deep reinforcement learning from human preferences. arXiv preprint arXiv:1706.03741.   \n[21] Dayan, P. (1993). Improving generalization for temporal difference learning: The successor representation. Neural Computation, 5(4):613–624.   \n[22] Ding, Y., Florensa, C., Abbeel, P., and Phielipp, M. (2019). Goal-conditioned imitation learning. Advances in Neural Information Processing Systems, 32:15324–15335.   \n[23] Dosovitskiy, A. and Koltun, V. (2016). Learning to act by predicting the future. arXiv preprint arXiv:1611.01779.   \n[24] Du, Y., Gan, C., and Isola, P. (2021). Curious representation learning for embodied intelligence. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 10408–10417.   \n[25] Emmons, S., Eysenbach, B., Kostrikov, I., and Levine, S. (2021). Rvs: What is essential for offline rl via supervised learning? arXiv preprint arXiv:2112.10751.   \n[26] Eysenbach, B., Geng, X., Levine, S., and Salakhutdinov, R. (2020). Rewriting history with inverse RL: Hindsight inference for policy improvement. ArXiv, abs/2002.11089.   \n[27] Eysenbach, B., Gupta, A., Ibarz, J., and Levine, S. (2018). Diversity is all you need: Learning skills without a reward function. In International Conference on Learning Representations.   \n[28] Eysenbach, B., Levine, S., and Salakhutdinov, R. R. (2021a). Replacing rewards with examples: Examplebased policy search via recursive classification. Advances in Neural Information Processing Systems, 34.   \n[29] Eysenbach, B., Salakhutdinov, R., and Levine, S. (2021b). C-learning: Learning to achieve goals via recursive classification. ArXiv, abs/2011.08909.   \n[30] Eysenbach, B., Salakhutdinov, R. R., and Levine, S. (2019). Search on the replay buffer: Bridging planning and reinforcement learning. Advances in Neural Information Processing Systems, 32.   \n[31] Eysenbach, B., Udatha, S., Levine, S., and Salakhutdinov, R. (2022). Imitating past successes can be very suboptimal. arXiv preprint arXiv:2206.03378.   \n[32] Finn, C., Tan, X. Y., Duan, Y., Darrell, T., Levine, S., and Abbeel, P. (2016). Deep spatial autoencoders for visuomotor learning. In 2016 IEEE International Conference on Robotics and Automation (ICRA), pages 512–519. IEEE.   \n[33] Fischinger, D., Vincze, M., and Jiang, Y. (2013). Learning grasps for unknown objects in cluttered scenes. In 2013 IEEE international conference on robotics and automation, pages 609–616. IEEE.   \n[34] Florensa, C., Degrave, J., Heess, N., Springenberg, J. T., and Riedmiller, M. (2019). Self-supervised learning of image embedding for continuous control. arXiv preprint arXiv:1901.00943.   \n[35] Florensa, C., Held, D., Geng, X., and Abbeel, P. (2018). Automatic goal generation for reinforcement learning agents. In International conference on machine learning, pages 1515–1528. PMLR.   \n[36] Fu, J., Kumar, A., Nachum, O., Tucker, G., and Levine, S. (2020). D4RL: Datasets for deep data-driven reinforcement learning. arXiv preprint arXiv:2004.07219.   \n[37] Fu, J., Luo, K., and Levine, S. (2017). Learning robust rewards with adversarial inverse reinforcement learning. arXiv preprint arXiv:1710.11248.   \n[38] Fu, J., Singh, A., Ghosh, D., Yang, L., and Levine, S. (2018). Variational inverse control with events: A general framework for data-driven reward definition. In NeurIPS.   \n[39] Fujimoto, S. and Gu, S. S. (2021). A minimalist approach to offline reinforcement learning. Advances in Neural Information Processing Systems, 34.   \n[40] Fujimoto, S., Hoof, H., and Meger, D. (2018). Addressing function approximation error in actor-critic methods. In International conference on machine learning, pages 1587–1596. PMLR.   \n[41] Ghosh, D., Gupta, A., Reddy, A., Fu, J., Devin, C. M., Eysenbach, B., and Levine, S. (2020). Learning to reach goals via iterated supervised learning. In International Conference on Learning Representations.   \n[42] Gregor, K., Rezende, D. J., and Wierstra, D. (2016). Variational intrinsic control. arXiv preprint arXiv:1611.07507.   \n[43] Grill, J.-B., Strub, F., Altch’e, F., Tallec, C., Richemond, P. H., Buchatskaya, E., Doersch, C., Pires, B. Á., Guo, Z. D., Azar, M. G., Piot, B., Kavukcuoglu, K., Munos, R., and Valko, M. (2020). Bootstrap your own latent: A new approach to self-supervised learning. ArXiv, abs/2006.07733.   \n[44] Guo, Z. D., Azar, M. G., Piot, B., Pires, B. A., and Munos, R. (2018). Neural predictive belief representations. arXiv preprint arXiv:1811.06407.   \n[45] Guo, Z. D., Pires, B. A., Piot, B., Grill, J.-B., Altché, F., Munos, R., and Azar, M. G. (2020). Bootstrap latent-predictive representations for multitask reinforcement learning. In International Conference on Machine Learning, pages 3875–3886. PMLR.   \n[46] Gutmann, M. U. and Hyvärinen, A. (2012). Noise-contrastive estimation of unnormalized statistical models, with applications to natural image statistics. Journal of machine learning research, 13(2).   \n[47] Ha, D. and Schmidhuber, J. (2018). World models. arXiv preprint arXiv:1803.10122.   \n[48] Haarnoja, T., Zhou, A., Abbeel, P., and Levine, S. (2018). Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. In International conference on machine learning, pages 1861–1870. PMLR.   \n[49] Hafner, D., Lillicrap, T., Ba, J., and Norouzi, M. (2019a). Dream to control: Learning behaviors by latent imagination. arXiv preprint arXiv:1912.01603.   \n[50] Hafner, D., Lillicrap, T., Fischer, I., Villegas, R., Ha, D., Lee, H., and Davidson, J. (2019b). Learning latent dynamics for planning from pixels. In International conference on machine learning, pages 2555–2565. PMLR.   \n[51] Han, T., Xie, W., and Zisserman, A. (2020). Self-supervised co-training for video representation learning. Advances in Neural Information Processing Systems, 33:5679–5690.   \n[52] Hansen, S., Dabney, W., Barreto, A., Van de Wiele, T., Warde-Farley, D., and Mnih, V. (2019). Fast task inference with variational intrinsic successor features. arXiv preprint arXiv:1906.05030.   \n[53] He, K., Fan, H., Wu, Y., Xie, S., and Girshick, R. (2020). Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9729–9738.   \n[54] Hjelm, R. D., Fedorov, A., Lavoie-Marchildon, S., Grewal, K., Bachman, P., Trischler, A., and Bengio, Y. (2018). Learning deep representations by mutual information estimation and maximization. arXiv preprint arXiv:1808.06670.   \n[55] Ho, J. and Ermon, S. (2016). Generative adversarial imitation learning. Advances in neural information processing systems, 29:4565–4573.   \n[56] Hoffer, E. and Ailon, N. (2015). Deep metric learning using triplet network. In International workshop on similarity-based pattern recognition, pages 84–92. Springer.   \n[57] Hoffman, M., Shahriari, B., Aslanides, J., Barth-Maron, G., Behbahani, F., Norman, T., Abdolmaleki, A., Cassirer, A., Yang, F., Baumli, K., Henderson, S., Novikov, A., Colmenarejo, S. G., Cabi, S., Gulcehre, C., Paine, T. L., Cowie, A., Wang, Z., Piot, B., and de Freitas, N. (2020). Acme: A research framework for distributed reinforcement learning. arXiv preprint arXiv:2006.00979.   \n[58] Hong, Z.-W., Yang, G., and Agrawal, P. (2022). Bilinear value networks. arXiv preprint arXiv:2204.13695.   \n[59] Ichter, B., Sermanet, P., and Lynch, C. (2020). Broadly-exploring, local-policy trees for long-horizon task planning. arXiv preprint arXiv:2010.06491.   \n[60] Janner, M., Mordatch, I., and Levine, S. (2020). gamma-models: Generative temporal difference learning for infinite-horizon prediction. Advances in Neural Information Processing Systems, 33:1724–1735.   \n[61] Jozefowicz, R., Vinyals, O., Schuster, M., Shazeer, N., and Wu, Y. (2016). Exploring the limits of language modeling. arXiv preprint arXiv:1602.02410.   \n[62] Kaelbling, L. P. (1993). Learning to achieve goals. In IJCAI, pages 1094–1099. Citeseer.   \n[63] Kalashnikov, D., Varley, J., Chebotar, Y., Swanson, B., Jonschkowski, R., Finn, C., Levine, S., and Hausman, K. (2021). Mt-opt: Continuous multi-task robotic reinforcement learning at scale. ArXiv, abs/2104.08212.   \n[64] Kish, L. (1965). Survey sampling. John Wiley & Sons.   \n[65] Klingemann, M. (2016). Raster fairy. https://github.com/bmcfee/RasterFairy.   \n[66] Konda, V. and Tsitsiklis, J. (1999). Actor-critic algorithms. Advances in neural information processing systems, 12.   \n[67] Konyushkova, K., Zolna, K., Aytar, Y., Novikov, A., Reed, S., Cabi, S., and de Freitas, N. (2020). Semi-supervised reward learning for offline reinforcement learning. arXiv preprint arXiv:2012.06899.   \n[68] Kostrikov, I., Nair, A., and Levine, S. (2021). Offline reinforcement learning with implicit Q-learning. arXiv preprint arXiv:2110.06169.   \n[69] Kostrikov, I., Yarats, D., and Fergus, R. (2020). Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. arXiv preprint arXiv:2004.13649.   \n[70] Kumar, A., Agarwal, R., Ghosh, D., and Levine, S. (2020). Implicit under-parameterization inhibits data-efficient deep reinforcement learning. arXiv preprint arXiv:2010.14498.   \n[71] Lange, S. and Riedmiller, M. (2010). Deep auto-encoder neural networks in reinforcement learning. In The 2010 International Joint Conference on Neural Networks (IJCNN), pages 1–8. IEEE.   \n[72] Langford, J. (2010). Specializations of the master problem.   \n[73] Laskin, M., Lee, K., Stooke, A., Pinto, L., Abbeel, P., and Srinivas, A. (2020). Reinforcement learning with augmented data. Advances in Neural Information Processing Systems, 33:19884–19895.   \n[74] Laskin, M., Liu, H., Peng, X. B., Yarats, D., Rajeswaran, A., and Abbeel, P. (2021). CIC: Contrastive intrinsic control for unsupervised skill discovery. In Deep RL Workshop NeurIPS 2021.   \n[75] LeCun, Y. (2016). Predictive learning. https://www.youtube.com/watch?v $=$ Ount2Y4qxQo. Keynote Talk.   \n[76] Levy, A., Konidaris, G., Platt, R., and Saenko, K. (2017). Learning multi-level hierarchies with hindsight. arXiv preprint arXiv:1712.00948.   \n[77] Levy, O. and Goldberg, Y. (2014). Neural word embedding as implicit matrix factorization. Advances in neural information processing systems, 27.   \n[78] Li, A., Pinto, L., and Abbeel, P. (2020). Generalized hindsight for reinforcement learning. Advances in neural information processing systems, 33:7754–7767.   \n[79] Liang, Y., Machado, M. C., Talvitie, E., and Bowling, M. (2015). State of the art control of Atari games using shallow reinforcement learning. arXiv preprint arXiv:1512.01563.   \n[80] Lin, X., Baweja, H. S., and Held, D. (2019). Reinforcement learning without ground-truth state. ArXiv, abs/1905.07866.   \n[81] Liu, H. and Abbeel, P. (2021). Aps: Active pretraining with successor features. In International Conference on Machine Learning, pages 6736–6747. PMLR.   \n[82] Liu, K., Kurutach, T., Tung, C., Abbeel, P., and Tamar, A. (2020). Hallucinative topological memory for zero-shot visual planning. In International Conference on Machine Learning, pages 6259–6270. PMLR.   \n[83] Lynch, C., Khansari, M., Xiao, T., Kumar, V., Tompson, J., Levine, S., and Sermanet, P. (2020). Learning latent plans from play. In Conference on Robot Learning, pages 1113–1132. PMLR.   \n[84] Ma, Z. and Collins, M. (2018). Noise contrastive estimation and negative sampling for conditional models: Consistency and statistical efficiency. In EMNLP.   \n[85] Mendonca, R., Rybkin, O., Daniilidis, K., Hafner, D., and Pathak, D. (2021). Discovering and achieving goals via world models. Advances in Neural Information Processing Systems, 34.   \n[86] Mikolov, T., Sutskever, I., Chen, K., Corrado, G. S., and Dean, J. (2013). Distributed representations of words and phrases and their compositionality. Advances in neural information processing systems, 26.   \n[87] Mnih, A. and Teh, Y. W. (2012). A fast and simple algorithm for training neural probabilistic language models. In ICML.   \n[88] Mnih, V., Kavukcuoglu, K., Silver, D., Graves, A., Antonoglou, I., Wierstra, D., and Riedmiller, M. (2013). Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602.   \n[89] Nachum, O., Gu, S., Lee, H., and Levine, S. (2018a). Near-optimal representation learning for hierarchical reinforcement learning. In International Conference on Learning Representations.   \n[90] Nachum, O., Gu, S. S., Lee, H., and Levine, S. (2018b). Data-efficient hierarchical reinforcement learning. Advances in neural information processing systems, 31.   \n[91] Nair, A. V., Pong, V., Dalal, M., Bahl, S., Lin, S., and Levine, S. (2018). Visual reinforcement learning with imagined goals. Advances in Neural Information Processing Systems, 31:9191–9200.   \n[92] Nair, S., Mitchell, E., Chen, K., Savarese, S., Finn, C., et al. (2022). Learning language-conditioned robot behavior from offline data and crowd-sourced annotation. In Conference on Robot Learning, pages 1303–1315. PMLR.   \n[93] Nasiriany, S., Pong, V. H., Lin, S., and Levine, S. (2019). Planning with goal-conditioned policies. In NeurIPS.   \n[94] Nowozin, S., Cseke, B., and Tomioka, R. (2016). f-GAN: Training generative neural samplers using variational divergence minimization. Advances in neural information processing systems, 29.   \n[95] Oord, A. v. d., Li, Y., and Vinyals, O. (2018). Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748.   \n[96] Paster, K., McIlraith, S. A., and Ba, J. (2020). Planning from pixels using inverse dynamics models. arXiv preprint arXiv:2012.02419.   \n[97] Plappert, M., Andrychowicz, M., Ray, A., McGrew, B., Baker, B., Powell, G., Schneider, J., Tobin, J., Chociej, M., Welinder, P., et al. (2018). Multi-goal reinforcement learning: Challenging robotics environments and request for research. arXiv preprint arXiv:1802.09464.   \n[98] Pong, V. H., Dalal, M., Lin, S., Nair, A., Bahl, S., and Levine, S. (2019). Skew-fit: State-covering self-supervised reinforcement learning. arXiv preprint arXiv:1903.03698.   \n[99] Poole, B., Ozair, S., Van Den Oord, A., Alemi, A., and Tucker, G. (2019). On variational bounds of mutual information. In International Conference on Machine Learning, pages 5171–5180. PMLR.   \n[100] Qiu, S., Wang, L., Bai, C., Yang, Z., and Wang, Z. (2022). Contrastive ucb: Provably efficient contrastive self-supervised learning in online reinforcement learning. In International Conference on Machine Learning, pages 18168–18210. PMLR.   \n[101] Rakelly, K., Gupta, A., Florensa, C., and Levine, S. (2021). Which mutual-information representation learning objectives are sufficient for control? ArXiv, abs/2106.07278.   \n[102] Riedmiller, M., Hafner, R., Lampe, T., Neunert, M., Degrave, J., Wiele, T., Mnih, V., Heess, N., and Springenberg, J. T. (2018). Learning by playing solving sparse reward tasks from scratch. In International conference on machine learning, pages 4344–4353. PMLR.   \n[103] Rudner, T. G., Pong, V., McAllister, R., Gal, Y., and Levine, S. (2021). Outcome-driven reinforcement learning via variational inference. Advances in Neural Information Processing Systems, 34.   \n[104] Rybkin, O., Zhu, C., Nagabandi, A., Daniilidis, K., Mordatch, I., and Levine, S. (2021). Model-based reinforcement learning via latent-space collocation. In International Conference on Machine Learning, pages 9190–9201. PMLR.   \n[105] Savinov, N., Dosovitskiy, A., and Koltun, V. (2018). Semi-parametric topological memory for navigation. In International Conference on Learning Representations.   \n[106] Schaul, T., Horgan, D., Gregor, K., and Silver, D. (2015). Universal value function approximators. In International conference on machine learning, pages 1312–1320. PMLR.   \n[107] Schmeckpeper, K., Xie, A., Rybkin, O., Tian, S., Daniilidis, K., Levine, S., and Finn, C. (2020). Learning predictive models from observation and interaction. In European Conference on Computer Vision, pages 708–725. Springer.   \n[108] Schroff, F., Kalenichenko, D., and Philbin, J. (2015). Facenet: A unified embedding for face recognition and clustering. 2015 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 815–823.   \n[109] Sermanet, P., Lynch, C., Chebotar, Y., Hsu, J., Jang, E., Schaal, S., Levine, S., and Brain, G. (2018). Time-contrastive networks: Self-supervised learning from video. In 2018 IEEE international conference on robotics and automation (ICRA), pages 1134–1141. IEEE.   \n[110] Sharma, A., Gu, S., Levine, S., Kumar, V., and Hausman, K. (2019). Dynamics-aware unsupervised discovery of skills. In International Conference on Learning Representations.   \n[111] Shu, R., Nguyen, T., Chow, Y., Pham, T., Than, K., Ghavamzadeh, M., Ermon, S., and Bui, H. (2020). Predictive coding for locally-linear control. In International Conference on Machine Learning, pages 8862–8871. PMLR.   \n[112] Silver, D., Singh, S., Precup, D., and Sutton, R. S. (2021). Reward is enough. Artificial Intelligence, 299:103535.   \n[113] Sohn, K. (2016). Improved deep metric learning with multi-class n-pair loss objective. In NeurIPS.   \n[114] Srinivas, A. and Abbeel, P. (2021). Unsupervised learning for reinforcement learning. Tutorial.   \n[115] Srinivas, A., Jabri, A., Abbeel, P., Levine, S., and Finn, C. (2018). Universal planning networks. ArXiv, abs/1804.00645.   \n[116] Srinivas, A., Laskin, M., and Abbeel, P. (2020). Curl: Contrastive unsupervised representations for reinforcement learning. arXiv preprint arXiv:2004.04136.   \n[117] Srivastava, R. K., Shyam, P., Mutz, F., Jaskowski, W., and Schmidhuber, J. (2019). Training agents using ´ upside-down reinforcement learning. arXiv preprint arXiv:1912.02877.   \n[118] Stooke, A., Lee, K., Abbeel, P., and Laskin, M. (2021). Decoupling representation learning from reinforcement learning. In International Conference on Machine Learning, pages 9870–9879. PMLR.   \n[119] Such, F. P., Madhavan, V., Liu, R., Wang, R., Castro, P. S., Li, Y., Zhi, J., Schubert, L., Bellemare, M. G., Clune, J., et al. (2018). An atari model zoo for analyzing, visualizing, and comparing deep reinforcement learning agents. arXiv preprint arXiv:1812.07069.   \n[120] Sun, H., Li, Z., Liu, X., Zhou, B., and Lin, D. (2019). Policy continuation with hindsight inverse dynamics. Advances in Neural Information Processing Systems, 32:10265–10275.   \n[121] Teh, Y., Bapst, V., Czarnecki, W. M., Quan, J., Kirkpatrick, J., Hadsell, R., Heess, N., and Pascanu, R. (2017). Distral: Robust multitask reinforcement learning. Advances in neural information processing systems, 30.   \n[122] Tian, Y., Krishnan, D., and Isola, P. (2020). Contrastive multiview coding. In Computer Vision–ECCV 2020: 16th European Conference, Glasgow, UK, August 23–28, 2020, Proceedings, Part XI 16, pages 776–794. Springer.   \n[123] Tsai, Y.-H., Zhao, H., Yamada, M., Morency, L.-P., and Salakhutdinov, R. (2020). Neural methods for point-wise dependency estimation. In Proceedings of the Neural Information Processing Systems Conference (Neurips).   \n[124] Tschannen, M., Djolonga, J., Rubenstein, P. K., Gelly, S., and Lucic, M. (2019). On mutual information maximization for representation learning. arXiv preprint arXiv:1907.13625.   \n[125] Venkattaramanujam, S., Crawford, E., Doan, T. V., and Precup, D. (2019). Self-supervised learning of distance functions for goal-conditioned reinforcement learning. ArXiv, abs/1907.02998.   \n[126] Wang, H., Miahi, E., White, M., Machado, M. C., Abbas, Z., Kumaraswamy, R., Liu, V., and White, A. (2022). Investigating the properties of neural network representations in reinforcement learning. arXiv preprint arXiv:2203.15955.   \n[127] Warde-Farley, D., Van de Wiele, T., Kulkarni, T., Ionescu, C., Hansen, S., and Mnih, V. (2018). Unsupervised control through non-parametric discriminative rewards. arXiv preprint arXiv:1811.11359.   \n[128] Watter, M., Springenberg, J., Boedecker, J., and Riedmiller, M. (2015). Embed to control: A locally linear latent dynamics model for control from raw images. Advances in neural information processing systems, 28.   \n[129] Weinberger, K. Q. and Saul, L. K. (2005). Distance metric learning for large margin nearest neighbor classification. In NIPS.   \n[130] Wilson, A., Fern, A., Ray, S., and Tadepalli, P. (2007). Multi-task reinforcement learning: a hierarchical bayesian approach. In Proceedings of the 24th international conference on Machine learning, pages 1015– 1022.   \n[131] Wu, Y., Tucker, G., and Nachum, O. (2018a). The Laplacian in RL: Learning representations with efficient approximations. arXiv preprint arXiv:1810.04586.   \n[132] Wu, Z., Xiong, Y., Yu, S. X., and Lin, D. (2018b). Unsupervised feature learning via non-parametric instance discrimination. 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 3733–3742.   \n[133] Xie, A., Singh, A., Levine, S., and Finn, C. (2018). Few-shot goal inference for visuomotor learning and planning. In Conference on Robot Learning, pages 40–52. PMLR.   \n[134] Xu, D. and Denil, M. (2019). Positive-unlabeled reward learning. arXiv preprint arXiv:1911.00459.   \n[135] Yang, G., Ajay, A., and Agrawal, P. (2021). Overcoming the spectral bias of neural value approximation. In International Conference on Learning Representations.   \n[136] Yarats, D., Fergus, R., Lazaric, A., and Pinto, L. (2021a). Mastering visual continuous control: Improved data-augmented reinforcement learning. arXiv preprint arXiv:2107.09645.   \n[137] Yarats, D., Zhang, A., Kostrikov, I., Amos, B., Pineau, J., and Fergus, R. (2021b). Improving sample efficiency in model-free reinforcement learning from images. In AAAI.   \n[138] Yu, T., Kumar, S., Gupta, A., Levine, S., Hausman, K., and Finn, C. (2020a). Gradient surgery for multi-task learning. Advances in Neural Information Processing Systems, 33:5824–5836.   \n[139] Yu, T., Quillen, D., He, Z., Julian, R., Hausman, K., Finn, C., and Levine, S. (2020b). Meta-world: A benchmark and evaluation for multi-task and meta reinforcement learning. In Conference on Robot Learning, pages 1094–1100. PMLR.   \n[140] Zhang, A., McAllister, R. T., Calandra, R., Gal, Y., and Levine, S. (2020a). Learning invariant representations for reinforcement learning without reconstruction. In International Conference on Learning Representations.   \n[141] Zhang, M., Vikram, S., Smith, L., Abbeel, P., Johnson, M., and Levine, S. (2019). Solar: Deep structured representations for model-based reinforcement learning. In International Conference on Machine Learning, pages 7444–7453. PMLR.   \n[142] Zhang, S., Liu, B., and Whiteson, S. (2020b). Gradientdice: Rethinking generalized offline estimation of stationary values. In International Conference on Machine Learning, pages 11194–11203. PMLR.   \n[143] Zhang, T., Ren, T., Yang, M., Gonzalez, J., Schuurmans, D., and Dai, B. (2022). Making linear mdps practical via contrastive representation learning. In International Conference on Machine Learning, pages 26447–26466. PMLR.   \n[144] Zhao, R., Sun, X., and Tresp, V. (2019). Maximum entropy-regularized multi-goal reinforcement learning. In International Conference on Machine Learning, pages 7553–7562. PMLR.   \n[145] Ziebart, B. D. (2010). Modeling purposeful adaptive behavior with the principle of maximum causal entropy. Carnegie Mellon University.   \n[146] Zolna, K., Reed, S., Novikov, A., Colmenarejo, S. G., Budden, D., Cabi, S., Denil, M., de Freitas, N., and Wang, Z. (2019). Task-relevant adversarial imitation learning. arXiv preprint arXiv:1910.01077. ",
+        "bbox": [
+            171,
+            82,
+            828,
+            921
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            64,
+            828,
+            916
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            77,
+            828,
+            920
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            70,
+            828,
+            919
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            58,
+            828,
+            915
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            61,
+            828,
+            921
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            84,
+            828,
+            583
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] The main claims are that (1) contrastive learning can be used to learn a Q-function (Proof in Appendix B) and that (2) contrastive RL methods can outperform non-contrastive RL algorithms on goal-conditioned RL tasks (results in Fig. 2).   \n(b) Did you describe the limitations of your work? [Yes] See Sec. 6.   \n(c) Did you discuss any potential negative societal impacts of your work? [No] While RL broadly might be used for applications with both positive and negative outcomes, our algorithmic contributions are not tied to any particular application.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            136,
+            825,
+            295
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            299,
+            493,
+            314
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] See Appendix B ",
+        "bbox": [
+            238,
+            318,
+            795,
+            349
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            353,
+            393,
+            367
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [No] We have included all experimental details in Appendix E; code will be released upon acceptance.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Appendix E.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] All figures show 5 random seeds, witht error bars corresponding to the mean and standard deviation across these seeds.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] Sec. 4.4 describes the training speed on one TPUv2. ",
+        "bbox": [
+            238,
+            372,
+            825,
+            531
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            209,
+            536,
+            823,
+            551
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [N/A]   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            554,
+            825,
+            676
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            680,
+            705,
+            695
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            699,
+            825,
+            787
+        ],
+        "page_idx": 17
+    }
+]