Year: 2020

Abstract:
Reinforcement learning (RL) encompasses both online and offline regimes. Unlike its online counterpart, offline RL agents are trained using logged-data only, without interaction with the environment. Therefore, offline RL is a promising direction for real-world applications, such as healthcare, where repeated interaction with environments is prohibitive. However, since offline RL losses often involve evaluating state-action pairs not well-covered by training data, they can suffer due to the errors introduced when the function approximator attempts to extrapolate those pairs’ value. These errors can be compounded by bootstrapping when the function approximator overestimates, leading the value function to grow unbounded, thereby crippling learning. In this paper, we introduce a three-part solution to combat extrapolation errors: (i) behavior value estimation, (ii) ranking regularization, and (iii) reparametrization of the value function. We provide ample empirical evidence on the effectiveness of our method, showing state of the art performance on the RL Unplugged (RLU) ATARI dataset. Furthermore, we introduce new datasets for bsuite as well as partially observable DeepMind Lab environments, on which our method outperforms state of the art offline RL algorithms.

heading: 1 INTRODUCTION
text: Agents are, fundamentally, entities which map observations to actions and can be trained with reinforcement learning (RL) in either an online or offline fashion. When trained online, an agent learns through trial and error by interacting with its environment. Online RL has had considerable success recently: on Atari (Mnih et al., 2015), the game of GO (Silver et al., 2017), video games like StarCraft II, and Dota 2, (Vinyals et al., 2019; Berner et al., 2019), and robotics (Andrychowicz et al., 2020). However, the requirement of extensive environmental interaction combined with a need for exploratory behavior makes these algorithms unsuitable and potentially unsafe for many real world applications. In contrast, in the offline setting (Fu et al., 2020; Fujimoto et al., 2018; Gulcehre et al., 2020; Levine et al., 2020), also known as batch RL (Ernst et al., 2005; Lange et al., 2012), agents learn from a fixed dataset which is assumed to have been logged by other (possibly unknown) agents. See also Fig. 1 for an illustration of these two settings. Learning purely from logged data allows these algorithms to be more widely applicable, including in problems such as healthcare and self-driving cars, where repeated interaction with the environment is costly and potentially unsafe or unethical, and where logged historical data is abundant. However these algorithms tend to behave considerably worse than their online counterpart.
Although similar in principle, there are some important differences between the two regimes. While it is useful for online agents to explore unknown regions of the state space so as to gain knowledge about the environment and better their chances of finding a good policy (Schmidhuber, 1991), this is not the case for the offline setting. Choosing actions not well-represented in the dataset for
offline methods would force the agent to rely on function approximators’ extrapolation ability. This can lead to substantial errors during training, as well as during deployment of the agent. During training, the extrapolation errors are exacerbated by bootstrapping and the use of max operators (e.g. in Q-learning) where evaluating the loss entails taking the maximum over noisy and possibly overestimated values of the different possible actions. This can result in a propagation of the erroneous values, leading to extreme over-estimation of the value function and potentially unbounded error; see (Fujimoto et al., 2019b) and our remark in Appendix A. As we empirically show in Section 4.2, extrapolation errors are a different source of overestimation compared to those considered by standard methods such as Double DQN (Hasselt, 2010), and hence cannot be addressed by those approaches. In addition to extrapolation errors during training, a further degradation in performance can result from the use of greedy policies at test time which maximize over value estimates extrapolated to under-represented actions. We propose a coherent set of techniques that work well together to combat extrapolation error and overestimation:
Behavior value estimation. First, we address extrapolation errors during training time. Instead of Qπ ∗ , we estimate the value of the behavioral policy QπB , thereby avoid the max-operator during training. To improve upon the behavioral policy, we conduct what amounts to a single step of policy improvement by employing a greedy policy at test time. Surprisingly, this technique with only one round of improvement allows us to perform significantly better than the behavioral policies and often outperform existing offline RL algorithms.
Ranking regularization. We introduce a max-margin based regularizer that encourages the value function, represented as a deep neural network, to rank actions present in the observed rewarding episodes higher than any other actions. Intuitively, this regularizer pushes down the value of all unobserved state-action pairs, thereby minimizing the chance of a greedy policy selecting actions under-represented in the dataset. Employing the regularizer during training will minimize the impact of the max-operator used by the greedy policy at test time, i.e. this approach addresses extrapolation errors both at training and (indirectly) at test time.
Reparametrization of Q-values. While behavior value estimation typically performs well, particularly when combined with ranking regularization, it only allows for one iteration of policy improvement. When more data is available, and hence we can trust our function approximator to capture more of the structure of the state space and as a result generalize better, we can rely on Q-learning which permits multiple policy improvement iterations. However this exacerbates the overestimation issue. We propose, in addition to the ranking loss, a simple reparametrization of the value function to disentangle the scale from the relative ranks of the actions. This reparametrization allows us to introduce a regularization term on the scale of the value function alone, which reduces over-estimation.
To evaluate our proposed method, we introduce new datasets based on bsuite environments (Osband et al., 2019), as well as the partially observable DeepMind Lab environments (Beattie et al., 2016). We further evaluate our method as well as baselines on the RL Unplugged (RLU) Atari dataset (Gulcehre et al., 2020). We achieve a new state of the art (SOTA) performance on the RLU Atari dataset as well as outperform existing SOTA offline RL methods on our newly introduced datasets. Last but not least, we provide careful ablations and analyses that provide insights into our proposed method as well as other existing offline RL algorithms.
Related work. Early examples of offline/batch RL include least-squares temporal difference methods (Bradtke & Barto, 1996; Lagoudakis & Parr, 2003) and fitted Q iteration (Ernst et al., 2005; Riedmiller, 2005). Recently, Agarwal et al. (2019a), Fujimoto et al. (2019b), Kumar et al. (2019), Siegel et al. (2020) , Wang et al. (2020) and Ghasemipour et al. (2020) have proposed offline-RL algorithms and shown that they outperform off-the-shelf off-policy RL methods. There also exist methods explicitly addressing the issues stemming from extrapolation error (Fujimoto et al., 2019b).

