CURL: Contrastive Unsupervised Representations for Reinforcement Learning

Aravind Srinivas$^{}$, Michael Laskin$^{}$, Pieter Abbeel

University of California, Berkeley, BAIR

Correspond to: Aravind Srinivas, Michael Laskin <aravind_srinivas, [email protected]>

Keywords: Contrastive Learning, Reinforcement Learning

Abstract

We present CURL: Contrastive Unsupervised Representations for Reinforcement Learning. CURL extracts high-level features from raw pixels using contrastive learning and performs off-policy control on top of the extracted features. CURL outperforms prior pixel-based methods, both model-based and model-free, on complex tasks in the DeepMind Control Suite and Atari Games showing 1.9x and 1.2x performance gains at the 100K environment and interaction steps benchmarks respectively. On the DeepMind Control Suite, CURL is the first image-based algorithm to nearly match the sample-efficiency of methods that use state-based features. Our code is open-sourced and available at https://www.github.com/MishaLaskin/curl.

Executive Summary: Training autonomous systems with reinforcement learning directly from raw visual inputs, such as camera feeds or pixel displays, typically requires prohibitive amounts of data and time. While agents learning from direct physical measurements (such as joint angles and velocities) learn efficiently, learning from images has historically been slow and resource-intensive. This limitation creates significant bottlenecks for real-world applications like robotics, where collecting millions of interactions is physically constrained, costly, and wear-intensive.

The article introduces and evaluates CURL (Contrastive Unsupervised Representations for Reinforcement Learning), a framework designed to dramatically improve the data efficiency of visual reinforcement learning. The core objective is to demonstrate that coupling standard control algorithms with contrastive self-supervised learning enables agents to extract high-level semantic features directly from raw image pixels without needing complex world models or specialized reward tuning.

To evaluate this approach, the authors integrated CURL into standard model-free algorithms—using Soft Actor-Critic for continuous control and a data-efficient Rainbow DQN for discrete actions. The system extracts matching representations from randomly cropped, temporally stacked visual frames using an auxiliary contrastive objective. The authors benchmarked CURL across 16 continuous control environments from the DeepMind Control Suite and 26 discrete games from the Atari 2600 benchmark, comparing performance under strict data budget constraints (100,000 to 500,000 environment steps, equivalent to roughly a few hours of real-time experience).

The evaluation yielded several key findings. First, on the DeepMind Control Suite at 100,000 steps, CURL achieved a 1.9-fold higher median score and demonstrated 4.5-fold higher data efficiency compared to Dreamer, a leading predictive model-based method. Second, CURL is the first image-based method to match the data efficiency and median performance of algorithms trained directly on low-level physical state features across several continuous control tasks. Third, on the Atari 100,000-step benchmark, CURL outperformed prior methods with a 1.2-fold median performance improvement over leading approaches, improved upon Efficient Rainbow on 19 out of 26 games, and achieved superhuman performance on two titles (James Bond and Krull).

These findings indicate that visual control agents do not need complex, computationally heavy world models or environment reconstruction pipelines to achieve high sample efficiency. Instead, simple instance-level contrastive learning allows standard algorithms to extract the underlying physical dynamics directly from pixels. This provides a direct path toward reducing training times, cloud compute costs, and physical wear-and-tear on hardware during real-world training pipelines, such as robotic manipulation.

Organizations developing vision-based autonomous control should consider contrastive self-supervised learning as an effective, low-overhead baseline. When tasks feature rich, continuous reward signals, teams may also evaluate pure data-augmentation approaches (such as RAD or DrQ); however, for multi-task applications or environments with sparse feedback, CURL’s reward-independent representation framework is recommended. Decision-makers should note that performance still lags behind physical state-based baselines when visual observations partially obscure critical state information (such as complex multi-joint coordination), and benchmark performance on Atari exhibited notable variance across random seeds. Further pilot testing in target domain environments is recommended before full-scale deployment.

1. Introduction

Section Summary: Recent successes in reinforcement learning have shown that agents can master complex tasks like game playing or robotic grasping directly from raw pixel inputs by pairing deep neural networks with standard RL algorithms. However, such pixel-based methods remain far less sample-efficient than approaches that start from clean state information, which limits their practicality in the real world where data collection is slow and expensive. To close this gap, the paper introduces CURL, a method that jointly trains visual representations through contrastive learning on augmented observations while performing off-policy reinforcement learning, yielding substantially faster learning without any separate pre-training phase.

Developing agents that can perform complex control tasks from high dimensional observations such as pixels has been possible by combining the expressive power of deep neural networks with the long-term credit assignment power of reinforcement learning algorithms. Notable successes include learning to play a diverse set of video games from raw pixels [1], continuous control tasks such as controlling a simulated car from a dashboard camera [2] and subsequent algorithmic developments and applications to agents that successfully navigate mazes and solve complex tasks from first-person camera observations [3, 4, 5]; and robots that successfully grasp objects in the real world [6].

However, it has been empirically observed that reinforcement learning from high dimensional observations such as raw pixels is sample-inefficient [7, 8]. Moreover, it is widely accepted that learning policies from physical state based features is significantly more sample-efficient than learning from pixels [9]. In principle, if the state information is present in the pixel data, then we should be able to learn representations that extract the relevant state information. For this reason, it may be possible to learn from pixels as fast as from state given the right representation.

From a practical standpoint, although high rendering speeds in simulated environments enable RL agents to solve complex tasks within reasonable wall clock time, learning in the real world means that agents are bound to work within the limitations of physics. [6] needed a farm of robotic arms that collected large scale robot interaction data over several months to develop their robot grasp value functions and policies. The data-efficiency of the whole pipeline thus has significant room for improvement. Similarly, in simulated worlds which are limited by rendering speeds in the absence of GPU accelerators, data efficiency is extremely crucial to have a fast experimental turnover and iteration. Therefore, improving the sample efficiency of reinforcement learning (RL) methods that operate from high dimensional observations is of paramount importance to RL research both in simulation and the real world and allows for faster progress towards the broader goal of developing intelligent autonomous agents.

A number of approaches have been proposed in the literature to address the sample inefficiency of deep RL algorithms. Broadly, they can be classified into two streams of research, though not mutually exclusive: (i) Auxiliary tasks on the agent's sensory observations; (ii) World models that predict the future. While the former class of methods use auxiliary self-supervision tasks to accelerate the learning progress of model-free RL methods [3, 10], the latter class of methods build explicit predictive models of the world and use those models to plan through or collect fictitious rollouts for model-free methods to learn from [11, 12, 8, 13].

Our work falls into the first class of models, which use auxiliary tasks to improve sample efficiency. Our hypothesis is simple: If an agent learns a useful semantic representation from high dimensional observations, control algorithms built on top of those representations should be significantly more data-efficient. Self-supervised representation learning has seen dramatic progress in the last couple of years with huge advances in masked language modeling [14] and contrastive learning [15, 16, 17] for language and vision respectively. The representations uncovered by these objectives improve the performance of any supervised learning system especially in scenarios where the amount of labeled data available for the downstream task is really low.

We take inspiration from the contrastive pre-training successes in computer vision. However, there are a couple of key differences: (i) There is no giant unlabeled dataset of millions of images available beforehand - the dataset is collected online from the agent's interactions and changes dynamically with the agent's experience; (ii) The agent has to perform unsupervised and reinforcement learning simultaneously as opposed to fine-tuning a pre-trained network for a specific downstream task. These two differences introduce a different challenge: How can we use contrastive learning for improving agents that can learn to control effectively and efficiently from online interactions?

To address this challenge, we propose CURL - Contrastive Uunsupervised Representations for Reinforcement Learning. CURL uses a form of contrastive learning that maximizes agreement between augmented versions of the same observation, where each observation is a stack of temporally sequential frames. We show that CURL significantly improves sample-efficiency over prior pixel-based methods by performing contrastive learning simultaneously with an off-policy RL algorithm. CURL coupled with the Soft-Actor-Critic (SAC) [18] results in 1.9x median higher performance over Dreamer, a prior state-of-the-art algorithm on DMControl environments, benchmarked at 100k environment steps and matches the performance of state-based SAC on the majority of 16 environments tested, a first for pixel-based methods. In the Atari setting benchmarked at 100k interaction steps, we show that CURL coupled with a data-efficient version of Rainbow DQN [19] results in 1.2x median higher performance over prior methods such as SimPLe [8], improving upon Efficient Rainbow [19] on 19 out of 26 Atari games, surpassing human efficiency on two games.

While contrastive learning in aid of model-free RL has been studied in the past by [20] using Contrastive Predictive Coding (CPC), the results were mixed with marginal gains in a few DMLab [4] environments. CURL is the first model to show substantial data-efficiency gains from using a contrastive self-supervised learning objective for model-free RL agents across a multitude of pixel based continuous and discrete control tasks in DMControl and Atari.

We prioritize designing a simple and easily reproducible pipeline. While the promise of auxiliary tasks and learning world models for RL agents has been demonstrated in prior work, there's an added layer of complexity when introducing components like modeling the future in a latent space [20, 12]. CURL is designed to add minimal overhead in terms of architecture and model learning. The contrastive learning objective in CURL operates with the same latent space and architecture typically used for model-free RL and seamlessly integrates with the training pipeline without the need to introduce multiple additional hyperparameters.

