Automatic Data Augmentation for Generalization in Reinforcement Learning
Year: 2021

Abstract:
Deep reinforcement learning (RL) agents often fail to generalize beyond their training environments. To alleviate this problem, recent work has proposed the use of data augmentation. However, different tasks tend to benefit from different types of augmentations and selecting the right one typically requires expert knowledge. In this paper, we introduce three approaches for automatically finding an effective augmentation for any RL task. These are combined with two novel regularization terms for the policy and value function, required to make the use of data augmentation theoretically sound for actor-critic algorithms. Our method achieves a new state-of-the-art1on the Procgen benchmark and outperforms popular RL algorithms on DeepMind Control tasks with distractors. In addition, our agent learns policies and representations which are more robust to changes in the environment that are irrelevant for solving the task, such as the background. Our code is available at https://github.com/rraileanu/auto-drac.

heading: 1 Introduction
text: Generalization to new environments remains a major challenge in deep reinforcement learning (RL). Current methods fail to generalize to unseen environments even when trained on similar settings [19, 51, 71, 11, 21, 12, 60]. This indicates that standard RL agents memorize specific trajectories rather than learning transferable skills. Several strategies have been proposed to alleviate this problem, such as the use of regularization [19, 71, 11, 28], data augmentation [11, 44, 69, 38, 41], or representation learning [72, 74]. In this work, we focus on the use of data augmentation in RL. We identify key differences between supervised learning and reinforcement learning which need to be taken into account when using data augmentation in RL.
More specifically, we show that a naive application of data augmentation can lead to both theoretical and practical problems with standard RL algorithms, such as unprincipled objective estimates and poor performance. As a solution, we propose Data-regularized Actor-Critic or DrAC, a new algorithm that enables the use of data augmentation with actor-critic algorithms in a theoretically sound way. Specifically, we introduce two regularization terms which constrain the agent’s policy and value function to be invariant to various state transformations. Empirically, this approach allows the agent to learn useful behaviors (outperforming strong RL baselines) in settings in which a naive use of data augmentation completely fails or converges to a sub-optimal policy. While we use Proximal Policy Optimization (PPO, Schulman et al. [56]) to describe and validate our approach, the method
1in June 2020, at the time of making this work publicly available on arXiv. it has since been surpassed.
35th Conference on Neural Information Processing Systems (NeurIPS 2021).
can be easily integrated with any actor-critic algorithm with a discrete stochastic policy such as A3C [49], SAC [24], or IMPALA [17].
The current use of data augmentation in RL either relies on expert knowledge to pick an appropriate augmentation [11, 44, 38] or separately evaluates a large number of transformations to find the best one [69, 41]. In this paper, we propose three methods for automatically finding a useful augmentation for a given RL task. The first two learn to select the best augmentation from a fixed set, using either a variant of the upper confidence bound algorithm (UCB, Auer [2]) or meta-learning (RL2, Wang et al. [66]). We refer to these methods as UCB-DrAC and RL2-DrAC, respectively. The third method, Meta-DrAC, directly meta-learns the weights of a convolutional network, without access to predefined transformations (MAML, Finn et al. [20]). Figure 1 gives an overview of UCB-DrAC.
We evaluate these approaches on the Procgen generalization benchmark [12] which consists of 16 procedurally generated environments with visual observations. Our results show that UCB-DrAC is the most effective among these at finding a good augmentation, and is comparable or better than using DrAC with the best augmentation from a given set. UCB-DrAC also outperforms baselines specifically designed to improve generalization in RL [28, 44, 41] on both train and test. In addition, we show that our agent learns policies and representations that are more invariant to changes in the environment which do not alter the reward or transition function (i.e. they are inconsequential for control), such as the background theme.
To summarize, our work makes the following contributions: (i) we introduce a principled way of using data augmentation with actor-critic algorithms, (ii) we propose a practical approach for automatically selecting an effective augmentation in RL settings, (iii) we show that the use of data augmentation leads to policies and representations that better capture task invariances, and (iv) we demonstrate state-of-the-art results on the Procgen benchmark and outperform popular RL methods on four DeepMind Control tasks with natural and synthetic distractors.