heading: 2 BACKGROUND AND PROBLEM STATEMENT
text: We consider, in this work, Markov Decision Processes (MDPs) defined by (S,A, P,R, ρ0, γ) where S is the set of all possible states and A all possible actions. An agent starts in some state s0 ∼ ρ0(·) where ρ0(·) is a distribution over S and takes actions according to its policy a ∼ π(·|s), a ∈ A, when in state s. Then it observes a new state s′ and reward r according to the transition distribution P (s′|s, a) and reward function r(s, a). The state action value function Qπ describes the expected
discounted return starting from state s and action a and following π afterwards:
Qπ(s, a) = E [∑ t=0 γtr(st, at) ] , s0 = s, a0 = a, st ∼ P (·|st−1, at−1), at ∼ π(·|st), (1)
and V π(s) = Ea∼π(·|s)Qπ(s, a) is the state value function. The optimal policy π∗, which we aim to discover through RL, is one that maximizes the expected cumulative discounted rewards, or expected returns such that Qπ ∗ (s, a) ≥ Qπ(s, a) ∀s, a, π. For notational simplicity, we denote the policy used to generate an offline dataset as πB1. In the same vein, for a state s in an offline dataset, we write GB(s) to denote an empirical estimate of V πB(s), computed by summing future discounted rewards over the trajectory that s is part of.
Approaches to RL can be broadly categorized as either on-policy or off-policy algorithms. Whereas on-policy algorithms update their current policy based on data generated by that same policy, offpolicy approaches can take advantage of data generated by other policies. Algorithms in the mold of fitted Q-iteration make up many of the most popular approaches to deep off-policy RL (Mnih et al., 2015; Lillicrap et al., 2015; Haarnoja et al., 2018). This class of algorithms learns a Q function by minimizing the Temporal Difference (TD) error. To increase stability and sample efficiency, the use of experience replay is also typically employed. For example, DQN (Mnih et al., 2015) minimizes the following loss function:
Lθ′(θ) = E(s,a,r,s′)∼D ( Qθ(s, a)− ( r + γmax
a′ Qθ′(s
′, a′) ))2 , (2)
where D represents experience replay, i.e. a dataset generated by some behavior policy. Typically, for off-policy algorithms the behavior policy is periodically updated to remain close to the policy being optimized. A deterministic policy can be derived by being greedy with respect to Q̂, i.e. by defining π(s) = arg maxaQ(s, a). In cases where maximization is nontrivial (e.g. continuous action spaces), we typically adopt a separate policy π and optimize losses similar to: Lθ′(θ) = E(s,a,r,s′)∼D ( Qθ(s, a)− ( r+ γEa′∼π(·|s′)[Qθ′(s′, a′)] ))2 . In this case, π is optimized separately in
order to maximize Ea∼π(·|s)[Q(s, a)], sometimes subject to other constraints (Lillicrap et al., 2015; Haarnoja et al., 2018). Various extensions have been proposed for this class of algorithms, including but not limited to: distributional critics (Bellemare et al., 2017), prioritized replays (Schaul et al., 2015), and n-step returns (Kapturowski et al., 2019; Barth-Maron et al., 2018; Hessel et al., 2017).
In the offline RL setting (see Figure 1, right), agents learn from fixed datasets generated via other processes, thus rendering off-policy RL algorithms particularly pertinent. Many existing offline RL algorithms adopt variants of Equation (2) to learn value functions; e.g. Agarwal et al. (2019b). Offline RL, however, is different from off-policy learning in the online setting. The dataset used is finite and fixed, and does not track the policy being learned. When a policy moves towards a part of the state space not covered by the behavior policy(s), for example, one cannot effectively learn the value function. We will explore this in more detail in the next subsection.

heading: 2.1 EXTRAPOLATION AND OVERESTIMATION IN OFFLINE RL
text: In the offline setting, when considering all possible actions for a next state in Equation (2), some of the actions will be out-of-distribution (OOD), i.e. these actions were never picked in that particular state by the behavior policy used to construct the training set (hence not present in the data). In such
1Our proposed approach does not depend on πB being a coherent policy.
circumstances, we have to rely on the current Q-network’s ability to extrapolate beyond the training data, resulting in extrapolation errors when evaluating the loss. Moreover, the need for extrapolation can lead to value overestimation, as explained below.
Value overestimation (see Fig. 2) happens when the function approximator predicts a larger value than the ground truth. In short, taking the max over actions of several Q-network predictions, as in Equation (2), leads to overconfident estimates of the true value of the state. We will expand on this point shortly. Before doing so, it is worth pointing out that this phenomenon of overestimation was well-studied in the online setting (Van Hasselt et al., 2015; 2018) and some prior works sought to address this problem (Van Hasselt et al., 2015; Fujimoto et al., 2018). However, in offline RL overestimation manifests itself in more problematic ways, which cannot be addressed by the solutions proposed in online RL (Kumar et al., 2019). To see this, let us consider Equation (2) again. The max operator is used to evaluate Qθ′ for all actions in a given state, including actions absent in the dataset (OOD actions). For OOD actions, we depend on extrapolated values provided by Q̂θ′ . While being an extremely powerful family of models, neural networks will produce erroneous predictions on unobserved state-action pairs, and sometimes, these will be artificially high. These errors will be propagated in the value of other states via bootstrapping. Due to the smoothness of neural networks, by increasing the value of actions in the OOD action-state’s neighborhood, the overestimated value itself might increase, creating a vicious loop. Mainly we remark that, in such a scenario, typical gradient descent optimization can diverge and escape towards infinity. See Appendix A for a formal statement, and proof on this statement, though similar observations had been made before by Fujimoto et al. (2019b) and Achiam et al. (2019). In the online setting, when the agent overestimates some state-action pairs, they will be chosen more often due to optimistic estimates of values, even in the off-policy setting where the behavior policy trails the learned one. The online agent would then act, collect data, thereby correcting extrapolation errors. This form of self-correction is absent in the offline setting, and due to the overestimation from extrapolation, this absence can be catastrophic.

heading: 3 SOLUTIONS TO ADDRESS EXTRAPOLATION ERROR
text: We build towards a solution to the extrapolation errors by i) using behavior value estimation to reduce training time extrapolation error, ii) ranking regularization of the Q-networks to better handle test time extrapolation error, iii) reparameterizing the Q-function to prevent divergence of these predictions to infinity.