Our paper makes the following key contributions: We present CURL, a simple framework that integrates contrastive learning with model-free RL with minimal changes to the architecture and training pipeline. Using 16 complex control tasks from the DeepMind control (DMControl) suite and 26 Atari games, we empirically show that contrastive learning combined with model-free RL outperforms the prior state-of-the-art by 1.9x on DMControl and 1.2x on Atari compared across leading prior pixel-based methods. CURL is also the first algorithm across both model-based and model-free methods that operates purely from pixels, and nearly matches the performance and sample-efficiency of a SAC algorithm trained from the state based features on the DMControl suite. Finally, our design is simple and does not require any custom architectural choices or hyperparameters which is crucial for reproducible end-to-end training. Through these strong empirical results, we demonstrate that a contrastive objective is the preferred self-supervised auxiliary task for achieving sample-efficiency compared to reconstruction based methods, and enables model-free methods to outperform state-of-the-art model-based methods in terms of data-efficiency.

2. Related Work

Section Summary: Researchers have explored self-supervised learning to build useful representations from unlabeled data, with notable successes in language and vision through methods like BERT and SimCLR, and contrastive approaches that train models to distinguish similar from dissimilar data pairs. In reinforcement learning, these ideas appear as auxiliary prediction tasks or world models that help agents learn more efficiently from fewer interactions by forecasting future states or simulating experience. CURL builds on this foundation by integrating contrastive self-supervision into RL agents, and the section reviews related benchmarks and algorithms on image-based control tasks such as DMControl and Atari.

Self-Supervised Learning: Self-Supervised Learning is aimed at learning rich representations of high dimensional unlabeled data to be useful for a wide variety of tasks. The fields of natural language processing and computer vision have seen dramatic advances in self-supervised methods such as BERT [14], CPC, MoCo, SimCLR [15, 16, 17].

Contrastive Learning: Contrastive Learning is a framework to learn representations that obey similarity constraints in a dataset typically organized by similar and dissimilar pairs. This is often best understood as performing a dictionary lookup task wherein the positive and negatives represent a set of keys with respect to a query (or an anchor). A simple instantiation of contrastive learning is Instance Discrimination [21] wherein a query and key are positive pairs if they are data-augmentations of the same instance (example, image) and negative otherwise. A key challenge in contrastive learning is the choice of negatives which can decide the quality of the underlying representations learned. The loss functions used to contrast could be among several choices such as InfoNCE [20], Triplet [22], Siamese [23] and so forth.

Self-Supervised Learning for RL: Auxiliary tasks such as predicting the future conditioned on the past observation(s) and action(s) [3, 24, 20, 25] are a few representative examples of using auxiliary tasks to improve the sample-efficiency of model-free RL algorithms. The future prediction is either done in a pixel space [3] or latent space [20]. The sample-efficiency gains from reconstruction-based auxiliary losses have been benchmarked in [3, 26, 27]. Contrastive learning has been used to extract reward signals in the latent space [28, 29, 30]; and study representation learning on Atari games by [31].

World Models for sample-efficiency: While joint learning of an auxiliary unsupervised task with model-free RL is one way to improve the sample-efficiency of agents, there has also been another line of research that has tried to learn world models of the environment and use them to sample rollouts and plan. An early instantiation of the generic principle was put forth by [11] in Dyna where fictitious samples rolled out from a learned world model are used in addition to the agent's experience for sample-efficient learning. Planning through a learned world model [32] is another way to improve sample-efficiency. While [3, 20, 33] also learn pixel and latent space forward models, the models are learned to shape the latent representations, and there is no explicit Dyna or planning. Planning through learned world models has been successfully demonstrated in [12, 34, 35]. [8] introduce SimPLe which implements Dyna with expressive deep neural networks for the world model for sample-efficiency on Atari games.

Sample-efficient RL for image-based control: CURL encompasses the areas of self-supervision, contrastive learning and using auxiliary tasks for sample-efficient RL. We benchmark for sample-efficiency on the DMControl suite ([9]) and Atari Games benchmarks [36]. The DMControl suite has been used widely by [27], [34], [35] and [33] for benchmarking sample-efficiency for image based continuous control methods. As for Atari, [8] propose to use the 100k interaction steps benchmark for sample-efficiency which has been adopted in [37, 19]. The Rainbow DQN [38] was originally proposed for maximum sample-efficiency on the Atari benchmark and in recent times has been adapted to a version known as Data-Efficient Rainbow [19] with competitive performance to SimPLe without learning world models. We benchmark extensively against both model-based and model-free algorithms in our experiments. For the DMControl experiments, we compare our method to Dreamer, PlaNet, SLAC, SAC+AE whereas for Atari experiments we compare to SimPLe, Rainbow, and OverTrained Rainbow (OTRainbow) and Efficient Rainbow (Eff. Rainbow).

3. Background

Section Summary: CURL is a framework that adds contrastive learning to standard reinforcement learning methods so agents can learn useful visual features from raw pixel observations. It builds on two existing algorithms: Soft Actor-Critic, an off-policy method that trains a policy and value functions together for continuous control tasks, and Rainbow DQN, which combines several improvements to Deep Q-Networks for better performance on Atari games. The background also covers contrastive learning, a technique that trains an encoder to match a query image representation with its correct “positive” match while pushing it away from many incorrect “negative” examples using a loss based on dot-product similarity.

CURL is a general framework for combining contrastive learning with RL. In principle, one could use any RL algorithm in the CURL pipeline, be it on-policy or off-policy. We use the widely adopted Soft Actor Critic (SAC) [18] for continuous control benchmarks (DM Control) and Rainbow DQN [38, 19] for discrete control benchmarks (Atari). Below, we review SAC, Rainbow DQN and Contrastive Learning.

3.1 Soft Actor Critic

SAC is an off-policy RL algorithm that optimizes a stochastic policy for maximizing the expected trajectory returns. Like other state-of-the-art end-to-end RL algorithms, SAC is effective when solving tasks from state observations but fails to learn efficient policies from pixels. SAC is an actor-critic method that learns a policy $\pi_\psi$ and critics $Q_{\phi_1}$ and $Q_{\phi_2}$. The parameters $\phi_i$ are learned by minimizing the Bellman error:

$ \mathcal L (\phi_{i},\mathcal{B}) = \mathbb{E}{t \sim \mathcal B} \left [\left ( Q{\phi_i}(o,a) - \left( r+\gamma(1-d)\mathcal T \right )\right )^2 \right] $