heading: 2 Background
text: We consider a distribution q(m) of Partially Observable Markov Decision Processes (POMDPs, [6]) m ∈ M, with m defined by the tuple (Sm,Om,A, Tm, Rm, γ), where Sm is the state space, Om is the observation space, A is the action space, Tm(s′|s, a) is the transition function, Rm(s, a) is the reward function, and γ is the discount factor. During training, we restrict access to a fixed set of POMDPs, Mtrain = {m1, . . . ,mn}, where mi ∼ q, ∀ i = 1, n. The goal is to find a policy πθ which maximizes the expected discounted reward over the entire distribution of POMDPs, J(πθ) = Eq,π,Tm,pm [∑T t=0 γ tRm(st, at) ] .
In practice, we use the Procgen benchmark which contains 16 procedurally generated games. Each game corresponds to a distribution of POMDPs q(m), and each level of a game corresponds to a POMDP sampled from that game’s distribution m ∼ q. The POMDP m is determined by the seed (i.e. integer) used to generate the corresponding level. Following the setup from Cobbe et al. [12], agents are trained on a fixed set of n = 200 levels (generated using seeds from 1 to 200) and tested on the full distribution of levels (generated by sampling seeds uniformly at random from all computer integers).
Proximal Policy Optimization (PPO, Schulman et al. [56]) is an actor-critic algorithm that learns a policy πθ and a value function Vθ with the goal of finding an optimal policy for a given POMDP.
PPO alternates between sampling data through interaction with the environment and maximizing a clipped surrogate objective function using stochastic gradient ascent.
One component of the PPO objective is the policy gradient term JPG, which is estimated using importance sampling:
JPG(θ) = ∑ a∈A πθ(a|s)Âθold(s, a) = Ea∼πθold [ πθ(a|s) πθold(a|s) Âθold(s, a) ] , (1)
where Â(·) is an estimate of the advantage function, πθold is the behavior policy used to collect trajectories (i.e. that generates the training distribution of states and actions), and πθ is the policy we want to optimize (i.e. that generates the true distribution of states and actions). See Appendix A for a full description of PPO.

heading: 3 Automatic Data Augmentation for RL

heading: 3.1 Data Augmentation in RL
text: Image augmentation has been successfully applied in computer vision for improving generalization on object classification tasks [58, 9, 8, 39]. As noted by Kostrikov et al. [38], those tasks are invariant to certain image transformations such as rotations or flips, which is not always the case in RL. For example, if your observation is flipped, the corresponding reward will be reversed for the left and right actions and will not provide an accurate signal to the agent. While data augmentation has been previously used in RL settings without other algorithmic changes [11, 69, 41], we argue that this approach is not theoretically sound.
If transformations are naively applied to observations in PPO’s buffer, as done in Laskin et al. [41], the PPO objective changes and equation (1) is replaced by
JPG(θ) = Ea∼πθold [ πθ(a|f(s)) πθold(a|s) Âθold(s, a) ] , (2)
where f : S × H → S is the image transformation. However, the right hand side of the above equation is not a sound estimate of the left hand side because πθ(a|f(s)) 6= πθ(a|s), since nothing constrains πθ(a|f(s)) to be close to πθ(a|s). Note that in the on-policy case when θ = θold, the ratio used to estimate the advantage should be equal to one, which is not necessarily the case when using equation (2). In fact, one can define certain transformations f(·) that result in an arbitrarily large ratio πθ(a|f(s))/πθold(a|s). Figure 3 shows examples where a naive use of data augmentation prevents PPO from learning a good policy in practice, suggesting that this is not just a theoretical concern. In the following section, we propose an algorithmic change that enables the use of data augmentation with actor-critic algorithms in a principled way.