heading: 3.1 BEHAVIOR VALUE ESTIMATION
text: One potential answer to the overestimation problem is to remove the max-operator in the policy evaluation step by optimizing the alternative loss:
Lθ′(θ) = E(s,a,r,s′,a′)∼D ( Qθ(s, a)− ( r + γQθ′(s ′, a′) ))2 . (3)
This update rule relies on transitions (s, a, r, s′, a′) collected by the behavior policy πβ and resembles the policy evaluation step of SARSA (Rummery & Niranjan, 1994; Van Seijen et al., 2009). Since the update contains no max-operator, and Qθ are evaluated only on state-action pairs that are part of the dataset, the learning process is not affected by overestimation. However, the removal of the max-operator means the update simply tries to evaluate the value of the behavioral policy. The astute reader may question our ability to improve upon the behavioral policy when using this update rule. We note, that when acting using the greedy policy π(s) = arg maxaQθ(s, a) we are in fact performing a single policy improvement step. Fortunately, this one step is typically sufficient for dramatic gains as we show in our experiments (see for example Fig. 9). This finding matches our understanding that policy iteration algorithms typically do not require more than a few steps to converge to the optimal policy (Lagoudakis & Parr, 2003; Sutton & Barto, 2018, Chapter 4.3).

heading: 3.2 RANKING REGULARIZATION
text: Policy evaluation with Eq. (3) effectively reduces overestimation during training. But it also avoids learning the Q values of OOD actions. Due to the lack of learning, these values are likely erroneous, and many will err on the side of overestimation, thus harming the greedy policy. This is in contrast with the tabular case, where all OOD actions will have a default value of 0.
To robustify the policy improvement step, a natural choice is to regularize the function approximator such that it behaves more predictable on unseen inputs. Forcing the neural network to output 0 for OOD actions might require very non-smooth behavior of the network—hence we choose a less harsh regularizer that asks the model only to assign lower values to state-action pairs that have not been observed during learning. We formulate this as a ranking loss which follows a typical hinge-loss approximation (Chen et al., 2009; Burges et al., 2005) for ranking problems. Given a transition from the dataset (st, at) this can be formulated as
C(θ) = |A|∑
i=0,i6=t
max (Qθ(st, ai)−Qθ(st, at) + ν, 0)2 . (4)
While equation (4) does, in expectation, encourage lower ranks for OOD action, it can also have the adverse effect of promoting suboptimal behavior that is frequent in the dataset. This is because for any transition, proportional to its frequency in the dataset, the regularizer pushes the value of all but the selected action down, promoting a policy that picks the selected action regardless of its value. To minimize this effect, we weigh the regularization based on the value of the trajectory:
C(θ) = exp (( GB(s)− Es∼D[GB(s)] ) /β ) |A|∑ i=0,i6=t max (Qθ(s, ai)−Qθ(s, at) + ν, 0)2 , (5)
where Es∼D[GB(s)] is estimated by average over GB(s) in mini-batches. In all our experiments, we fix ν to be 5e − 2 and β to be 2. The new formulation of the loss ensures that particularly on trajectories performed well in the dataset, trajectories that are likely for policy learned using behavior evaluation, the OOD action rank lower than observed actions. We note that our rank loss, when viewed through the lens of on-policy online RL, can be related to ranking policy gradients (Lin & Zhou, 2020) or to (Su et al., 2020; Pohlen et al., 2018) who also used a hinge loss as a regularizer but with different goals from ours.

heading: 3.3 REPARAMETRIZATION OF Q-VALUES
text: The overestimation of state-action values can be severe in offline RL, and can escape towards infinity (see for example appendix A). While behavior value estimation can be an effective way for suppressing this overestimation, when one iteration of policy improvement is insufficient, one may want to bring back the max-operator and therefore the implicit policy improvement step of Q-learning. To better handle this scenario, we introduce a complimentary method to prevent severe over-estimation by bounding the values predicted by the critic via reparameterization. Specifically, we reparameterize the critic as Qθ(s, a) = αQ̂θ(s, a) given a state- and action-independent scale parameter α. This, in effect, disentangles the scale from the relative magnitude of values predicted, but also enables us to impose constraints on the scale parameter. To further stabilize the learning and reduce the variance of the estimations, we update α by stochastic gradient descent, but with larger minibatches and a smaller learning rate.
In our formulation, the “standardized” value Q̂θ(s, a) ∈ [−1, 1] is attained by using a tanh activation function. Note that the tanh activation has the side effect of reducing numerical resolution for representing extreme values (as the tanh will be in its saturated regime), minimizing the ability of the learning process to keep growing these values by bootstrapping on each other. We let α = exp(ρ) such that α > 0. Our parameterization thus ensures that Q-values are always bounded in absolute value by α, i.e. n Q(s, a) ∈ [−α, α]. The equations below show how critic scaling can be adapted into the Q-learning objective:
Lθ′,α′(θ, α) = E(s,a,r,s′)∼D ( αQ̂θ(s, a)− ( r + γα′max
a′ Q̂θ′(s
′, a′) ))2 . (6)
The introduction of α allows us to conveniently regularize the scale of Q values without disturbing the ranking between actions. More precisely, we introduce a regularization term on α
C(α) = E[softplus(αQ̂θ(s, a)−GB(s))2], (7)
where C(α) represents a soft-constraint requiring Q values to stay close to the performance of the behavioral policy, and thereby prevent gross overestimation. In Eq. (7), we rely on the softplus function to constrain α only when Qθ(s, a) > GB(s).

heading: 4 EXPERIMENTS
text: We investigate the performance of discrete offline RL algorithms on the three aforementioned opensource domains: Atari, DeepMind Lab, and bsuite. A question we are particularly interested in answering is: how does the lack of coverage of the state-action pairs affect the performance of each algorithm? In that context, we study each algorithms’ robustness to dataset size (see Fig. 6), noise (see Fig. 3 and 7), and reward distribution (Fig. 9 in Appendix), as they all affect the datasets’ coverage of the state and action space.
Because we explore various ablations of our proposed approach, discussed in Section 3, we used a specific acronym for each potential combination. According to our naming convention, Q is for Q-learning and B is for behavior value estimation as the underlying RL loss, R indicates the use of the ranking regularization and r the use of reparametrization. In that vein, QRr refers to Q-learning with ranking regularization and reparametrization and BR stands for behavior value estimation with ranking regularization (see Appendix B.1.) We note that, both our DQN and R2D2 experiments used Double Q-learning (Van Hasselt et al., 2015), but for our approach (and ablations of it) that rely on Q-learning, we used the vanilla Q-learning algorithm. More details for each experimental setup appear in Appendix D. We also provide more analysis and additional results in Appendix B.
We used an open-source Atari offline RL dataset, which is a part of RL Unplugged (Gulcehre et al., 2020) benchmark suite. We have created two new offline RL datasets for bsuite and DeepMind Lab, which we are going to opensource. The details of those datasets are provided in Appendix C.
4.1 BSUITE EXPERIMENTS
bsuite (Osband et al., 2019) is a proposed benchmark designed to highlight key aspects of agent scalability such as exploration, memory, credit assignment, etc. We have generated low-coverage offline RL datasets for catch and cartpole as described by Agarwal et al. (2019a) (see Appendix C.1 for details).
In Fig. 3, we compare the performance of BRr and QRr with four baselines: DDQN (Hasselt, 2010), CQL (Kumar et al., 2020), REM (Agarwal et al., 2019a) and BCQ (Fujimoto et al., 2018). We consider two tasks, each in five versions defined by the amount of injected noise. The noise is injected into transitions by replacing the actions from an agent with a random action with probability .
On the harder dataset (cartpole), BRr, the proposed method, outperforms all other approaches showing the efficiency of our approach and its robustness to noise. Two other methods, QRr (proposed by us as an ablation to BRr) and CQL, also perform relatively well. The results for catch are similar, with the exception that BCQ also improves performance which re-emphasises the importance of restricting behavior to stay close to the observed data. We have additional results on mountain car, where most algorithms behave well except DDQN (see Appendix D.4).