where $t = (o,a,o',r,d)$ is a tuple with observation $o$, action $a$, reward $r$ and done signal $d$, $\mathcal{B}$ is the replay buffer, and $\mathcal T$ is the target, defined as:

$ \mathcal{T} = \left (\min_{i=1,2} Q^{*}{\phi_i} (o',a') - \alpha \log \pi\psi(a'|o')\right ) $

In the target equation 3, $Q^{*}{\phi_i}$ denotes the exponential moving average (EMA) of the parameters of $Q{\phi_i}$. Using the EMA has empirically shown to improve training stability in off-policy RL algorithms. The parameter $\alpha$ is a positive entropy coefficient that determines the priority of the entropy maximization over value function optimization.

While the critic is given by $Q_{\phi_{i}}$, the actor samples actions from policy $\pi_\psi$ and is trained by maximizing the expected return of its actions as in:

$ \mathcal L (\psi) = \mathbb{E}{a \sim \pi} \left [ Q^\pi (o,a) - \alpha \log \pi\psi (a|o) \right ] $

where actions are sampled stochastically from the policy $a_\psi (o,\xi) \sim \tanh \left (\mu_\psi (o) + \sigma_\psi (o) \odot \xi \right )$ and $\xi \sim \mathcal N (0,I)$ is a standard normalized noise vector.

3.2 Rainbow

Rainbow DQN [38] is best summarized as multiple improvements on top of the original Nature DQN [1] applied together. Specifically, Deep Q Network (DQN) [1] combines the off-policy algorithm Q-Learning with a convolutional neural network as the function approximator to map raw pixels to action value functions. Since then, multiple improvements have been proposed such as Double Q Learning [39], Dueling Network Architectures [40], Prioritized Experience Replay [41], and Noisy Networks [42]. Additionally, distributional reinforcement learning [43] proposed the technique of predicting a distribution over possible value function bins through the C51 Algorithm. Rainbow DQN combines all of the above techniques into a single off-policy algorithm for state-of-the-art sample efficiency on Atari benchmarks. Additionally, Rainbow also makes use of multi-step returns [44]. [19] propose a data-efficient version of the Rainbow which can be summarized as an improved configuration of hyperparameters that is optimized for performance benchmarked at 100K interaction steps.

3.3 Contrastive Learning

A key component of CURL is the ability to learn rich representations of high dimensional data using contrastive unsupervised learning. Contrastive learning [45, 46, 20, 21, 16] can be understood as learning a differentiable dictionary look-up task. Given a query $q$ and keys $\mathbb{K} = {k_0, k_1, \dots }$ and an explicitly known partition of $\mathbb{K}$ (with respect to $q$) $P(\mathbb{K}) = ( {k_{+}}, \mathbb{K} \setminus {k_{+}} )$, the goal of contrastive learning is to ensure that $q$ matches with $k_{+}$ relatively more than any of the keys in $\mathbb{K} \setminus {k_{+}}$. $q, \mathbb{K}, k_{+},$ and $\mathbb{K} \setminus {k_{+}}$ are also referred to as anchor, targets, positive, negatives respectively in the parlance of contrastive learning [20, 16]. Similarities between the anchor and targets are best modeled with dot products ($q^Tk)$ [21, 16] or bilinear products ($q^TWk$) [20, 15] though other forms like euclidean distances are also common [47, 22]. To learn embeddings that respect these similarity relations, [20] propose the InfoNCE loss:

$ \mathcal L_{q} = \log \frac{\exp(q^T W k_{+})}{ \exp(q^T W k_{+}) + \sum_{i=0}^{K-1} \exp(q^T W k_{i})} $

The loss Equation 5 can be interpreted as the log-loss of a $K$-way softmax classifier whose label is $k_{+}$.

4. CURL Implementation

Section Summary: CURL adapts standard reinforcement learning algorithms such as SAC and Rainbow DQN by adding a contrastive learning task as an auxiliary objective during regular training updates. It works by creating pairs of randomly cropped and augmented frame stacks from the same observation, then training an encoder to pull matching pairs closer together in latent space while pushing apart pairs from different observations, using a momentum-updated encoder and a bilinear similarity measure for stability. This instance-discrimination approach is deliberately kept simple to avoid destabilizing the main reinforcement learning objective or slowing down training.

CURL minimally modifies a base RL algorithm by training the contrastive objective as an auxiliary loss during the batch update. In our experiments, we train CURL alongside two model-free RL algorithms — SAC for DMControl experiments and Rainbow DQN (data-efficient version) for Atari experiments. To specify a contrastive learning objective, we need to define (i) the discrimination objective (ii) the transformation for generating query-key observations (iii) the embedding procedure for transforming observations into queries and keys and (iv) the inner product used as a similarity measure between the query-key pairs in the contrastive loss. The exact specification these aspects largely determine the quality of the learned representations.

We first summarize the CURL architecture, and then cover each architectural choice in detail.

4.1 Architectural Overview

CURL uses instance discrimination with similarities to SimCLR [17], MoCo [16] and CPC [15]. Most Deep RL architectures operate with a stack of temporally consecutive frames as input [38]. Therefore, instance discrimination is performed across the frame stacks as opposed to single image instances. We use a momentum encoding procedure for targets similar to MoCo [48] which we found to be better performing for RL. Finally, for the InfoNCE score function, we use a bi-linear inner product similar to CPC [20] which we found to work better than unit norm vector products used in MoCo and SimCLR. Ablations for both the encoder and the similarity measure choices are shown in Figure 5. The contrastive representation is trained jointly with the RL algorithm, and the latent code receives gradients from both the contrastive objective and the Q-function. An overview of the architecture is shown in in Figure 2.

4.2 Discrimination Objective

A key component of contrastive representation learning is the choice of positives and negative samples relative to an anchor [49, 50, 15, 16, 17]. Contrastive Predictive Coding (CPC) based pipelines [15, 20] use groups of image patches separated by a carefully chosen spatial offset for anchors and positives while the negatives come from other patches within the image and from other images.

While patches are a powerful way to incorporate spatial and instance discrimination together, they introduce extra hyperparameters and architectural design choices which may be hard to adapt for a new problem. SimCLR [17] and MoCo [16] opt for a simpler design where there is no patch extraction.

Discriminating transformed image instances as opposed to image-patches within the same image optimizes a simpler instance discrimination objective [21] with the InfoNCE loss and requires minimal architectural adjustments [48, 17]. It is preferable to pick a simpler discrimination objective in the RL setting for two reasons. First, considering the brittleness of reinforcement learning algorithms [51], complex discrimination may destabilize the RL objective. Second, since RL algorithms are trained on dynamically generated datasets, a complex discrimination objective may significantly increase the wall-clock training time. CURL therefore uses instance discrimination rather than patch discrimination. One could view contrastive instance discrimination setups like SimCLR and MoCo as maximizing mutual information between an image and its augmented version. The reader is encouraged to refer to [20, 52, 53] for connections between contrastive learning and mutual information.

4.3 Query-Key Pair Generation

Similar to instance discrimination in the image setting [48, 17], the anchor and positive observations are two different augmentations of the same image while negatives come from other images. CURL primarily relies on the random crop data augmentation, where a random square patch is cropped from the original rendering.

A significant difference between RL and computer vision settings is that an instance ingested by a model-free RL algorithm that operates from pixels is not just a single image but a stack of frames [1]. For example, one typically feeds in a stack of 4 frames in Atari experiments and a stack of 3 frames in DMControl. This way, performing instance discrimination on frame stacks allows CURL to learn both spatial and temporal discriminative features. For details regarding the extent to which CURL captures temporal features, see Appendix E.

We apply the random augmentations across the batch but consistently across each stack of frames to retain information about the temporal structure of the observation. The augmentation procedure is shown in Figure 3. For more details, refer to Appendix A.

4.4 Similarity Measure

Another determining factor in the discrimination objective is the inner product used to measure agreement between query-key pairs. CURL employs the bi-linear inner-product $\text{sim}(q,k) = q^T W k$, where $W$ is a learned parameter matrix. We found this similarity measure to outperform the normalized dot-product (see Figure 5 in Appendix A) used in recent state-of-the-art contrastive learning methods in computer vision like MoCo and SimCLR.

4.5 Target Encoding with Momentum

The motivation for using contrastive learning in CURL is to train encoders that map from high dimensional pixels to more semantic latents. InfoNCE is an unsupervised loss that learns encoders $f_q$ and $f_k$ mapping the raw anchors (query) $x_q$ and targets (keys) $x_k$ into latents $q = f_q(x_q)$ and $k = f_k(x_k)$, on which we apply the similarity dot products. It is common to share the same encoder between the anchor and target mappings, that is, to have $f_q = f_k$ [20, 15].

From the perspective of viewing contrastive learning as building differentiable dictionary lookups over high dimensional entities, increasing the size of the dictionary and enriching the set of negatives is helpful in learning rich representations. [16] propose momentum contrast (MoCo), which uses the exponentially moving average (momentum averaged) version of the query encoder $f_q$ for encoding the keys in $\mathbb{K}$. Given $f_q$ parametrized by $\theta_q$ and $f_k$ parametrized by $\theta_k$, MoCo performs the update $\theta_k = m \theta_k + (1 - m) \theta_q$ and encodes any target $x_k$ using $\textrm{SG}(f_k(x_k))$ [${\textrm{SG}}$ : Stop Gradient].

CURL couples frame-stack instance discrimination with momentum encoding for the targets during contrastive learning, and RL is performed on top of the encoder features.

4.6 Differences Between CURL and Prior Contrastive Methods in RL

[20] use Contastive Predictive Coding (CPC) as an auxiliary task wherein an LSTM operates on a latent space of a convolutional encoder; and both the CPC and A2C [1] objectives are jointly optimized. CURL avoids using pipelines that predict the future in a latent space such as [20, 35]. In CURL, we opt for a simple instance discrimination style contrastive auxiliary task.

4.7 CURL Contrastive Learning Pseudocode (PyTorch-like)

# f_q, f_k: encoder networks for anchor
# (query) and target (keys) respectively.
# loader: minibatch sampler from ReplayBuffer
# B-batch_size, C-channels, H,W-spatial_dims
# x : shape : [B, C, H, W]
# C = c * num_frames; c=3 (R/G/B) or 1 (gray)
# m: momentum, e.g. 0.95
# z_dim: latent dimension
f_k.params = f_q.params
W = rand(z_dim, z_dim) # bilinear product.
for x in loader: # load minibatch from buffer
 x_q = aug(x) # random augmentation
 x_k = aug(x) # different random augmentation
 z_q = f_q.forward(x_q)
 z_k = f_k.forward(x_k)
 z_k = z_k.detach() # stop gradient
 proj_k = matmul(W, z_k.T) # bilinear product
 logits = matmul(z_q, proj_k) # B x B
  # subtract max from logits for stability
 logits = logits - max(logits, axis=1) 
 labels = arange(logits.shape[0])
 loss = CrossEntropyLoss(logits, labels) 
 loss.backward()
 update(f_q.params) # Adam
 update(W) # Adam
 f_k.params = m*f_k.params+(1-m)*f_q.params

5. Experiments

Section Summary: In the experiments section, the authors evaluate CURL's sample efficiency and performance on continuous-control tasks from the DMControl suite and discrete Atari games, using pixel inputs and fixed budgets of 100k or 500k environment steps. They report that CURL reaches state-of-the-art scores on most DMControl environments and improves over strong baselines on 19 of 26 Atari games, while also comparing favorably to both model-based and model-free methods. The tests cover sixteen DMControl tasks and twenty-six Atari games to demonstrate broad applicability for learning from raw visual observations.

5.1 Evaluation

We measure the data-efficiency and performance of our method and baselines at 100k and 500k environment steps on DMControl and 100k interaction steps (400k environment steps with action repeat of 4) on Atari, which we will henceforth refer to as DMControl100k, DMControl500k and Atari100k for clarity. While Atari100k benchmark has been common practice when investigating data-efficiency on Atari [8, 19, 37], the DMControl benchmark was set at 500k environment steps because state-based RL approaches asymptotic performance on many environments at this point, and 100k steps to measure the speed of initial learning. A broader motivation is that while RL algorithms can achieve super-human performance on Atari games, they are still far less efficient than a human learner. Training for 100-500k environment steps corresponds to a few hours of human time.

We evaluate (i) sample-efficiency by measuring how many steps it takes the best performing baselines to match CURL performance at a fixed $T$ (100k or 500k) steps and (ii) performance by measuring the ratio of the episode returns achieved by CURL versus the best performing baseline at $T$ steps. To be explicit, when we say data or sample-efficiency we're referring to (i) and when we say performance we're referring to (ii).

\begin{tabular}{lcccccccc}
\toprule
500K step scores & CURL & PlaNet & Dreamer & SAC+AE & SLACv1 & Pixel SAC & State SAC \\
\midrule
Finger, spin &  926 $\pm$ 45 & 561 $\pm$ 284 & 796 $\pm$ 183 & 884 $\pm$ 128 & 673 $\pm$ 92 & 179 $\pm$ 166 & 923 $\pm$ 21 \\
Cartpole, swingup & 841 $\pm$ 45& 475 $\pm$ 71& 762 $\pm$ 27 & 735 $\pm$ 63 & - & 419 $\pm$ 40 & 848 $\pm$ 15 \\
Reacher, easy & 929 $\pm$ 44& 210 $\pm$ 390& 793 $\pm$ 164 & 627 $\pm$ 58 & - & 145 $\pm$ 30 & 923 $\pm$ 24 \\
Cheetah, run & 518 $\pm$ 28 & 305 $\pm$ 131& 570 $\pm$ 253 & 550 $\pm$ 34 & 640 $\pm$ 19 & 197 $\pm$ 15 & 795 $\pm$ 30 \\
Walker, walk & 902 $\pm$ 43& 351 $\pm$ 58 & 897 $\pm$ 49 & 847 $\pm$ 48 & 842 $\pm$ 51 & 42 $\pm$ 12 & 948 $\pm$ 54 \\
Ball in cup, catch & 959 $\pm$ 27 & 460 $\pm$ 380 & 879 $\pm$ 87 & 794$\pm$ 58 & 852 $\pm$ 71 & 312$ \pm$ 63 & 974 $\pm$ 33\\
\midrule
100K step scores & & & & & & & \\
\midrule
Finger, spin & 767 $\pm$ 56  & 136 $\pm$ 216 & 341 $\pm$ 70& 740 $\pm$ 64 & 693 $\pm$ 141 & 179 $\pm$ 66 & 811$\pm$46 \\
Cartpole, swingup & 582$\pm$146& 297$\pm$39& 326$\pm$27 & 311$\pm$11 & - & 419$\pm$40 & 835$\pm$22\\
Reacher, easy & 538$\pm$233 & 20$\pm$50 & 314$\pm$155 & 274$\pm$14 & - & 145$\pm$30 & 746$\pm$25 \\
Cheetah, run & 299 $\pm$48 & 138$\pm$88& 235$\pm$ 137 & 267$\pm$24 & 319$\pm$56 & 197$\pm$15& 616$\pm$18 \\
Walker, walk & 403$\pm$24& 224$\pm$48& 277$\pm$12 & 394$\pm$22 & 361$\pm$73 &42$\pm$12& 891$\pm$82 \\
Ball in cup, catch & 769 $\pm$ 43 & 0 $\pm$ 0 & 246 $\pm$ 174 & 391$\pm$ 82 & 512 $\pm$ 110 & 312$\pm$ 63 & 746$\pm$91 \\ 
\bottomrule
\end{tabular}

::: {caption="Table 2: Scores achieved by CURL (coupled with Eff. Rainbow) and baselines on Atari benchmarked at 100k time-steps (Atari100k). CURL achieves state-of-the-art performance on 7 out of 26 environments. Our baselines are SimPLe [8], OverTrained Rainbow (OTRainbow) [37], Data-Efficient Rainbow (Eff. Rainbow) [19], Rainbow [38], Random Agent and Human Performance (Human). We see that CURL implemented on top of Eff. Rainbow improves over Eff. Rainbow on 19 out of 26 games. We also run CURL with 20 random seeds given that this benchmark is susceptible to high variance across multiple runs. We also see that CURL achieves superhuman performance on JamesBond and Krull."}

:::

5.2 Environments

Our primary goal for CURL is sample-efficient control from pixels that is broadly applicable across a range of environments. We benchmark the performance of CURL for both discrete and continuous control environments. Specifically, we focus on DMControl suite for continuous control tasks and the Atari Games benchmark for discrete control tasks with inputs being raw pixels rendered by the environments.

DeepMind Control: Recently, there have been a number of papers that have benchmarked for sample efficiency on challenging visual continuous control tasks belonging to the DMControl suite [9] where the agent operates purely from pixels. The reason for operating in these environments is multi fold: (i) they present a reasonably challenging and diverse set of tasks; (ii) sample-efficiency of pure model-free RL algorithms operating from pixels on these benchmarks is poor; (iii) multiple recent efforts to improve the sample efficiency of both model-free and model-based methods on these benchmarks thereby giving us sufficient baselines to compare against; (iv) performance on the DM control suite is relevant to robot learning in real world benchmarks.

We run experiments on sixteen environments from DMControl to examine the performance of CURL on pixels relative to SAC with access to the ground truth state, shown in Figure 7. For more extensive benchmarking, we compare CURL to five leading pixel-based methods across the the six environments presented in [27]: ball-in-cup, finger-spin, reacher-easy, cheetah-run, walker-walk, cartpole-swingup for benchmarking.

Atari: Similar to DMControl sample-efficiency benchmarks, there have been a number of recent papers that have benchmarked for sample-efficiency on the Atari 2600 Games. [8] proposed comparing various algorithms in terms of performance achieved within $100$K timesteps ($400$K frames, frame skip of $4$) of interaction with the environments (games). The method proposed by [8] called SimPLe is a model-based RL algorithm. SimPLe is compared to a random agent, model-free Rainbow DQN [38] and human performance for the same amount of interaction time. Recently, [19] and [37] proposed data-efficient versions of Rainbow DQN which are competitive with SimPLe on the same benchmark. Given that the same benchmark has been established in multiple recent papers and that there is a human baseline to compare to, we benchmark CURL on all the 26 Atari Games (Table 2).

5.3 Baselines for benchmarking sample efficiency

DMControl baselines: We present a number of baselines for continuous control within the DMControl suite: (i) SAC-AE [27] where the authors attempt to use a $\beta$-VAE [26], VAE [54] and a regualrized autoencoder [55, 56] jointly with SAC; (ii) SLAC [33] which learns a latent space world model on top of VAE features [12] and builds value functions on top; (iii) PlaNet and (iv) Dreamer [34, 35] both of which learn a latent space world model and explicitly plan through it; (v) Pixel SAC: Vanilla SAC operating purely from pixels [18]. These baselines are competitive methods for benchmarking control from pixels. In addition to these, we also present the baseline State-SAC where the assumption is that the agent has access to low level state based features and does not operate from pixels. This baseline acts as an oracle in that it approximates the upper bound of how sample-efficient a pixel-based agent can get in these environments.

Atari baselines: For benchmarking performance on Atari, we compare CURL to (i) SimPLe [8], the top performing model-based method in terms of data-efficiency on Atari and (ii) Rainbow DQN [38], a top-performing model-free baseline for Atari, (iii) OTRainbow [37] which is an OverTrained version of Rainbow for data-efficiency, (iv) Efficient Rainbow [19] which is a modification of Rainbow hyperparameters for data-efficiency, (v) Random Agent [8], (vi) Human Performance [8, 19]. All the baselines and our method are evaluated for performance after 100K interaction steps (400K frames with a frame skip of 4) which corresponds to roughly two hours of gameplay. These benchmarks help us understand how the state-of-the-art pixel based RL algorithms compare in terms of sample efficiency and also to human efficiency.

Note: Scores for SimPLe and Human baselines have been reported differently in prior work [37, 19]. To be rigorous, we take the best reported score for each individual game reported in prior work.

6. Results

Section Summary: In experiments on DMControl tasks, CURL achieved state-of-the-art results among image-based reinforcement learning methods, often matching or exceeding the sample efficiency of algorithms that receive direct state information rather than raw pixels. It reached near-optimal performance on most tested environments within 500,000 steps. On Atari games with limited data, CURL posted higher median scores than prior approaches, improving results on the majority of titles and surpassing human-level play in two cases.

6.1 DMControl

Sample-efficiency results for DMControl experiments are shown in Table 1 and in Figure 4, Figure 6, and Figure 7. Below are the key findings:

(i) CURL is the state-of-the-art image-based RL algorithm on the majority (5 out of 6) DMControl environments that we benchmark on for sample-efficiency against existing pixel-based baselines. On DMControl100k, CURL achieves 1.9x higher median performance than Dreamer [35], a leading model-based method, and is 4.5x more data-efficient shown in Figure 6.

(ii) CURL operating purely from pixels nearly matches (and sometimes surpasses) the sample efficiency of SAC operating from state on the majority of 16 DMControl environments tested shown in Figure 7 and matches the median state-based score on DMControl500k shown in Figure 4. This is a first for any image-based RL algorithm, be it model-based, model-free, with or without auxiliary tasks.

(iii) CURL solves (converges close to optimal score of 1000) on the majority of 16 DMControl experiments within 500k steps. It also matches the state-based median score across the 6 extensively benchmarked environments in this regime.

6.2 Atari

Results for Atari100k are shown in Table 2. Below are the key findings:

(i) CURL achieves a median human-normalized score (HNS) of 17.5% while SimPLe and Efficient Rainbow DQN achieve 14.4% and 16.1% respectively. The mean HNS is 38.1%, 44.3%, and 28.5% for CURL, SimPLe, and Efficient Rainbow DQN respectively.

(ii) CURL improves on top of Efficient Rainbow on 19 out of 26 Atari games. Averaged across 26 games, CURL improves on top of Efficient Rainbow by 1.3x, while the median performance improvement over SimPLE and Efficient Rainbow are 1.2x and 1.1x respectively.

(iii) CURL surpasses human performance on two games JamesBond (1.6 HNS), Krull (2.5 HNS).

7. Ablation Studies

Section Summary: The paper includes ablation studies in its appendix to explore several aspects of the CURL method. These experiments examine whether the approach captures only visual information or also temporal patterns in the data, how well reinforcement learning performs when using representations trained solely through contrastive learning without reinforcement signals, and the reasons for varying performance compared to state-based methods across different environments. The results help clarify the contributions of different components in the overall framework.

In Appendix E, we present the results of ablation studies carried out to answer the following questions: (i) Does CURL learn only visual features or does it also capture temporal dynamics of the environment? (ii) How well does the RL policy perform if CURL representations are learned solely with the contrastive objective and no signal from RL? (iii) Why does CURL match state-based RL performance on some DMControl environments but not on others?

8. Conclusion

Section Summary: Researchers introduced CURL, a new approach that uses contrastive learning to help reinforcement learning systems extract useful information from raw pixel data without needing explicit labels or supervision. It reaches top performance in data efficiency across many visual control tasks while requiring only small changes to standard model-free methods, unlike earlier techniques that depended on building world models or decoder networks. The authors suggest this progress could support wider real-world use of reinforcement learning, such as in robotics where gathering training data is especially difficult.

In this work, we proposed CURL, a contrastive unsupervised representation learning method for RL, that achieves state-of-the-art data-efficiency on pixel-based RL tasks across a diverse set of benchmark environments. CURL is the first model-free RL pipeline accelerated by contrastive learning with minimal architectural changes to demonstrate state-of-the-art performance on complex tasks so far dominated by approaches that have relied on learning world models and (or) decoder-based objectives. We hope that progress like CURL enables avenues for real-world deployment of RL in areas like robotics where data-efficiency is paramount.

9. Acknowledgements

Section Summary: This research received funding support from the Defense Advanced Research Projects Agency through a program on learning with limited labels, along with a grant from the Office of Naval Research. The authors also credit several collaborators for practical help, such as assistance with one appendix section, access to cloud computing resources, shared data used in comparisons, and useful conversations during the work.

This research is supported in part by DARPA through the Learning with Less Labels (LwLL) Program and by ONR through PECASE N000141612723. We also thank Wendy Shang for her help with Appendix E.4; Zak Stone and Google TFRC for cloud credits; Danijar Hafner, Alex Lee, and Denis Yarats for sharing data for baselines; and Lerrel Pinto, Adam Stooke, Will Whitney, and Ankesh Anand for insightful discussions.

Appendix

Section Summary: The appendix describes the implementation of CURL for reinforcement learning on DMControl tasks, which combines the SAC algorithm with contrastive learning on image observations. It lists the key hyperparameters for the networks, optimization, data augmentation, and replay buffer, along with a PyTorch-style sketch of the convolutional encoder shared by the actor and critic. The text also clarifies terminology around training steps, explains how momentum-averaged encoders and equal-weighted losses are used for both contrastive and RL objectives, and notes practical differences from standard computer-vision contrastive setups.

A. Implementation Details

Below, we explain the implementation details for CURL in the DMControl setting. Specifically, we use the SAC algorithm as the RL objective coupled with CURL and build on top of the publicly released implementation from [27]. We present in detail the hyperparameters for the architecture and optimization. We do not use any extra hyperparameter for balancing the contrastive loss and the reinforcement learning losses. Both the objectives are weighed equally in the gradient updates.

\begin{tabular}{ll}
\toprule
\textbf{Hyperparameter} & \textbf{Value} \\
\midrule
Random crop & True \\ 
Observation rendering & $(100,100)$ \\ 
Observation downsampling & $(84,84)$ \\ 
Replay buffer size & $100000$ \\ 
Initial steps & $1000$ \\ 
Stacked frames & $3$ \\ 
Action repeat & $2$ finger, spin; walker, walk\\
  {} & $8$ cartpole, swingup \\
  {} & $4$ otherwise \\
Hidden units (MLP) & $1024$ \\ 
Evaluation episodes & $10$ \\ 
Optimizer & Adam \\ 
$(\beta_1, \beta_2) \rightarrow (f_\theta, \pi_\psi, Q_\phi)$ & $(.9, .999)$ \\
$(\beta_1, \beta_2) \rightarrow (\alpha)$ & $(.5, .999)$ \\
Learning rate $(f_\theta, \pi_\psi, Q_\phi)$ & $2e-4$ cheetah, run \\
 {} & $1e-3$ otherwise\\ 
Learning rate ($\alpha$) & $1e-4$ \\

Batch Size & $512$ \\ 
$Q$ function EMA $\tau$ & $0.01$ \\
Critic target update freq & $2$ \\
Convolutional layers & $4$ \\
Number of filters & $32$ \\
Non-linearity & ReLU \\
Encoder EMA $\tau$ & $0.05$ \\
Latent dimension & $50$ \\
Discount $\gamma$ & $.99$ \\
Initial temperature & $0.1$ \\

\bottomrule
\end{tabular}

Architecture: We use an encoder architecture that is similar to [27], which we sketch in PyTorch-like pseuodocode below. The actor and critic both use the same encoder to embed image observations. A full list of hyperparameters is displayed in Table 3.

For contrastive learning, CURL utilizes momentum for the key encoder [48] and a bi-linear inner product as the similarity measure [20]. Performance curves ablating these two architectural choices are shown in Figure 5.

Pseudo-code for the architecture is provided below:

def encode(x,z_dim):
    """
    ConvNet encoder
    args:
        B-batch_size, C-channels
        H,W-spatial_dims
        x : shape : [B, C, H, W]
        C = 3 * num_frames; 3 - R/G/B
        z_dim: latent dimension
    """

    x = x / 255.

    # c: channels, f: filters
    # k: kernel, s: stride

    z = Conv2d(c=x.shape[1], f=32, k=3, s=2)])(x)
    z = ReLU(z)

    for _ in range(num_layers - 1):
        z = Conv2d((c=32, f=32, k=3, s=1))(z)
        z = ReLU(z)

    z = flatten(z)

    # in: input dim, out: output_dim, h: hiddens

    z = mlp(in=z.size(),out=z_dim,h=1024)
    z = LayerNorm(z)
    z = tanh(z)