heading: 3.2 Policy and Value Function Regularization
text: Inspired by the recent work of Kostrikov et al. [38], we propose two novel regularization terms for the policy and value functions that enable the proper use of data augmentation for actor-critic algorithms. Our algorithmic contribution differs from that of Kostrikov et al. [38] in that it constrains both the actor and the critic, as opposed to only regularizing the Q-function. This allows our method to be used with a different (and arguably larger) class of RL algorithms, namely those that learn a policy and a value function.
Following Kostrikov et al. [38], we define an optimality-invariant state transformation f : S×H → S as a mapping that preserves both the agent’s policy π and its value function V such that V (s) = V (f(s, ν)) and π(a|s) = π(a|f(s, ν)), ∀s ∈ S, ν ∈ H, where ν are the parameters of f(·), drawn from the set of all possible parametersH. To ensure that the policy and value functions are invariant to such transformation of the input state, we propose an additional loss term for regularizing the policy,
Gπ = KL [πθ(a|s) | πθ(a|f(s, ν))] , (3)
as well as an extra loss term for regularizing the value function,
GV = (Vφ(s)− Vφ (f(s, ν)))2 . (4)
Thus, our data-regularized actor-critic method, or DrAC, maximizes the following objective:
JDrAC = JPPO − αr(Gπ +GV ), (5)
where αr is the weight of the regularization term (see Algorithm 1).
The use of Gπ and GV ensures that the agent’s policy and value function are invariant to the transformations induced by various augmentations. Particular transformations can be used to impose certain inductive biases relevant for the task (e.g. invariance with respect to colors or translations). In addition, Gπ and GV can be added to the objective of any actor-critic algorithm with a discrete stochastic policy (e.g. A3C, TRPO, ACER, SAC, or IMPALA) without any other changes.
Note that when using DrAC, as opposed to the method proposed by Laskin et al. [41], we still use the correct importance sampling estimate of the left hand side objective in equation (1) (instead of a wrong estimate as in equation (2)). This is because the transformed observations f(s) are only used to compute the regularization losses Gπ and GV , and thus are not used for the main PPO objective. Without these extra terms, the only way to use data augmentation is as explained in Section 3.1, which leads to inaccurate estimates of the PPO objective. Hence, DrAC benefits from the regularizing effect of using data augmentation, while mitigating adverse consequences on the RL objective. See Appendix B for a more detailed explanation of why a naive application of data augmentation with certain policy gradient algorithms is theoretically unsound.
Algorithm 1 DrAC: Data-regularized Actor-Critic applied to PPO Black: unmodified actor-critic algorithm. Cyan: image transformation. Red: policy regularization. Blue: value function regularization.
1: Hyperparameters: image transformation f , regularization loss coefficient αr, minibatch size M, replay buffer size T, number of updates K. 2: for k = 1, . . . ,K do 3: Collect a new set of transitions D = {(si, ai, ri, si+1)}Ti=1 using πθ. 4: for j = 1, . . . , ∗ TM do 5: {(si, ai, ri, si+1)}Mi=1 ∼ D . Sample a minibatch of transitions 6: for i = 1, . . . ,M do 7: νi ∼ H . Sample the augmentation parameters 8: π̂i ← πφ(·|si) . Compute the policy targets 9: V̂i ← Vφ(si) . Compute the value function targets
10: end for 11: Gπ(θ) = 1 M ∑M i=1 KL [π̂i | πθ(·|f(si, νi))] . Regularize the policy
12: GV (φ) = 1 M ∑M i=1 ( V̂i − Vφ (f(si, νi)) )2 . Regularize the value function 13: JDrAC(θ, φ) = JPPO(θ, φ)− αr(Gπ(θ) +GV (φ)) . Compute the total loss function 14: θ ← argmaxθ JDrAC . Update the policy 15: φ← argmaxφ JDrAC . Update the value function 16: end for 17: end for