heading: 4.2 ATARI EXPERIMENTS
text: Atari is an established online RL benchmark (Bellemare et al., 2013), which has recently attracted the attention of the offline RL community (Agarwal et al., 2019a; Fujimoto et al., 2019a) arguably because the diversity of games presents a challenge for offline RL methods. Here, we used the experimental protocol and datasets from the RL Unplugged Atari benchmark (Gulcehre et al., 2020). We report the median normalized score across the Atari games, and the error bars show a bootstrapped estimate of the [25, 75] percentile interval for the median estimate computed across different games.
In Fig. 4, we show that QRr outperforms all baselines reported in the RL Unplugged benchmark as well as CQL (Kumar et al., 2020). While BRr performs well, this experiment highlights the potential limitation of doing a single policy improvement iteration in rich data regimes. Because in the considered setting there is enough data for the neural networks to learn reasonable approximations of the Q-value (exploiting the structure of the state space to extrapolate for unobserved state-action pairs), one can gain more by reverting to Q-learning in order to do multiple policy improvement steps. However this amplifies the role of the regularization and in particular the reparametrization. Therefore, in this setting, QRr, which we proposed as an ablation to BRr outperforms other techniques. Fig. 4 also shows the robustness of QRr’s hyperparameters to different tasks.
Ablation Experiments on Atari We ablate three different aspects of our algorithm on online policy selection games: i) the choice of TD backup updates (Q-learning or behavior value estimation), ii) the effect of ranking regularization, iii) the reparameterization on the critic. We show the ablation of those three components in Fig. 5. We observed the largest improvement when using ranking regularization. In general, we found that estimating the Monte-Carlo returns directly from the value function (we refer this in our plot as ”MC Learning”) does not work on Atari. However, behavior value estimation and Q-learning both have similar performance on the full dataset, however in low data regimes, the behavior value policy considerably outperforms Q-learning (see Fig. 9 in Appendix B).
Overestimation Experiments Q-learning can over-estimate due to the maximization bias, which happens due to the max-operator in the backups (Hasselt, 2010). In the offline setting another source of overestimation, as discussed in Section 2, are OOD actions due to the dataset’s limited coverage. Double DQN (DDQN by Hasselt (2010)) is supposed to address the first problem, but it is unclear whether it can address the second. In Fig. 6, we show that in the offline setting DDQN still over-estimates severely when we evaluate the critic’s predictions in the environment. We believe this is because the second factor is the main reason of overestimation, which is not explicitly addressed by DDQN. However, Qr (vanilla Q-learning with reparametrization) and B are not effected from the
reduced dataset size and coverage as much. In the figure, we compute the over-estimation error as 1100 ∑100 i=0(max(Q
π(s, a) − Gπ(s), 0))2 over 100 episodes, where Gπ(s) corresponds to the discounted sum of rewards from state s till the end of episode by following the policy π.
Robustness Experiments In Appendix B.3 (see Figure 9), we investigate the robustness of B and DDQN with respect to the reward distribution and dataset sizes. We found that the performance of B is more robust than DDQN to the variations on the reward distribution and the dataset size.
BC R2D2 CQL B BR0.0
2.5
5.0
7.5
10.0
12.5
15.0
17.5
20.0
2.9
8.5 9.3
7.6
13.4
explore_object_rewards_many
BC R2D2 CQL B BR0
5
10
15
20
25
30
1.8
19.8
23.8 23.7
28.6 explore_object_rewards_few
BC R2D2 CQL B BR0
2
4
6
8
10
12
14
0.1
2.6
4.0
9.9
11.2
rooms_watermaze
BC R2D2 CQL B BR0
2
4
6
8
10
12
14
1.1
5.4
3.4
9.4 10.4
rooms_select_nonmatching_object
Models
Ep iso
de R
et ur
n
Figure 7: DeepMind Lab Results: We compare the performance of different baselines on challenging DeepMind Lab datasets coming from four different DeepMind Lab levels. Our method, BR, consistently performs the best.

heading: 4.3 DEEPMIND LAB EXPERIMENTS
text: Offline RL research mainly focused on fully observable environments such as Atari. However, in a complex partially observable environment such as Deepmind Lab, it is very difficult to obtain good coverage in the dataset even after collecting billions of transitions. To highlight this, we have generated datasets by training an online R2D2 agent on DeepMind Lab levels. Specifically, we have generated datasets for four of the levels: explore object rewards many, explore object rewards few, rooms watermaze, and rooms select nonmatching object. The details of the datasets are provided in the Appendix C.2.
We compare offline R2D2, CQL, BC, B and BR on our DeepMind Lab datasets. In contrast to Atari, BR performed better than QR according to our preliminary results. Thus, here, we decided to only focus on BR. We use the same network architecture and hence, the models vary only is the loss function. We want to compare our baselines’ performance on our Deepmind Lab datasets when there is a large amount of data stored during online training with online R2D2. In Figure 7, we show the performance of each algorithm on different levels. Our proposed modifications, BR and B outperform other offline RL approaches on all DeepMind Lab levels. We argue that poor performance of R2D2 in the offline setting is due to the low coverage of the dataset. Despite having on the order 300M transitions, since the environment is partially observable and diverse, it is still not enough to cover enough of all possible state-action pairs. We present further results about dataset coverage on Deepmind Lab seekavoid arena 01 level with dataset generated by a fixed policy in Appendix B.2 where we showed that BR is more robust to the dataset coverage than other offline RL methods.