Terminology: A common point of confusion is the meaning "training steps." We use the term environment steps to denote the amount of times the simulator environment is stepped through and interaction steps to denote the number of times the agent steps through its policy. The terms action repeat or frame skip refer to the number of times an action is repeated when it's drawn from the agent's policy. For example, if action repeat is set to 4, then 100k interaction steps is equivalent to 400k environment steps.

Batch Updates: After initializing the replay buffer with observations extracted by a random agent, we sample a batch of observations, compute the CURL objectives, and step through the optimizer. Note that since queries and keys are generated by data-augmenting an observation, we can generate arbitrarily many keys to increase the contrastive batch size without sampling any additional observations.

Shared Representations: The objective of performing contrastive learning together with RL is to ensure that the shared encoder learns rich features that facilitate sample efficient control. There is a subtle coincidental connection between MoCo and off-policy RL. Both the frameworks adopt the usage of a momentum averaged (EMA) version of the underlying model. In MoCo, the EMA encoder is used for encoding the keys (targets) while in off-policy RL, the EMA version of the Q-networks are used as targets in the Bellman error [1, 18]. Thanks to this connection, CURL shares the convolutional encoder, momentum coefficient and EMA update between contrastive and reinforcement learning updates for the shared parameters. The MLP part of the critic that operates on top of these convolutional features has a separate momentum coefficient and update decoupled from the image encoder parameters.