heading: 3.3 Automatic Data Augmentation
text: Since different tasks benefit from different types of transformations, we would like to design a method that can automatically find an effective transformation for any given task. Such a technique would significantly reduce the computational requirements for applying data augmentation in RL. In this section, we describe three approaches for doing this. In all of them, the augmentation learner is trained at the same time as the agent learns to solve the task using DrAC. Hence, the distribution of rewards varies significantly as the agent improves, making the problem highly nonstationary.
Upper Confidence Bound. The problem of selecting a data augmentation from a given set can be formulated as a multi-armed bandit problem, where the action space is the set of available transformations F = {f1, . . . , fn}. A popular algorithm for such settings is the upper confidence bound or UCB [2], which selects actions according to the following policy:
ft = argmaxf∈F [ Qt(f) + c √ log(t)
Nt(f)
] , (6)
where ft is the transformation selected at time step t, Nt(f) is the number of times transformation f has been selected before time step t and c is UCB’s exploration coefficient. Before the t-th DrAC update, we use equation (6) to select an augmentation f . Then, we use equation (5) to update the agent’s policy and value function. We also update the counter: Nt(f) = Nt−1(f) + 1. Next, we collect rollouts with the new policy and update the Q-function: Qt(f) = 1K ∑t i=t−K R(fi = f), which is computed as a sliding window average of the past K mean returns obtained by the agent after being updated using augmentation f . We refer to this algorithm as UCB-DrAC (Algorithm 4). Note that UCB-DrAC’s estimation of Q(f) differs from that of a typical UCB algorithm which uses rewards from the entire history. However, the choice of estimating Q(f) using only more recent rewards is crucial due to the nonstationarity of the problem.
Meta-Learning the Selection of an Augmentation. Alternatively, the problem of selecting a data augmentation from a given set can be formulated as a meta-learning problem. Here, we consider a meta-learner like the one proposed by Wang et al. [66]. Before each DrAC update, the meta-learner selects an augmentation, which is then used to update the agent using equation (5). We then collect rollouts using the new policy and update the meta-learner using the mean return of these trajectories. We refer to this approach as RL2-DrAC (Algorithm 4).
Meta-Learning the Weights of an Augmentation. Another approach for automatically finding an appropriate augmentation is to directly learn the weights of a certain transformation rather than selecting an augmentation from a given set. In this work, we focus on meta-learning the weights of a convolutional network which can be applied to the observations to obtain a perturbed image. We meta-learn the weights of this network using an approach similar to the one proposed by Finn et al. [20]. For each agent update, we also perform a meta-update of the transformation function by splitting DrAC’s buffer into meta-train and meta-test sets. We refer to this approach as Meta-DrAC (Algorithm 4). More details about the implementation of these methods can be found in Appendix D.

heading: 4 Experiments
text: In this section, we evaluate our methods on four DeepMind Control environments with natural and synthetic distractors and the full Procgen benchmark [12] which consists of 16 procedurally generated games (see Figure 6 in Appendix G). Procgen has a number of attributes that make it a good testbed for generalization in RL: (i) it has a diverse set of games in a similar spirit with the ALE benchmark [5], (ii) each of these games has procedurally generated levels which present agents with meaningful generalization challenges, (iii) agents have to learn motor control directly from images, and (iv) it has a clear protocol for testing generalization.
All environments use a discrete 15 dimensional action space and produce 64× 64× 3 RGB observations. We use Procgen’s easy setup, so for each game, agents are trained on 200 levels and tested on the full distribution of levels. We use PPO as a base for all our methods. More details about our experimental setup and hyperparameters can be found in Appendix E.
Data Augmentation. In our experiments, we use a set of eight transformations: crop, grayscale, cutout, cutout-color, flip, rotate, random convolution and color-jitter [39, 15]. We use RAD’s [41] implementation of these transformations, except for crop, in which we pad the image with 12 (boundary) pixels on each side and select random crops of 64× 64. We found this implementation of crop to be significantly better on Procgen, and thus it can be considered an empirical upper bound of RAD in this case. For simplicity, we will refer to our implementation as RAD. DrAC uses the same set of transformations as RAD, but is trained with additional regularization losses for the actor and the critic, as described in Section 3.2.
Automatic Selection of Data Augmentation. We compare three different approaches for automatically finding an effective transformation: UCB-DrAC which uses UCB [2] to select an augmentation
from a given set, RL2-DrAC which uses RL2 [67] to do the same, and Meta-DrAC which uses MAML [20] to meta-learn the weights of a convolutional network. Meta-DrAC is implemented using the higher library [22]. Note that we do not expect these approaches to be better than DrAC with the best augmentation. In fact, DrAC with the best augmentation can be considered to be an upper bound for these automatic approaches since it uses the best augmentation during the entire training process.
Ablations. DrC and DrA are ablations to DrAC that use only the value or only the policy regularization terms, respectively. DrC can be thought of an analogue of DrQ [38] applied to PPO rather than SAC. Rand-DrAC uses a uniform distribution to select an augmentation each time. Crop-DrAC uses crop for all games (which is the most effective augmentation on half of the Procgen games). UCB-RAD combines UCB with RAD (i.e. it does not use the regularization terms).
Baselines. We also compare with Rand-FM [44], IBAC-SNI [28], Mixreg [66], and PLR [32], four methods specifically designed for improving generalization in RL and previously tested on Procgen environments. Rand-FM uses a random convolutional networks to regularize the learned representations, while IBAC-SNI uses an information bottleneck with selective noise injection. Mixreg uses mixtures of observations to impose linearity constraints between the agent’s inputs and the outputs, while PLR samples levels according to their learning potential.
Evaluation Metrics. At the end of training, for each method and each game, we compute the average score over 100 episodes and 10 different seeds. The scores are then normalized using the corresponding PPO score on the same game. We aggregate the normalized scores over all 16 Procgen games and report the resulting mean, median, and standard deviation (Table 1). For a per-game breakdown, see Tables 6 and 7 in Appendix J.