heading: 5 DISCUSSION
text: In this work, we first highlight how, in the offline deep RL setting, overestimation errors may cause Q-learning to diverge, with weights and Q-value escaping towards infinity. We discuss using behavior value estimation to address this problem, which efficiently regresses to the Q-value of the behavior policy and then takes a policy improvement step at test time by acting greedily with respect to the learnt Q-value. The behavior value estimation oversteps the overestimation issue by avoiding the max-operator during training. We note that a single policy improvement step seems sufficient, especially in the low data regime, to improve over the behavior policy and the policy discovered by double DQN. However, the max-operator used to construct the test time policy re-introduces overestimation errors that were avoided during training. We can address this issue by regularizing the function approximator with a ranking loss that encourages OOD actions to rank lower than the observed actions. This reduces overestimation at test time and improves performance. Nevertheless, we observe that behavior value estimation can be too conservative in rich data settings. In such scenarios, the function approximator can exploit more of the state and action space’s underlying structure, leading to more reliable extrapolation. Therefore, it can be more lucrative to rely on Q-learning in such scenarios, which can do multiple policy improvement steps, further constraining the function approximator. The resulting algorithm QRr, that is Q-learning with the ranking loss and reparametrization, outperforms all other approaches on the RL Unplugged Atari benchmark.
Overall behavior value estimation coupled with the ranking loss, is an effective algorithm for low data regimes. For larger data regimes, where the coverage is better, it is possible to achieve better performance by switching to Q-learning and using reparametrization. The proposed methods outperform existing offline RL approaches on the considered benchmarks. As future work, we plan to extend our observations to the continuous control setup and towards more real-world applications.

heading: A Q-LEARNING CAN ESCAPE TO INFINITY IN THE OFFLINE CASE
text: Remark 1. Q-learning, using neural networks as a function approximator, can diverge in the offline RL setting given that the collected dataset does not include all possible state-actions pairs, even if it contains all transitions along optimal paths. Furthermore, the parameters (and hence the Q-values themselves) can espace towards infinity under gradient descent dynamics.
Proof. The proof relies on providing a particular instance where Q-learning diverges towards infinity. This is sufficient to show that divergence can happen. Note that the remark does not make any statement of how likely is for this to happen, nor is providing sufficient conditions under which such divergence has to happen.
Let us consider a simple deterministic MDP depicted in the figure below (left).
u3u2 h2 h3
1 -1
a2, r =0 a1, r =0 s2
s1 s3
s4
a0, r= 1
a 2, r=0
S a[0] a[1] a[2]
1
w u1
Depiction of the MDP
-2-2-2
Depiction of the MLP
h1
1
h4 a2, r=0
a0 or a1, r=0 a0 or a1, r=0
S = {s1, s2, s3, s4} is the set of all states, where S1 is deterministically the starting state and S4 is the terminal state of the MDP. Let A = {a0, a1, a2} be the set of all possible actions. Let the reward function r(s, a) be 0 for all action-state pair except r(s1, a0) which is 1. Let the transition probabilities P (s′|s, a) be deterministic as defined by the depicted arrows. I.e. for any state action pair only transitioning to one state has probability 1, while the rest has probability 0. For example, only P (s4|s1, a0) = 1, while P (s3|s1, a0) = 0, P (s2|s1, a0) = 0.P (s2|s1, a0) = 0. For s1, a1 only P (s2|s1, a1) = 1 and so on and so forth. First observation is that the optimal behavior is to pick action a0 (as it is the only rewarding transition in the entire MDP).
The features describing each state are given by a single real number, where s1 = 0, s2 = 1, s3 = β, with β > 1γ > 0, where γ is the discount factor. Assume actions are provided to the neural network as one-hot vectors, i.e. a0 = [0, 0, 1]T , a1 = [0, 1, 0]T , a2 = [1, 0, 0]T 2, where we will refer to a[i] as the i-th element of the vector that represents the action a. For example a0[2] = 1 and a0[0] = 0.
Let us consider the Q-function parametrized as a simple MLP (depicted in the figure above left). The MLP uses rectifier activations, and gets as input both the state and action, returning a single scalar value which is the Q-value for that particular state action combination. Rewriting the diagram in analytical form we have that for s ∈ R and a ∈ R3:
Qθ(s, a) = w · relu(s) + u1relu(a[0]− 2s) + u2relu(a[1]− 2s) + u3relu(−2s− a[2]) (8)
A note on initialization. The weights of the first layer are given as constants. The process would work if we leave them to be learnable as well, but the analysis would become considerably harder. The exact value used, −2, 1,−1, are not important. In principle we care for the negative weights connecting s to h2, h3, h4 be larger in magnitude than those from a[i] to hi, and we care for the weight between a[2] and h2 to be negative. They can be scaled arbitrarily small and do not need to be identical.
2one-hot representation is the typical representation for action in discrete spaces
What we will rely in the rest of the analysis is that the preactivation of h2, h3, h4 to be negative for state s2 and s3. This will be in the zero region of the rectifier, meaning no gradient will flow through those units. Since s3 > s2 ≥ 1 and a[i] ∈ {0, 1}, it is sufficient for the weight from s to h2, h3, h4 to be larger in magnitude than the weight from a[i] to h2, h3, h4. This ensures that for s > 1, the Q-function is not a function of ui as ui will get multiplied by 0.3 Also we want the function to never depend on u3 to simplify our analysis, which is easily achievable if the weight going from a[2] to h4 is negative.
Given the observations above, if we plug in the formula the different values of si and ai we get that:
Qθ(s1, a0) = u1 Qθ(s, 1, a1) = u2 Qθ(s1, a2) = 0
∀a ∈ A, Qθ(s2, a) = w ∀a ∈ A, Qθ(s3, a) = βw
(9)
Note that this implies that maxaQθ(s2, a) = w maxaQθ(s3, a) = βw
(10)
Assume w > 0. And let the dataset collected by the behavior policy to contain the following 3 transitions:
D = {(s1, a0, 1, s4), (s1, a1, 0, s2), (s2, a2, 0, s3)}
We can now construct the Q-learning loss that we will use to learn the function Q in the offline case which will be
L = ∑
(s,a,r,s′)∈D (Qθ(s, a)− r − γmaxaQ′θ(s′, a)) 2
= (Qθ(s1, s0)− 1)2 + (Qθ(s1, a1)− γmaxaQ′θ(s2, a))2 + (Qθ(s2, a2)− γmaxaQ′θ(s3, a))2 = (u1 − 1)2 + (u2 − γw′)2 + (w − γβw′)2
(11)
Note that we relied on Eq. (10) to evaluate the max operator and θ′ is a copy of θ, that is used for bootstrapping. This is the standard definition of Q-learning see Eq. (2). In particular in this toy example θ′ is numerically always identical to θ (in general it can be a trailing copy of θ from k steps back) and is used more to indicate that when we take a derivative of the loss with respect to θ we do not differentiate through Q′θ. From Eq. (11) we notice that only the first transition in dataset contributes to the gradient of u1, only the second transition contributes to the gradient of u2 and only the third transition contributes to the gradient of w. We can not evaluate the gradient with respect to θ of the loss L over the entire dataset:
∇u1 = u1 − 1 ∇u2 = u2 − (0 + γw) ∇u3 = w − (0 + γβw) = (1− γβ)w ∇w = w − (0 + γβw) = (1− γβ)w
(12)
Note that we assumed w > 0 and for simplicity we exploited that w′ = w numerically, to be able to better understand the dynamics of the update. Given that β > 1γ ,∇w will always be negative as long as w (and implicitly w′) stays positive. Given that wt = wt−1 − α∇w for some learning rate α > 0, the update creates a vicious loop that will increase the norm of w at every iterations, such that limt→∞ wt =∞. Given that the gradient on u2 tracks w, it means that the path that takes action a2 in the initial state s1 will have +∞ as value. Note that all transitions along the optimal path of this deterministic MDP are part of the dataset.
3The fact that no gradient gets propagated in the first layer is only important if we attempt to consider the case when the first layer weights are learnable.
Also that given our example, the same will happen if we rely on SGD rather than batch GD (as the different examples affect different parameters of the model independently and there is no effect from averaging). Preconditioning the updates (as for e.g. is done by Adam or rmsprop) will also not change the result as they will not affect the sign of the gradient (the preconditioning matrix needs to be positive definite). Neither momentum will not affect the divergence of learning, as it will not affect the sign of the update.
This means that the provided MDP will diverge towards infinity under the updates on most commonly used gradient based algorithms.