Balancing Contrastive and RL Updates: While past work has learned hyperparameters to balance the auxiliary loss coefficient or learning rate relative to the RL objective [3, 27], CURL does not need any such adjustments. We use both the contrastive and RL objectives together with equal weight and learning rate. This simplifies the training process compared to other methods, such as training a VAE jointly [34, 35, 33], that require careful tuning of coefficients for representation learning.

Differences in Data Collection between Computer Vision and RL Settings: There are two key differences between contrastive learning in the computer vision and RL settings because of their different goals. Unsupervised feature learning methods built for downstream vision tasks like image classification assume a setting where there is a large static dataset of unlabeled images. On the other hand, in RL, the dataset changes over time to account for the agent's new experiences. Secondly, the size of the memory bank of labeled images and dataset of unlabeled ones in vision-based settings are 65K and 1M (or 1B) respectively. The goal in vision-based methods is to learn from millions of unlabeled images. On the other hand, the goal in CURL is to develop sample-efficient RL algorithms. For example, to be able to solve a task within 100K timesteps (approximately 2 hours in real-time), an agent can only ingest 100K image frames.

Therefore, unlike MoCo, CURL does not use a memory bank for contrastive learning. Instead, the negatives are constructed on the fly for every minibatch sampled from the agent's replay buffer for an RL update similar to SimCLR. The exact implementation is provided as a PyTorch-like code snippet in Section 4.7.