heading: 4.1 Generalization Performance on Procgen
text: Table 1 shows train and test performance on Procgen. UCB-DrAC significantly outperforms PPO, Rand-FM, IBAC-SNI, PLR, and Mixreg. As shown in Jiang et al. [32], combining PLR with UCBDrAC achieves a new state-of-the-art on Procgen leading to a 76% gain over PPO. Regularizing the policy and value function leads to improvements over merely using data augmentation, and thus the performance of DrAC is better than that of RAD (both using the best augmentation for each game). In addition, we demonstrate the importance of regularizing both the policy and the value function rather than either one of them by showing that DrAC is superior to both DrA and DrC (see Figures 9 and 10 in Appendix K). Our experiments show that the most effective way of automatically finding an augmentation is UCB-DrAC. As expected, meta-learning the weights of a CNN using Meta-DrAC performs reasonably well on the games in which the random convolution augmentation helps. But overall, Meta-DrAC and RL2-DrAC are worse than UCB-DrAC. In addition, UCB is generally more stable, easier to implement, and requires less fine-tuning compared to meta-learning algorithms. See
Figures 8 and 7 in Appendix K for a comparison of these three approaches on each game. Moreover, automatically selecting the augmentation from a given set using UCB-DrAC performs similarly well or even better than a method that uses the best augmentation for each task throughout the entire training process. UCB-DrAC also achieves higher returns than an ablation that uses a uniform distribution to select an augmentation each time, Rand-DrAC. Nevertheless, UCB-DrAC is better than Crop-DrAC, which uses crop for all the games (which is the best augmentation for eight of the Procgen games as shown in Tables 4 and 5 from Appendix H).

heading: 4.2 DeepMind Control with Distractors
text: In this section, we evaluate our approach on the DeepMind Control Suite from pixels (DMC, Tassa et al. [64]). We use four tasks, namely Cartpole Balance, Finger Spin, Walker Walk, and Cheetah Run, in three settings with different types of backgrounds, namely the default, simple distractors, and natural videos from the Kinetics dataset [35], as introduced in Zhang et al. [73]. See Figure 11 for a few examples. Note that in the simple and natural settings, the background is sampled from a list of videos at the beginning of each episode, which creates spurious correlations between the backgrounds and the rewards. In the simple and natural distractor settings, as shown in Figure 13, UCB-DrAC outperforms PPO and RAD on all these environments in the most challenging setting with natural distractors. See Appendix L for results on DMC with default and simple distractor backgrounds, where our method also outperforms the baselines.

heading: 4.3 Regularization Effect
text: In Section 3.1, we argued that additional regularization terms are needed in order to make the use of data augmentation in RL theoretically sound. However, one might wonder if this problem actually appears in practice. Thus, we empirically investigate the effect of regularizing the policy and value function. For this purpose, we compare the performance of RAD and DrAC with grayscale and random convolution augmentations on Chaser, Miner, and StarPilot.
Figure 3 shows that not regularizing the policy and value function with respect to the transformations used can lead to drastically worse performance than vanilla RL methods, further emphasizing the
importance of these loss terms. In contrast, using the regularization terms as part of the RL objective (as DrAC does) results in an agent that is comparable or, in some cases, significantly better than PPO.