heading: B ADDITIONAL RESULTS AND ABLATIONS

heading: B.1 ACRONYMS
text: In Table 1, we provided the acronyms for our models and their corresponding meanings.

heading: B.2 DEEPMIND LAB: THE EFFECT OF COVERAGE ON OFFLINE LEARNING
text: As mentioned in Section 4.3 we investigate the effect of coverage on the DeepMind Lab seekavoid arena 01 level. To do so, we have created another set of datasets which is generated by using a fixed R2D2 snapshot with different noise levels when evaluating the trained snapshot in the environment for seekavoid arena 01 level. We have used different s in the -greedy algorithm to create datasets with different noise levels. The also effects the coverage of the dataset.
We compare R2D2, CQL, BC, B and BR on these DeepMind Lab datasets by using the same network architecture—the only change among the models is the loss function.
We investigate the effect of coverage in the DeepMind Lab seekavoid arena 01 level, by evaluating the policy with different ’s for the epsilon-greedy in the environment and storing each episode in the dataset. Increasing the will increase the coverage of the dataset but also it will increase the noise in the dataset as well. In Figure 8, we show the effect on the simple DeepMind Lab level. When = 0, BC works outperforms offline RL approaches, however increasing the level of noise deteriorates the performance of BC, and BR starts to performs better. Since the environment is deterministic, if the policy is deterministic as well, this corresponds to only having one single unique episode in the dataset. As we increase the epsilon the coverage in the dataset and diversity of the trajectories will increase as well. We trained all models by unrolling on the whole episode and trained using back-propagation through time.

heading: B.3 ATARI: ROBUSTNESS TO DATA
text: The robustness of the reward distribution in the dataset is an important feature required to deploy offline RL algorithms in the real-world. We would like to understand the robustness of behavior value estimation in the offline RL setting. Thus, we first investigate the robustness of B in contrast to Q-learning with respect to the datasets’ size and the reward distribution. In Fig. 9, we split out the dataset into two smaller datasets: i) transitions coming from only highly rewarding ii) transitions from only poorly performing episodes. We show that B outperforms Q-learning in both settings.

heading: B.4 ON THE EFFECT OF REGULARIZATION
text: In this Section we study the effect of the regularization on the action gap and the overestimation error. In Figure 10, we show that increasing the regularization co-efficient for the ranking regularization increases the action gap across the Atari online policy selection games which can result to lower estimation error and better optimization.
In Figure 11, we show the effect of increasing the regularization on the overestimation of the Qnetwork when evaluated in the environment. We show the mean over-estimation across the games.

heading: B.5 ONLINE POLICY SELECTION GAMES RESULTS
text: In Figure 12, we show the performance of different models with respect to the rewards they achieve over the training.

heading: Action Gap

heading: Returns

heading: B.6 OVERESTIMATION ON ONLINE POLICY SELECTION GAMES
text: In Figure 13 and 14, we report the value error of B, BRr and DQN’s value error and squared value error respectively.

heading: Value Error
text: Squared Value Error

heading: C DETAILS OF DATASETS

heading: C.1 BSUITE DATASET
text: BSuite (Osband et al., 2019) data was collected by training DQN agents (Mnih et al., 2015) with the default setting in Acme (Hoffman et al., 2020) from scratch in each of the three tasks: cartpole, catch, and mountain car. We convert the originally deterministic environments into stochastic ones by randomly replacing the agent action with a uniformly sampled action with a probability of ∈ {0, 0.1, 0.2, 0.3, 0.4, 0.5} (ie. = 0 corresponds to the original environment). We train agents (separately for each randomness level and 5 seeds, i.e. 25 agents per game) for 1000, 2000, 500 episodes in cartpole, catch and mountain car respectively. The number of episodes is chosen so that agents in all levels can reach their best performance. We record all the experience generated through the training process. Then to reduce the coverage of the datasets and make them more challenging we only used 10% of the data by subsampling it. More details of the dataset are provided in Table 2. The results presented in the paper are averaged over the 5 random seeds.