Data Augmentation:

Random crop data augmentation has been crucial for the performance of deep learning based computer vision systems in object recognition, detection and segmentation [57, 58, 59, 17]. However, similar augmentation methods have not seen much adoption in the field of RL even though several benchmarks use raw pixels as inputs to the model.

CURL adopts the random crop data augmentation as the stochastic data augmentation applied to a frame stack. To make it easier for the model to correlate spatio-temporal patterns in the input, we apply the same random crop (in terms of box coordinates) across all four frames in the stack as opposed to extracting different random crop positions from each frame in the stack. Further, unlike in computer vision systems where the aspect ratio for random crop is allowed to be as low as 0.08, we preserve much of the spatial information as possible and use a constant aspect ratio of 0.84 between the original and cropped. In our experiments, data augmented samples for CURL are formed by cropping $84\times84$ frames from an input frame of $100\times100$.

DMControl: We render observations at $100 \times 100$ and randomly crop $84 \times 84$ frames. For evaluation, we render observations at $100 \times 100$ and center crop to $84 \times 84$ pixels. We found that implementing random crop efficiently was extremely important to the success of the algorithm. We provide pseudocode below:

from skimage import view_as_windows
import numpy as np

def random_crop(imgs, out):
    """
    Vectorized random crop
    args:
        imgs: shape (B,C,H,W)
        out: output size (e.g. 84)
    """

    # n: batch size.
    n = imgs.shape[0]
    img_size = imgs.shape[-1] # e.g. 100
    crop_max = img_size - out

    imgs = np.transpose(imgs, (0, 2, 3, 1))

    w1 = np.random.randint(0, crop_max, n)
    h1 = np.random.randint(0, crop_max, n)

    # creates all sliding window
    # combinations of size (out)

    windows = view_as_windows(
        imgs, (1, out, out, 1))[..., 0,:,:, 0]

    # selects a random window 
    # for each batch element
    cropped = windows[np.arange(n), w1, h1]
    return cropped

B. Atari100k Implementation Details

The flexibility of CURL allows us to apply it to discrete control setting with minimal modifications. Similar to our rationale for picking SAC as the baseline RL algorithm to couple CURL with (for continuous control), we pick the data-efficient version of Rainbow DQN (Efficient Rainbow) [19] for Atari100K which performs competitively with an older version of SimPLe (most recent version has improved numbers). In order to understand specifically what the gains from CURL are without any other changes, we adopt the exact same hyperparameters specified in the paper [19] (including a modified convolutional encoder that uses larger kernel size and stride of 5). We present the details in Table 4. Similar to DMControl, the contrastive objective and the RL objective are weighted equally for learning (except for Pong, Freeway, Boxing and PrivateEye for which we used a coefficient of $0.05$ for the momentum contastive loss. On a large majority (22 out of 26) of the games, we do not use this adjustment. While it is standard practice to use the same hyperparameters for all games in Atari, papers proposing auxiliary losses have adopted a different practice of using game specific coefficients [3].). We use the Efficient Rainbow codebase from https://github.com/Kaixhin/Rainbow which has a reproduced version of [19]. We evaluate with $20$ random seeds and report the mean score for each game given the high variance nature of the Atari100k steps benchmark. We restrict ourselves to using grayscale renderings of image observations and use random crop of frame stack as data augmentation.

\begin{tabular}{ll}
\toprule
\textbf{Hyperparameter} & \textbf{Value} \\
\midrule
Random crop & True \\ 
Image size & $(84,84)$ \\ 
Data Augmentation & Random Crop (Train) \\
Replay buffer size & $100000$ \\ 
Training frames & $400000$ \\ 
Training steps & $100000$ \\
Frame skip & $4$ \\
Stacked frames & $4$ \\ 
Action repeat & $4$ \\
Replay period every & $1$ \\
Q network: channels & $32$, $64$ \\
Q network: filter size & $5\times 5, 5\times 5$ \\
Q network: stride & $5$, $5$ \\
Q network: hidden units & $256$ \\
Momentum (EMA for CURL) $\tau$ & $0.001$ \\
Non-linearity & ReLU \\
Reward Clipping & $[-1, 1]$ \\ 
Multi step return & $20$ \\
Minimum replay size for sampling & $1600$ \\ 
Max frames per episode & $108$K \\
Update & Distributional Double Q \\
Target Network Update Period & every $2000$ updates \\
Support-of-Q-distribution & $51$ bins \\ 
Discount $\gamma$ & $0.99$ \\
Batch Size & $32$ \\
Optimizer & Adam \\ 
Optimizer: learning rate & $0.0001$ \\
Optimizer: $\beta1$ & $0.9$ \\
Optimizer: $\beta2$ & $0.999$ \\ 
Optimizer $\epsilon$ & $0.000015$ \\
Max gradient norm & $10$ \\ 
Exploration & Noisy Nets \\
Noisy nets parameter & $0.1$ \\
Priority exponent & $0.5$ \\
Priority correction & $0.4 \rightarrow 1$ \\
Hardware & CPU \\
\bottomrule
\end{tabular}

C. Benchmarking Data Efficiency

Table 1 and Table 2 show the episode returns of DMControl100k, DMControl500k, and Atari100k across CURL and a number of pixel-based baselines. CURL outperforms all baseline pixel-based methods across experiments on both DMControl100k and DMControl500k. On Atari100k experiments, CURL coupled with Eff Rainbow outperforms the baseline on the majority of games tested (19 out of 26 games).

D. Further Investigation of Data-Efficiency in Contrastive RL

To further benchmark CURL's sample-efficiency, we compare it to state-based SAC on a total of 16 DMControl environments. Shown in Figure 7, CURL matches state-based data-efficiency on most of the environments, but lags behind state-based SAC on more challenging environments.

E. Ablations

E.1 Learning Temporal Dynamics

To gain insight as to whether CURL learns temporal dynamics across the stacked frames, we also train a variant of CURL where the discriminants are individual frames as opposed to stacked ones. This can be done by sampling stacked frames from the replay buffer but only using the first frame to update the contrastive loss:

f_q = x_q[:,:3,...] # (B,C,H,W), C=9.
f_k = x_k[:,:3,...]

During the actor-critic update, frames in the batch are encoded individually into latent codes, which are then concatenated before being passed to a dense network.

# x: (B,C,H,W), C=9.
z1 = encode(x[:,:3,...])
z2 = encode(x[:,3:6,...])
z3 = encode(x[:,6:9,...])
z = torch.cat([z1,z2,z3],-1)

Encoding each frame indiviudally ensures that the contrastive objective only has access to visual discriminants. Comparing the visual and spatiotemporal variants of CURL in Figure 8 shows that the variant trained on stacked frames outperforms the visual-only version in most environments. The only exceptions are reacher and ball-in-cup environments. Indeed, in those environments the visual signal is strong enough to solve the task optimally, whereas in other environments, such as walker and cheetah, where balance or coordination is required, visual information alone is insufficient.

E.2 Increasing Gradient Updates per Agent Step

Although most baselines we benchmark against use one gradient update per agent step, it was recently empirically shown that increasing the ratio of gradients per step improves data-efficiency in RL [37]. This finding is also supported by SLAC [33], where results are shown with a ratio of 1:1 (SLACv1) and 3:1 (SLACv2). We

\begin{tabular}{lcc}
\toprule
DMControl500k & CURL & SLACv2 \\
\midrule
Finger, spin & 923 $\pm$ 50 & 884 $\pm$ 98 \\
Walker, walk & 911 $\pm$ 35 & 891 $\pm$ 60\\\
Cheetah, run & 545 $\pm$ 39 & 791 $\pm$ 37 \\
Ball in cup, catch & 948 
$\pm$ 21  & 885 $\pm$ 154 \\
\midrule
DMControl100k & CURL & SLACv2 \\
\midrule
Finger, spin &  741$\pm$ 118  & 728 $\pm$212 \\
Walker, walk & 428 $\pm$ 59 & 513 $\pm$ 41 \\\
Cheetah, run & 314 $\pm$ 46 & 438 $\pm$ 76 \\
Ball in cup, catch &  899 $\pm$ 47 & 837 $\pm$ 147 \\
\bottomrule
\end{tabular}

E.3 Decoupling Representation Learning from Reinforcement Learning

Typically, Deep RL representations depend almost entirely on the reward function specific to a task. However, hand-crafted representations such as the proprioceptive state are independent of the reward function. It is much more desirable to learn reward-agnostic representations, so that the same representation can be re-used across different RL tasks. We test whether CURL can learn such representations by comparing CURL to a variant where the critic gradients are backpropagated through the critic and contrastive dense feedforward networks but stopped before reaching the convolutional neural network (CNN) part of the encoder.

Scores displayed in Figure 9 show that for many environments, the detached CNN representations are sufficient to learn an optimal policy. The major exception is the cheetah environment, where the detached representation significantly under-performs. Though promising, we leave further exploration of task-agnostic representations for future work.