heading: 4.4 Automatic Augmentation
text: Our experiments indicate there is not a single augmentation that works best across all Procgen games (see Tables 4 and 5 in Appendix H). Moreover, our intuitions regarding the best transformation for each game might be misleading. For example, at a first sight, Ninja appears to be somewhat similar to Jumper, but the augmentation that performs best on Ninja is color-jitter, while for Jumper is random-conv (see Tables 4 and 5). In contrast, Miner seems like a different type of game than Climber or Ninja, but they all have the same best performing augmentation, namely color-jitter. These observations further underline the need for a method that can automatically find the right augmentation for each task.
Table 1 along with Figures 8 and 7 in the Appendix compare different approaches for automatically finding an augmentation, showing that UCB-DrAC performs best and reaches the asymptotic performance obtained when the most effective transformation for each game is used throughout the entire training process. Figure 4 illustrates an example of UCB’s policy during training on Ninja and Dodgeball, showing that it converges to always selecting the most effective augmentation, namely color-jitter for Ninja and crop for Dodgeball. Finally, Figure 5 in Appendix F illustrates how UCB’s behavior varies with its exploration coefficient.

heading: 4.5 Robustness Analysis
text: To further investigate the generalizing ability of these agents, we analyze whether the learned policies and state representations are invariant to changes in the observations which are irrelevant for solving the task.
We first measure the Jensen-Shannon divergence (JSD) between the agent’s policy for an observation from a training level and a modified version of that observation with a different background theme (i.e. color and pattern). Note that the JSD also represents a lower bound for the joint empirical risk across train and test [30]. The background theme is randomly selected from the set of backgrounds available for all other Procgen environments, except for the one of the original training level. Note that the modified observation has the same semantics as the original one (with respect to the reward function), so the agent should have the same policy in both cases. Moreover, many of the backgrounds are not uniform and can contain items such as trees or planets which can be easily misled for objects the agent can interact with. As seen in Table 2, UCB-DrAC has a lower JSD than PPO, indicating that it learns a policy that is more robust to changes in the background.
To quantitatively evaluate the quality of the learned representation, we use the cycle-consistency metric proposed by Aytar et al. [3] and also used by Lee et al. [44]. See Appendix C for more details about this metric. Table 2 reports the percentage of input observations in the seen environment that are cycle-consistent with trajectories in modified unseen environments, which have a different background but the same layout. UCB-DrAC has higher cycle-consistency than PPO, suggesting that it learns representations that better capture relevant task invariances.

heading: 5 Related Work
text: Generalization in Deep RL. A recent body of work has pointed out the problem of overfitting in deep RL [53, 46, 34, 51, 71, 75, 50, 11, 12, 33, 52, 40, 23]. A promising approach to prevent overfitting is to apply regularization techniques originally developed for supervised learning such as dropout [62, 28] or batch normalization [31, 19, 28]. For example, Igl et al. [28] use selective noise injection with a variational information bottleneck, while Lee et al. [44] regularize the agent’s representation with respect to random convolutional transformations. The use of state abstractions has also been proposed for improving generalization in RL [72, 74, 1]. Similarly, Roy and Konidaris [54] and Sonar et al. [59] learn domain-invariant policies via feature alignment, while Stooke et al. [63] decouple representation from policy learning. Igl et al. [29] reduce non-stationarity using policy distillation, while Mazoure et al. [47] maximize the mutual information between the agent’s representation of successive time steps. Jiang et al. [32] improve efficiency and generalization by sampling levels according to their learning potential, while Wang et al. [67] use mixtures of observations to impose linearity constraints between the agent’s inputs and the outputs. More similar to our work, Cobbe et al. [11], Ye et al. [69] and Laskin et al. [41] add augmented observations to the training buffer of an RL agent. However, as we show here, naively applying data augmentation in RL can lead to both theoretical and practical issues. Our algorithmic contributions alleviate these problems while still benefitting from the regularization effect of data augmentation.
Data Augmentation has been extensively used in computer vision for both supervised [42, 4, 43, 58, 9, 10, 39] and self-supervised [16, 48] learning. More recent work uses data augmentation for contrastive learning, leading to state-of-the-art results on downstream tasks [70, 26, 25, 7]. Domain
randomization can also be considered a type of data augmentation, which has proven useful for transferring RL policies from simulation to the real world [65]. However, it requires access to a physics simulator, which is not always available. Recently, a few papers propose the use of data augmentation in RL [11, 44, 61, 38, 41], but all of them use a fixed (set of) augmentation(s) rather than automatically finding the most effective one. The most similar work to ours is that of Kostrikov et al. [38], who propose to regularize the Q-function in Soft Actor-Critic (SAC) [24] using random shifts of the input image. Our work differs from theirs in that it automatically selects an augmentation from a given set, regularizes both the actor and the critic, and focuses on the problem of generalization rather than sample efficiency. While there is a body of work on the automatic use of data augmentation [14, 13, 18, 57, 45], these approaches were designed for supervised learning and, as we explain here, cannot be applied to RL without further algorithmic changes.