heading: C.2 DEEPMIND LAB DATASET
text: DeepMind Lab (Beattie et al., 2016) data was collected by training distributed R2D2 (Kapturowski et al., 2019) agents from scratch on individual tasks. First, we tuned the hyperparameters of a distributed version of the Acme (Hoffman et al., 2020) R2D2 agent independently for every task to achieve fast learning in terms of actor steps. Then, we recorded the experience across all actors during entire training runs a few times for every task. Training was stopped after there was no further progress in learning across all runs, with a resulting number of steps for each run between 50 million for the easiest task (seekavoid arena 01) and 200 million for some of the hard tasks. Finally we built a separate offline RL dataset for every run and every task. See more details about these datasets in Table 3.
Additionally, for the seekavoid arena 01 task we ran two fully trained snapshots of our R2D2 agents on the environment with different levels of noise ( = 0, 0.01, 0.1, 0.25 for -greedy action selection). We recorded all interactions with the environment and generated a different offline RL dataset containing 10 million actor steps for every agent and every value of .

heading: D EXPERIMENT DETAILS
text: We used the Adam optimizer (Kingma & Ba, 2014) for all our experiments. For details on the used hyperparameters, refer to the Table 4 for bsuite, Table 5 for Atari, and Table 6 for DeepMind Lab. Our evaluation protocol is described below, in Section D.1. On Atari experiments, we have normalized the agents’ scores as described in (Gulcehre et al., 2020).
On Atari, in all our experiments we report the median normalized score along with the bootstraps estimates of 75th and 25th percentiles for the interquantile range estimates of the errors in the error bars as done by (Gulcehre et al., 2020).
Atari Hyperparameters: On Atari we directly used the baselines and the hyperparameters reported in (Gulcehre et al., 2020), to get the detailed Atari results on test set we communicated with the authors. We have run additional CQL and our own models with ranking regularization and reparameterization. For CQL we have finetuned both the learning rate from the grid [8e− 5, 1e− 4, 3e− 4] and the regularization hyperparameter α ∈ [0.005, 0.05, 0.01, 0.1, 1]. For our own proposed models we have only tuned the learning rate from the grid [8e− 5, 1e− 4, 3e− 4] and the ranking regularization hyperparameter from the grid [0.005, 0.05, 0.01, 0.1, 1]. We have fixed the rest of the hyperparameters. As mentioned earlier, we have only used the online policy selection games for finetuning the hyperparameters. As a result of our grid search, we have used learning rate of 1e− 4 for CQL and our models. We have used 0.01 for the α hyperparameter of CQL. 0.05 seems to be the optimal hyperparameter choice for the ranking regularization hyperparameter.
DeepMind Lab Hyperparameters: On DeepMind Lab experiments, we tuned the hyperparameters of each model individually on each level separately. We have tuned the learning rate and the regularization hyperparameters for each model from the same grid that we have used for Atari. All our algorithms are n-step in DeepMind Lab experiments, where n is fixed to 5 in all our experiments. Thus both behavior value estimation and Q-learning experiments use 5 steps of unrolls for learning.

heading: D.1 EVALUATION PROTOCOL
text: To evaluate the performance of the various methods, we use the following protocol:
1. We sweep over a small (5-10) sets of hyperparameter values for each of the methods.
2. We independently train each of the models on 5 datasets generated by running the behavior policy with 5 different seeds (ie. producing 25-50 runs per problem setting and method).
3. We evaluate the produced models in the original environments (without the noise).
4. We average the results over seeds and report the results of the best hyperparameter for each method.

heading: D.1.1 EVALUATION METHOD
text: To evaluate models (step 3. above), in the case of bsuite and DeepMind Lab we ran an evaluation job in parallel to the training one. It repeatedly read the learner’s checkpoint and produced evaluation results during training. We report the average of the evaluation scores over the last 100 learning steps.
In the case of the Atari environments, instead of averaging performance during the final steps of learning, we take the final snapshot produced by a given method and evaluate it on a ‘100‘ environment steps after the training finished.

heading: D.2 ATARI OFFLINE POLICY SELECTION RESULTS
text: In Table 7, we show the performance of our baselines on different Atari Offline Policy selection games. We show that QRr outperforms other approaches significantly.

heading: D.3 DEEPMIND LAB DETAILED RESULTS
text: In Table 8, we have shown the results on the Deepmind Lab datasets. It is possible see from these numerica results that BR outperforms other approaches and B is still very competitive.
D.4 BSUITE DETAILED RESULTS
We generated datasets and performed experiments analogous to these in Section 4.1 for mountain car environment. We present results for all three environments in Table 9. BRr outperforms all the baselines.

heading: E REPARAMETRIZING THE Q-NETWORK
text: In all reparameterized critic experiments we have used the tanh(·) activation function with refine gates to help with optimization (Gu et al., 2019). We have not tuned the hyperparameters of the
reparameterization in our experiments, we have used four times larger minibatches to update the scale, since it is cheap to update a single scalar and as shown in Algorithm 1, we have used twice smaller learning rate to update the scale than the rest of the parameters of the network. This is a heuristic, but we found this simple heuristic to work well across all the tasks that we have tried. Potentially it is possible to get better results by tuning the hyperparameters for reparameterization more carefully.
Algorithm 1 Algorithm of Reparametrized Q-Network Inputs: Dataset of trajectories D, batch size to update θ: B1, batch size to update γ: B2, and number of actors A. Initialize Q̂ weights θ. Initialize α to 1. Initialize target policy weights θ′ ← θ. for nsteps do
Sample transition sequences (st:t+m, at:t+m, rt:t+m) from datasetD to construct a mini-batch of size B. Calculate loss L(st, at, rt, st+1; θ, α) using target network. Update θ with GD: θ ← θ − η1∇θL(θ) Update α with GD: α← α− η1 √ B1/B2∇γL(γ)
If t mod ttarget = 0, update the target weights and α, θ′ ← θ, α′ ← α. end for
As seen in Algorithm 1, there is a two stage of optimization to update the parameters of Q-network θ and the scale of the Q values α. They both use different learning rates, it is important to make sure that we update the α with a smaller learning rate: η2 ≤ η1.