E.4 Removing Data Augmentation for the Actor Critic

Our main results involve the use of data augmentations to regularize both the contrastive and SAC objectives. Here, we investigate whether the contrastive representations alone are sufficient for learning effective policies. In these experiments, we only augment the data for the contrastive objective but not for the SAC agent. As a result, data augmentation is used only to learn features but does not influence the control policy. The pseudocode is shown below:

# o = original unaugmented observation
# aug = augmentation
# contrastive = InfoNCE loss
o_anchor, o_target = aug(o), aug(o)
curl_loss = contrastive(o_anchor, o_target)
sac_loss = critic_loss(o) + actor_loss(o)
loss = curl_loss + sac_loss 
params = update(params, grad(loss, params))

DMControl500k results plotted in Figure 10 show that, on average, features learned through the contrastive loss alone improve the pixel SAC baseline by 2x. Augmenting the input passed to the SAC algorithm further improves performance.

E.5 Predicting State from Pixels

Despite improved sample-efficiency on most DMControl tasks, there is still a visible gap between the performance of SAC on state and SAC with CURL in some environments. Since CURL learns representations by performing instance discrimination across stacks of three frames, it's possible that the reason for degraded sample-efficiency on more challenging tasks is due to partial-observability of the ground truth state.

To test this hypothesis, we perform supervised regression $(X,Y)$ from pixels $X$ to the proprioceptive state $Y$, where each data point $x \in X$ is a stack of three consecutive frames and $y \in Y$ is the corresponding state extracted from the simulator. We find that the error in predicting the state from pixels correlates with the policy performance of pixel-based methods. Test-time error rates displayed in Figure 11 show that environments that CURL solves as efficiently as state-based SAC have low error-rates in predicting the state from stacks of pixels. The prediction error increases for more challenging environments, such as cheetah-run and walker-walk. Finally, the error is highest for environments where current pixel-based methods, CURL included, make no progress at all [9], such as humanoid and swimmer.

This investigation suggests that degraded policy performance on challenging tasks may result from the lack of requisite information about the underlying state in the pixel data used for learning representations. We leave further investigation for future work.

E.6 CURL + Efficient Rainbow Atari runs

We report the scores (Table 6 and Table 7) for 20 seeds across the 26 Atari games in the Atari100k benchmark for CURL coupled with Efficient Rainbow. The variance across multiple seeds is considerably high in this benchmark. Therefore, we report the scores for each of the seeds along with the mean and standard deviation for each game.

::: {caption="Table 6: CURL implemented on top of Efficient Rainbow - Scores reported for $20$ random seeds for each of the above games, with the last two rows being the mean and standard deviation across the runs."}

:::

::: {caption="Table 7: CURL implemented on top of Efficient Rainbow - Scores reported for $20$ random seeds for each of the above games, with the last two rows being the mean and standard deviation across the runs."}

:::

F. Document changelog

This document tracks the progress and changes of CURL. In order to help readers be aware of and understand the changes, here is a brief summary:

v1 Initial version.

v2 Minor changes to DMControl to account for frame skip factor when evaluating data-efficiency of CURL and baselines. Changed action repeat for the Walker-walk task from 4 to 2 to match baseline implementations.

v3 ICML 2020 Camera Ready. For our Atari experiments, we moved to the https://github.com/Kaixhin/Rainbow codebase for easy and clean benchmarking that directly builds on top of Efficient Rainbow without other changes. We also run 20 seeds as opposed to 3 seeds earlier given the high variance nature of the benchmark.

v4 Added in Appendix E.4 - an ablation investigating whether contrastive representations alone, with no augmentations passed to the policy during training, improve the baseline SAC policy.

G. Connection to work on data augmentations

Recently, there have been two papers published on using data augmentations for reinforcement learning, RAD [60] and DrQ [61]. These two papers present the version of CURL without an auxiliary contrastive loss but rather directly feeding in the augmented views of the image observations to the underlying value / policy network(s). Both RAD and DrQ present results on both continuous and discrete control environments, surpassing the results presented in CURL on both the DMControl and Atari benchmarks. Plenty of researchers have opined in public forums whether the results in RAD and DrQ make CURL irrelevant if the objective is to use data augmentations for data-efficient reinforcement learning. We believe that answering this question needs more nuance and present our opinions below:

1. If one has access to a rich stream of rewards from the underlying environment and is interested in optimzing the performance in terms of average reward, RAD and DrQ are likely to work better than CURL. The reason for this is simply that RAD and DrQ directly optimize for the objective one cares about, while CURL introduces an additional auxiliary consistency objective.

2. If one does not have access to a rich stream of rewards and is interested in learning good latent spaces in a task agnostic manner that can allow for data-efficient controllers across multiple tasks, CURL is the only option since the contrastive objective in CURL is reward independent. Our ablation on the detached encoder with the CURL objective present evidence that one could build simple MLPs on top of the CURL features without fine-tuning the underlying encoder and still be data-efficient on many of the DMControl tasks.

3. Future work in data-efficient reinforcement learning, particularly for real world settings, is likely to require approaches that do not rely on reward functions. In such scenarios, CURL is likely to be the more preferred approach. Further, one could potentially use CURL in a scenario where unsupervised pre-training without reward functions is initially performed before fine-tuning to the RL objective across multiple tasks.

Given the above reasons, there isn't a straightforward answer as to which is the better algorithm and the answer really depends on what the researcher / practioner wants to solve. We also emphasize that CURL was the first approach that used data augmentations effectively to significantly improve the data-efficiency of model-free reinforcement learning methods with very simple changes and showed improvement over relatively more complex model-based methods. The augmentations and results in CURL inspired future work in the form of RAD and DrQ. We hope that the analysis and results presented in CURL encourage researchers to employ data augmentations, contrastive losses and unsupervised pre-training for future reinforcement learning research.

References

Section Summary: This section compiles a numbered list of academic papers and technical reports, primarily from the fields of reinforcement learning, robotics, and unsupervised visual representation learning. Most citations come from researchers affiliated with DeepMind and focus on advances such as deep Q-networks, model-based planning, contrastive predictive coding, and scalable training methods for agents in games or simulated environments. The references span journal articles, conference papers, and arXiv preprints dating from 1990 to 2020.

[1] Mnih, V., Kavukcuoglu, K., Silver, D., Rusu, A. A., Veness, J., Bellemare, M. G., Graves, A., Riedmiller, M., Fidjeland, A. K., Ostrovski, G., et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.

[2] Lillicrap, T. P., Hunt, J. J., Pritzel, A., Heess, N., Erez, T., Tassa, Y., Silver, D., and Wierstra, D. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.

[3] Jaderberg, M., Mnih, V., Czarnecki, W. M., Schaul, T., Leibo, J. Z., Silver, D., and Kavukcuoglu, K. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016.

[4] Espeholt, L., Soyer, H., Munos, R., Simonyan, K., Mnih, V., Ward, T., Doron, Y., Firoiu, V., Harley, T., Dunning, I., et al. Impala: Scalable distributed deep-rl with importance weighted actor-learner architectures. arXiv preprint arXiv:1802.01561, 2018.

[5] Jaderberg, M., Czarnecki, W. M., Dunning, I., Marris, L., Lever, G., Castaneda, A. G., Beattie, C., Rabinowitz, N. C., Morcos, A. S., Ruderman, A., et al. Human-level performance in 3d multiplayer games with population-based reinforcement learning. Science, 364(6443):859–865, 2019.

[6] Kalashnikov, D., Irpan, A., Pastor, P., Ibarz, J., Herzog, A., Jang, E., Quillen, D., Holly, E., Kalakrishnan, M., Vanhoucke, V., et al. Qt-opt: Scalable deep reinforcement learning for vision-based robotic manipulation. arXiv preprint arXiv:1806.10293, 2018.

[7] Lake, B. M., Ullman, T. D., Tenenbaum, J. B., and Gershman, S. J. Building machines that learn and think like people. Behavioral and brain sciences, 40, 2017.

[8] Kaiser, L., Babaeizadeh, M., Milos, P., Osinski, B., Campbell, R. H., Czechowski, K., Erhan, D., Finn, C., Kozakowski, P., Levine, S., et al. Model-based reinforcement learning for atari. arXiv preprint arXiv:1903.00374, 2019.

[9] Tassa, Y., Doron, Y., Muldal, A., Erez, T., Li, Y., Casas, D. d. L., Budden, D., Abdolmaleki, A., Merel, J., Lefrancq, A., et al. Deepmind control suite. arXiv preprint arXiv:1801.00690, 2018.

[10] Mirowski, P., Pascanu, R., Viola, F., Soyer, H., Ballard, A. J., Banino, A., Denil, M., Goroshin, R., Sifre, L., Kavukcuoglu, K., et al. Learning to navigate in complex environments. arXiv preprint arXiv:1611.03673, 2016.

[11] Sutton, R. S. Integrated architectures for learning, planning, and reacting based on approximating dynamic programming. In Machine learning proceedings 1990, pp. 216–224. Elsevier, 1990.

[12] Ha, D. and Schmidhuber, J. World models. arXiv preprint arXiv:1803.10122, 2018.

[13] Schrittwieser, J., Antonoglou, I., Hubert, T., Simonyan, K., Sifre, L., Schmitt, S., Guez, A., Lockhart, E., Hassabis, D., Graepel, T., et al. Mastering atari, go, chess and shogi by planning with a learned model. arXiv preprint arXiv:1911.08265, 2019.