heading: 6 Discussion
text: In this work, we propose UCB-DrAC, a method for automatically finding an effective data augmentation for RL tasks. Our approach enables the principled use of data augmentation with actor-critic algorithms by regularizing the policy and value functions with respect to state transformations. We show that UCB-DrAC avoids the theoretical and empirical pitfalls typical in naive applications of data augmentation in RL. Our approach improves training performance by 19% and test performance by 40% on the Procgen benchmark, and sets a new state-of-the-art on the Procgen benchmark. In addition, the learned policies and representations are more invariant to spurious correlations between observations and rewards. One limitation of our work is the assumption that using a single type of data augmentation throughout the entire training process is optimal. In future work, we plan to study the effect of using multiple augmentations at different stages during the training of the agent’s policy. Another promising avenue for future research is to use a more expressive function class for meta-learning the transformations in order to capture a wider range of inductive biases.
Acknowledgments and Disclosure of Funding
We would like to thank our NeurIPS reviewers for their valuable feedback on this work. Roberta and Max were supported by the DARPA Machine Commonsense program.

Review summaries:
This paper presents a method that utilizes data augmentation for image-based reinforcement learning. The data augmentation is used to regularize the policy and function approximation in the proposed method. In addition, a method for automatically identifying effective ways of data augmentation is proposed. The experimental results show that the proposed method outperforms the baseline methods.

This paper tackles the problem of generalization in deep RL via data augmentation. It provides a framework for automatic data augmentation based on UCB, RL^2, or MAML. When UCB is combined with regularization of the policy and value function so that their outputs are invariant to transformations (such as rotation, crop, etc.), it shows improvements over similar algorithms on the ProcGen benchmark. 

This paper proposes an automatic data augmentation approach for RL tasks. Specifically, it takes UCB for data selection and introduces two regularization terms for actor-critic algorithms' policy and value function. Then this paper evaluated the approach based on the Procgen benchmark and demonstrated that it outperforms existing methods. It is also shown that the learned policies and representations are robust to irrelevant factors.

This paper presents a method for improving generalization in reinforcement learning using data augmentation. It identifies a key theoretical limitation of previous work in the naive application of data augmentation to actor critic methods and proposes a solution that avoids biased estimation of the policy gradient objective while still allowing for regularization of the policy and value function. The resulting loss is paired with three distinct approaches for identifying an optimal data augmentation strategy. The best of these approaches, a bandit algorithm, obtains SOTA performance (relative to published works) on the Procgen environment.  

The paper proposes a framework for automatic data augmentation in deep RL. It proposes three algorithms based on 1) UCB 2) RL2 3) meta-learning, combining PPO and regularization of both the actor and critic to make sure that the policy and value function are invariant to the transformation corresponding to the augmentation. Experiments on ProcGen and the DMC with distractors show that the UCB-based algorithm (UCB-DrAC) outperforms vanilla deep RL and previous data augmentation baselines and is competitive with the best augmentation type chosen post hoc.

Summary: Reinforcement learning has been shown to overfit to training environments. Some recent works (laskin et al, kostrikov et al) have shown data-augmentation to be an effective technique in curbing the overfitting issue. However, different games have different biases and hence require different data augmentation. This paper proposes to use UCB algorithm to automatically select a good data augmentation (from a list of data augmentations) for a game. However, naively applying data augmentation to RL algorithms like PPO isn’t theoretically sound. To address this problem, the paper introduces novel policy and value regularization. Overall, the paper contains extensive experiments and ablation studies.