heading: F RANKING REGULARIZER
text: We propose a family of methods that prevent the extrapolation error by suppressing the values of the actions that are not in the dataset. We achieve that by ranking the actions in the training set higher than the ones that are not in the training set. For the learned Q-function the absolute values of actions do not matter, we are rather interested in relative ranking of the actions. Given at is the action from the dataset. For all j 6= t and illustration purposes, the value iteration can be written as:
E[max a Q(s, a)] ≈ E [P (Q(s, at) > Q(s, aj))Q(s, at)|t ∈Max] + E [P (Q(s, at) ≯ Q(s, aj))Q(s, aj)|j ∈Max]
= E [P (Q(s, at) > Q(s, aj))Q(s, at)|t ∈Max] + E [(1− P (Q(s, at) > Q(s, aj)))Q(s, aj)|j ∈Max] = αE [ P (Q̂(s, at) > Q̂(s, aj))Q̂(s, at)|t ∈Max ] + αE [ (1− P (Q̂(s, at) > Q̂(s, aj)))Q̂(s, aj)|j ∈Max ] = α ( E [ P (Q̂(s, at) > Q̂(s, aj))Q̂(s, at)|t ∈Max ] + E [ (1− P (Q̂(s, at) > Q̂(s, aj))) ]) ξ
where ξ is an irreducible noise, because we can not gather additional data on (st, aj), and we don’t know the corresponding reward for it. This causes extrapolation error which accumulates through the bootstrapping in the backups as noted by Kumar et al. (2019). We implicitly pull down the P (Q(s, at) ≯ Q(s, at)) by ranking the actions in the dataset higher which pushes up P (Q(s, at) > Q(s, aj)). As a result, the extrapolation error in Q-learning would also reduce.

heading: F.1 PAIRWISE RANKING LOSS FOR Q-LEARNING
text: In this section, we discus the relationship between the pairwise ranking loss for Q-learning and the list-wise pairwise ranking losses.
ptj = sigm(Q̂)θ(s, at)− Q̂θ(s, aj))
π(at|s) ≈ |A|∏
i=0,i6=t
pti/Z
Z = |A|∑ i=0 |A|∏ j=0,j 6=i pij
R(θ) = − |A|∑ i=0 log(pti)
= − |A|∑ i=0 log(sigm(Q̂θ(s, at)− Q̂θ(s, aj)))
= |A|∑ i=0 softplus(Q̂θ(s, aj)− Q̂θ(s, at))
We use a common approximation (Chen et al., 2009; Burges et al., 2005) to the softplus-based log-likelihood is to use a hinge-loss which can be seen as an approximation:
C(θ) = |A|∑
i=0,i6=t
max ( Q̂θ(s, a)− Q̂θ(s, at) + ν, 0 )2 (13)
Imposing the constraint in Equation (13) can be harmful if the dataset has lots of suboptimal trajectories. Because this constraint will try to maximize the values of suboptimal actions in the
dataset. As a result, similar to Wang et al. (2020), we propose a filtering function to impose that constraints only on rewarding transitions:
C(θ) = exp(GB(s)− Es∼D[GB(s)]) |A|∑
i=0,i6=t
max ( Q̂θ(s, ai)− Q̂θ(s, at) + ν, 0 )2 (14)

heading: F.2 RELATIONSHIP TO THE POLICY GRADIENTS
text: It is possible to drive the foirmulation that we use for the ranking regularizer from the policy gradient theorem to show the relationship. The Ranking Policy Gradient Theorem formulates the optimization of long-term reward using a ranking objective as done in Lin & Zhou (2020). The proof below illustrates the formulation process. Let us note that we apply the ranking regularization on the offline and off-policy data, such that thee formalism below only works when the behavior policy and target policy are equivalent, when the transitions are coming from on-policy data. If the ranking regularizer is used on the on-policy data it approximates the policy gradients, but it will not on the off-policy data.
Our construction is based on direct policy differentiation (Peters & Schaal, 2008; Williams, 1992) where the objective function is to θ∗ = arg maxθ J(θ).
∇θJ(θ) =∇θ ∑
τ pθ(τ)G
B(s) (15) = ∑
τ pθ(τ)∇θ log pθ(τ)GB(s) = ∑
τ pθ(τ)∇θ log
( p(s0)Π T t=1πθ(at|st)p(st+1|st, at) ) GB(s)
= ∑
τ pθ(τ) ∑T t=1 ∇θ log πθ(at|st)GB(s)
=Eτ∼πθ [∑T
t=1 ∇θ log πθ(at|st)GB(s) ] =Eτ∼πθ [∑T t=1 ∇θ log (∏m j=1,j 6=i pij ) GB(s)
] =Eτ∼πθ [∑T t=1 ∇θ ∑m j=1,j 6=i log (sigm(pij))GB(s) ] (16)
=− Eτ∼πθ [∑T t=1 ∇θ ∑m j=1,j 6=i softplus(pji)G B(s) ] ≈− Eτ∼πθ [∑T t=1 ∇θ (∑m j=1,j 6=i rectifier (Q(s, ai)−Q(s, aj)) ) GB(s) ] , (17)
with baseline Es∼D[GB(s)] it will be, ≈− Eτ∼πθ [∑T t=1 ∇θ (∑m j=1,j 6=i rectifier (Q(s, ai)−Q(s, aj)) ) ( GB(s)− Es∼D[GB(s)] )] (18)
Then we apply the exp(·) transformation on (GB(s)− Es∼D[GB(s)] to impose this loss loss mostly on the rewarding trajectories, and we can turn the maximization problem to a minimization one with a flip of sign:
=Eτ∼πθ [∑T t=1 ∇θ (∑m j=1,j 6=i rectifier (Q(s, ai)−Q(s, aj)) ) exp ( GB(s)− Es∼D[GB(s)] )] (19)
where the trajectory is a series of state-action pairs from t = 1, ..., T , i.e. τ = (s1, a1, s2, a2, ..., sT ). The gradients in (19) is exactly the gradients of the ranking regularizer.

Review summaries:
The paper deals with offline aka batch RL for discrete actions. Three techniques ((i) behavior value estimation, (ii) ranking regularization, and (iii) reparametrization of the value function), which can be combined with each other, are presented. These techniques are compared with other methods in different experiments. Furthermore a new benchmark is being introduced.  It is claimed that in this new benchmark, the new techniques outperform state-of-the-art methods. Furthermore it is claimed that the presented method „behavior value estimation“, although it is only a one-step greedy optimization is typically already sufficient for dramatic gains.

This paper focuses on the problem of Q value over-estimation in offline reinforcement learning and proposes three approaches (tricks) to help solve this problem. (1) estimate Q value of behavior policy avoiding max-operator in Q learning and take greedy action according to the behavior value estimation. (2) introduce ranking loss to push down the value estimation of all unobserved state-action pairs to avoid over-estimation. (3) use tanh operator to bound the range of Q value estimation, and learn a scale parameter with regularization term. The experimental results on several domains (Atari, Bsuite, Deepmind Lab) with discrete action space show performance better than existing algorithms.