[14] Devlin, J., Chang, M.-W., Lee, K., and Toutanova, K. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.

[15] Hénaff, O. J., Srinivas, A., De Fauw, J., Razavi, A., Doersch, C., Eslami, S., and Oord, A. v. d. Data-efficient image recognition with contrastive predictive coding. arXiv preprint arXiv:1905.09272, 2019.

[16] He, K., Fan, H., Wu, Y., Xie, S., and Girshick, R. Momentum contrast for unsupervised visual representation learning. arXiv preprint arXiv:1911.05722, 2019a.

[17] Chen, T., Kornblith, S., Norouzi, M., and Hinton, G. A simple framework for contrastive learning of visual representations, 2020.

[18] Haarnoja, T., Zhou, A., Hartikainen, K., Tucker, G., Ha, S., Tan, J., Kumar, V., Zhu, H., Gupta, A., Abbeel, P., et al. Soft actor-critic algorithms and applications. arXiv preprint arXiv:1812.05905, 2018.

[19] van Hasselt, H. P., Hessel, M., and Aslanides, J. When to use parametric models in reinforcement learning? In Advances in Neural Information Processing Systems, pp. 14322–14333, 2019.

[20] van den Oord, A., Li, Y., and Vinyals, O. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.

[21] Wu, Z., Xiong, Y., Yu, S., and Lin, D. Unsupervised feature learning via non-parametric instance-level discrimination. arXiv preprint arXiv:1805.01978, 2018.

[22] Wang, X. and Gupta, A. Unsupervised learning of visual representations using videos. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2794–2802, 2015.

[23] Chopra, S., Hadsell, R., and LeCun, Y. Learning a similarity metric discriminatively, with application to face verification. In 2005 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR'05), volume 1, pp. 539–546. IEEE, 2005.

[24] Shelhamer, E., Mahmoudieh, P., Argus, M., and Darrell, T. Loss is its own reward: Self-supervision for reinforcement learning. arXiv preprint arXiv:1612.07307, 2016.

[25] Schmidhuber, J. Making the world differentiable: On using fully recurrent self-supervised neural networks for dynamic reinforcement learning and planning in non-stationary environments. Technical Report FKI-126-90, TUM, 1990.

[26] Higgins, I., Pal, A., Rusu, A., Matthey, L., Burgess, C., Pritzel, A., Botvinick, M., Blundell, C., and Lerchner, A. Darla: Improving zero-shot transfer in reinforcement learning. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1480–1490. JMLR. org, 2017.

[27] Yarats, D., Zhang, A., Kostrikov, I., Amos, B., Pineau, J., and Fergus, R. Improving sample efficiency in model-free reinforcement learning from images. arXiv preprint arXiv:1910.01741, 2019.

[28] Sermanet, P., Lynch, C., Chebotar, Y., Hsu, J., Jang, E., Schaal, S., Levine, S., and Brain, G. Time-contrastive networks: Self-supervised learning from video. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pp. 1134–1141. IEEE, 2018.

[29] Dwibedi, D., Tompson, J., Lynch, C., and Sermanet, P. Learning actionable representations from visual observations. In 2018 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 1577–1584. IEEE, 2018.

[30] Warde-Farley, D., Van de Wiele, T., Kulkarni, T., Ionescu, C., Hansen, S., and Mnih, V. Unsupervised control through non-parametric discriminative rewards. arXiv preprint arXiv:1811.11359, 2018.

[31] Anand, A., Racah, E., Ozair, S., Bengio, Y., Côté, M.-A., and Hjelm, R. D. Unsupervised state representation learning in atari. In Advances in Neural Information Processing Systems, pp. 8766–8779, 2019.

[32] Srinivas, A., Jabri, A., Abbeel, P., Levine, S., and Finn, C. Universal planning networks. arXiv preprint arXiv:1804.00645, 2018.

[33] Lee, A. X., Nagabandi, A., Abbeel, P., and Levine, S. Stochastic latent actor-critic: Deep reinforcement learning with a latent variable model. arXiv preprint arXiv:1907.00953, 2019.

[34] Hafner, D., Lillicrap, T., Fischer, I., Villegas, R., Ha, D., Lee, H., and Davidson, J. Learning latent dynamics for planning from pixels. arXiv preprint arXiv:1811.04551, 2018.

[35] Hafner, D., Lillicrap, T., Ba, J., and Norouzi, M. Dream to control: Learning behaviors by latent imagination. arXiv preprint arXiv:1912.01603, 2019.

[36] Bellemare, M. G., Naddaf, Y., Veness, J., and Bowling, M. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, 2013.

[37] Kielak, K. Do recent advancements in model-based deep reinforcement learning really improve data efficiency?, 2020.

[38] Hessel, M., Modayil, J., van Hasselt, H., Schaul, T., Ostrovski, G., Dabney, W., Horgan, D., Piot, B., Azar, M., and Silver, D. Rainbow: Combining improvements in deep reinforcement learning, 2017.

[39] Van Hasselt, H., Guez, A., and Silver, D. Deep reinforcement learning with double q-learning. In Thirtieth AAAI conference on artificial intelligence, 2016.

[40] Wang, Z., Schaul, T., Hessel, M., Van Hasselt, H., Lanctot, M., and De Freitas, N. Dueling network architectures for deep reinforcement learning. arXiv preprint arXiv:1511.06581, 2015.

[41] Schaul, T., Quan, J., Antonoglou, I., and Silver, D. Prioritized experience replay. arXiv preprint arXiv:1511.05952, 2015.

[42] Fortunato, M., Azar, M. G., Piot, B., Menick, J., Osband, I., Graves, A., Mnih, V., Munos, R., Hassabis, D., Pietquin, O., et al. Noisy networks for exploration. arXiv preprint arXiv:1706.10295, 2017.

[43] Bellemare, M. G., Dabney, W., and Munos, R. A distributional perspective on reinforcement learning. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 449–458. JMLR. org, 2017.

[44] Sutton, R. S. et al. Introduction to reinforcement learning, volume 135. 1998.

[45] Hadsell, R., Chopra, S., and LeCun, Y. Dimensionality reduction by learning an invariant mapping. In 2006 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR'06), volume 2, pp. 1735–1742. IEEE, 2006.

[46] LeCun, Y., Chopra, S., Hadsell, R., Ranzato, M., and Huang, F. A tutorial on energy-based learning. 2006.

[47] Schroff, F., Kalenichenko, D., and Philbin, J. Facenet: A unified embedding for face recognition and clustering. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 815–823, 2015.

[48] He, K., Fan, H., Wu, Y., Xie, S., and Girshick, R. Momentum contrast for unsupervised visual representation learning. 2019b.

[49] Bachman, P., Hjelm, R. D., and Buchwalter, W. Learning representations by maximizing mutual information across views. In Advances in Neural Information Processing Systems, pp. 15509–15519, 2019.

[50] Tian, Y., Krishnan, D., and Isola, P. Contrastive multiview coding. arXiv preprint arXiv:1906.05849, 2019.

[51] Henderson, P., Islam, R., Bachman, P., Pineau, J., Precup, D., and Meger, D. Deep reinforcement learning that matters. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.

[52] Hjelm, R. D., Fedorov, A., Lavoie-Marchildon, S., Grewal, K., Bachman, P., Trischler, A., and Bengio, Y. Learning deep representations by mutual information estimation and maximization. arXiv preprint arXiv:1808.06670, 2018.

[53] Tschannen, M., Djolonga, J., Rubenstein, P. K., Gelly, S., and Lucic, M. On mutual information maximization for representation learning. arXiv preprint arXiv:1907.13625, 2019.

[54] Kingma, D. P. and Welling, M. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.

[55] Vincent, P., Larochelle, H., Bengio, Y., and Manzagol, P.-A. Extracting and composing robust features with denoising autoencoders. In Proceedings of the 25th international conference on Machine learning, pp. 1096–1103, 2008.

[56] Ghosh, P., Sajjadi, M. S. M., Vergari, A., Black, M., and Schölkopf, B. From variational to deterministic autoencoders, 2019.

[57] Krizhevsky, A., Sutskever, I., and Hinton, G. E. Imagenet classification with deep convolutional neural networks. In Pereira, F., Burges, C. J. C., Bottou, L., and Weinberger, K. Q. (eds.), Advances in Neural Information Processing Systems 25, pp. 1097–1105. Curran Associates, Inc., 2012.

[58] Szegedy, C., Liu, W., Jia, Y., Sermanet, P., Reed, S., Anguelov, D., Erhan, D., Vanhoucke, V., and Rabinovich, A. Going deeper with convolutions. In Computer Vision and Pattern Recognition (CVPR), 2015. URL http://arxiv.org/abs/1409.4842.

[59] Cubuk, E. D., Zoph, B., Shlens, J., and Le, Q. V. Randaugment: Practical automated data augmentation with a reduced search space, 2019.

[60] Laskin, M., Lee, K., Stooke, A., Pinto, L., Abbeel, P., and Srinivas, A. Reinforcement learning with augmented data. arXiv preprint arXiv:2004.14990, 2020.

[61] Kostrikov, I., Yarats, D., and Fergus, R. Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. arXiv preprint arXiv:2004.13649, 2020.