Original: U SER -I NTERACTIVE O FFLINE R EINFORCEMENT L EARNING
Revised: U SER -I NTERACTIVE O FFLINE R EINFORCEMENT L EARNING

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Offline reinforcement learning algorithms still lack trust in practice due to the risk that the learned policy performs worse than the original policy that generated the dataset or behaves in an unexpected way that is unfamiliar to the user.
Revised: Offline reinforcement learning algorithms still lack trust in practice due to the risk that the learned policy performs worse than the original policy that generated the dataset or behaves in an unexpected way that is unfamiliar to the user.

Original: At the same time, offline RL algorithms are not able to tune their most important hyperparameter - the proximity of the learned policy to the original policy.
Revised: At the same time, offline RL algorithms are not able to tune their most important hyperparameter - the proximity of the learned policy to the original policy.

Original: We propose an algorithm that allows the user to tune this hyperparameter at runtime, thereby addressing both of the above mentioned issues simultaneously.
Revised: We propose an algorithm that allows the user to tune this hyperparameter at runtime, thereby addressing both of the above mentioned issues simultaneously.

Original: This allows users to start with the original behavior and grant successively greater deviation, as well as stopping at any time when the policy deteriorates or the behavior is too far from the familiar one.
Revised: This allows users to start with the original behavior and grant successively greater deviation, as well as stopping at any time when the policy deteriorates or the behavior is too far from the familiar one.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Recently, offline reinforcement learning (RL) methods have shown that it is possible to learn effective policies from a static pre-collected dataset instead of directly interacting with the environment (Laroche et al., 2019; Fujimoto et al., 2019; Yu et al., 2020; Swazinna et al., 2021b).
Revised: Recently, offline reinforcement learning (RL) methods have shown that it is possible to learn effective policies from a static pre-collected dataset instead of directly interacting with the environment (Laroche et al., 2019; Fujimoto et al., 2019; Yu et al., 2020; Swazinna et al., 2021b).

Original: Since direct interaction is in practice usually very costly, these techniques have alleviated a large obstacle on the path of applying reinforcement learning techniques in real world problems.
Revised: Since direct interaction is in practice usually very costly, these techniques have alleviated a large obstacle on the path of applying reinforcement learning techniques in real world problems.

Original: A major issue that these algorithms still face is tuning their most important hyperparameter: The proximity to the original policy.
Revised: A major issue that these algorithms still face is tuning their most important hyperparameter: The proximity to the original policy.

Original: Virtually all algorithms tackling the offline setting have such a hyperparameter, and it is obviously hard to tune, since no interaction with the real environment is permitted until final deployment.
Revised: Virtually all algorithms tackling the offline setting have such a hyperparameter, and it is obviously hard to tune, since no interaction with the real environment is permitted until final deployment.

Original: Practitioners thus risk being overly conservative (resulting in no improvement) or overly progressive (risking worse performing policies) in their choice.
Revised: Practitioners thus risk being overly conservative (resulting in no improvement) or overly progressive (risking worse performing policies) in their choice.

Original: Additionally, one of the arguably largest obstacles on the path to deployment of RL trained policies in most industrial control problems is that (offline) RL algorithms ignore the presence of domain experts, who can be seen as users of the final product - the policy.
Revised: Additionally, one of the arguably largest obstacles on the path to deployment of RL trained policies in most industrial control problems is that (offline) RL algorithms ignore the presence of domain experts, who can be seen as users of the final product - the policy.

Original: Instead, most algorithms today can be seen as trying to make human practitioners obsolete.
Revised: Instead, most algorithms today can be seen as trying to make human practitioners obsolete.

Original: We argue that it is important to provide these users with a utility - something that makes them want to use RL solutions.
Revised: We argue that it is important to provide these users with a utility - something that makes them want to use RL solutions.

Original: Other research fields, such as machine learning for medical diagnoses, have already established the idea that domain experts are crucially important to solve the task and complement human users in various ways Babbar et al.
Revised: Other research fields, such as machine learning for medical diagnoses, have already established the idea that domain experts are crucially important to solve the task and complement human users in various ways Babbar et al.

Original: ; Cai et al.
Revised: ; Cai et al.

Original: ; De-Arteaga et al.
Revised: ; De-Arteaga et al.

Original: ; Fard & Pineau (2011); Tang et al.
Revised: ; Fard & Pineau (2011); Tang et al.

Original: We see our work in line with these and other researchers (Shneiderman, 2020; Schmidt et al., 2021), who suggest that the next generation of AI systems needs to adopt a user-centered approach and develop systems that behave more like an intelligent tool, combining both high levels of human control and high levels of automation.
Revised: We see our work in line with these and other researchers (Shneiderman, 2020; Schmidt et al., 2021), who suggest that the next generation of AI systems needs to adopt a user-centered approach and develop systems that behave more like an intelligent tool, combining both high levels of human control and high levels of automation.

Original: We seek to develop an offline RL method that does just that.
Revised: We seek to develop an offline RL method that does just that.

Original: Furthermore, we see giving control to the user as a requirement that may in the future be much more enforced when regulations regarding AI systems become more strict: The EU’s high level expert group on AI has already recognized “human autonomy and oversight” as a key requirement for trustworthy AI in their
Revised: Furthermore, we see giving control to the user as a requirement that may in the future be much more enforced when regulations regarding AI systems become more strict: The EU’s high level expert group on AI has already recognized “human autonomy and oversight” as a key requirement for trustworthy AI in their

Original: Ethics Guidelines for Trustworthy AI (Smuha, 2019).
Revised: Ethics Guidelines for Trustworthy AI (Smuha, 2019).

Original: In the future, solutions found with RL might thus be required by law to exhibit features that enable more human control.
Revised: In the future, solutions found with RL might thus be required by law to exhibit features that enable more human control.

Original: In this paper, we thus propose a simple method to provide users with more control over how an offline RL policy will behave after deployment.
Revised: In this paper, we thus propose a simple method to provide users with more control over how an offline RL policy will behave after deployment.

Original: The algorithm that we develop trains a conditional policy, that can after training adapt the trade-off between proximity to the data generating policy on the one hand and estimated performance on the other.
Revised: The algorithm that we develop trains a conditional policy, that can after training adapt the trade-off between proximity to the data generating policy on the one hand and estimated performance on the other.

Original: Close proximity to a known solution naturally facilitates trust, enabling conservative users to choose behavior they are more inclined to confidently deploy.
Revised: Close proximity to a known solution naturally facilitates trust, enabling conservative users to choose behavior they are more inclined to confidently deploy.

Original: That way, users may benefit from the automation provided by offline RL (users don’t need to handcraft controllers, possibly even interactively choose actions) yet still remain in control as they can e.g. make the policy move to a more conservative or more liberal trade-off.
Revised: That way, users may benefit from the automation provided by offline RL (users don’t need to handcraft controllers, possibly even interactively choose actions) yet still remain in control as they can e.g. make the policy move to a more conservative or more liberal trade-off.

Original: We show how such an algorithm can be designed, as well as compare its performance with a variety of offline
Revised: We show how such an algorithm can be designed, as well as compare its performance with a variety of offline

Original: RL baselines and show that a user can achieve state of the art performance with it.
Revised: RL baselines and show that a user can achieve state of the art performance with it.

Original: Furthermore, we show that our method has advantages over simpler approaches like training many policies with diverse hyperparameters.
Revised: Furthermore, we show that our method has advantages over simpler approaches like training many policies with diverse hyperparameters.

Original: Finally, since we train a policy conditional on one of the most important hyperparameters in offline RL, we show how a user could potentially use it to tune this hyperparameter.
Revised: Finally, since we train a policy conditional on one of the most important hyperparameters in offline RL, we show how a user could potentially use it to tune this hyperparameter.

Original: In many cases of our evaluations, this works almost regret-free, since we observe that the performance as a function of the hyperparameter is mostly a smooth function.
Revised: In many cases of our evaluations, this works almost regret-free, since we observe that the performance as a function of the hyperparameter is mostly a smooth function.

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: Offline RL Recently, a plethora of methods has been published that learn policies from static datasets.
Revised: Offline RL Recently, a plethora of methods has been published that learn policies from static datasets.

Original: Early works, such as FQI and NFQ (Ernst et al., 2005; Riedmiller, 2005), were termed batch instead of offline since they didn’t explicitly address issue that the data collection cannot be influenced.
Revised: Early works, such as FQI and NFQ (Ernst et al., 2005; Riedmiller, 2005), were termed batch instead of offline since they didn’t explicitly address issue that the data collection cannot be influenced.

Original: Instead, similarly to other batch methods (Depeweg et al., 2016; Hein et al., 2018; Kaiser et al., 2020), they assumed a uniform random data collection that made generalization to the real environment simpler.
Revised: Instead, similarly to other batch methods (Depeweg et al., 2016; Hein et al., 2018; Kaiser et al., 2020), they assumed a uniform random data collection that made generalization to the real environment simpler.

Original: Among the first to explicitly address the limitations in the offline setting under unknown data collection were SPIBB(-DQN) (Laroche et al., 2019) in the discrete and BCQ (Fujimoto et al., 2019) in the continuous actions case.
Revised: Among the first to explicitly address the limitations in the offline setting under unknown data collection were SPIBB(-DQN) (Laroche et al., 2019) in the discrete and BCQ (Fujimoto et al., 2019) in the continuous actions case.

Original: Many works with different focuses followed: Some treat discrete
Revised: Many works with different focuses followed: Some treat discrete

Original: MDPs and come with provable bounds on the performance at least with a certain probability Thomas et al. (2015); Nadjahi et al.
Revised: MDPs and come with provable bounds on the performance at least with a certain probability Thomas et al. (2015); Nadjahi et al.

Original: (2019), however many more focused on the continuous setting: EMaQ,
Revised: (2019), however many more focused on the continuous setting: EMaQ,

Original: BEAR, BRAC, ABM, various DICE based methods, REM, PEBL, PSEC-TD-0, CQL, IQL, BAIL,
Revised: BEAR, BRAC, ABM, various DICE based methods, REM, PEBL, PSEC-TD-0, CQL, IQL, BAIL,

Original: CRR, COIL, O-RAAC, OPAL, TD3+BC, and RvS (Ghasemipour et al., 2021; Kumar et al., 2019;
Revised: CRR, COIL, O-RAAC, OPAL, TD3+BC, and RvS (Ghasemipour et al., 2021; Kumar et al., 2019;

Original: Wu et al., 2019; Siegel et al., 2020; Nachum et al., 2019; Zhang et al., 2020; Agarwal et al., 2020;
Revised: Wu et al., 2019; Siegel et al., 2020; Nachum et al., 2019; Zhang et al., 2020; Agarwal et al., 2020;

Original: Smit et al., 2021; Pavse et al., 2020; Kumar et al., 2020; Kostrikov et al., 2021; Chen et al., 2019;
Revised: Smit et al., 2021; Pavse et al., 2020; Kumar et al., 2020; Kostrikov et al., 2021; Chen et al., 2019;

Original: Wang et al., 2020; Liu et al., 2021; Urpí et al., 2021; Ajay et al., 2020; Brandfonbrener et al., 2021;
Revised: Wang et al., 2020; Liu et al., 2021; Urpí et al., 2021; Ajay et al., 2020; Brandfonbrener et al., 2021;

Original: Emmons et al., 2021) are just a few of the proposed model-free methods over the last few years.
Revised: Emmons et al., 2021) are just a few of the proposed model-free methods over the last few years.

Original: Additionally, many model-based as well as hybrid approaches have been proposed, such as MOPO,
Revised: Additionally, many model-based as well as hybrid approaches have been proposed, such as MOPO,

Original: MOReL, MOOSE, COMBO, RAMBO, and WSBC (Yu et al., 2020; Kidambi et al., 2020; Swazinna et al., 2021b; Yu et al., 2021; Rigter et al., 2022; Swazinna et al., 2021a).
Revised: MOReL, MOOSE, COMBO, RAMBO, and WSBC (Yu et al., 2020; Kidambi et al., 2020; Swazinna et al., 2021b; Yu et al., 2021; Rigter et al., 2022; Swazinna et al., 2021a).

Original: Even approaches that train policies purely supervised, by conditioning on performance, have been proposed (Peng et al., 2019;
Revised: Even approaches that train policies purely supervised, by conditioning on performance, have been proposed (Peng et al., 2019;

Original: Emmons et al., 2021; Chen et al., 2021).
Revised: Emmons et al., 2021; Chen et al., 2021).

Original: Model based algorithms more often use model uncertainty, while model-free methods use a more direct behavior regularization approach.
Revised: Model based algorithms more often use model uncertainty, while model-free methods use a more direct behavior regularization approach.

Original: Offline policy evaluation or offline hyperparameter selection is concerned with evaluating (or at least ranking) policies that have been found by an offline RL algorithm, in order to either pick the best performing one or to tune hyperparameters.
Revised: Offline policy evaluation or offline hyperparameter selection is concerned with evaluating (or at least ranking) policies that have been found by an offline RL algorithm, in order to either pick the best performing one or to tune hyperparameters.

Original: Often, dynamics models are used to evaluate policies found in model-free algorithms, however also model-free evaluation methods exist (Hans et al., 2011;
Revised: Often, dynamics models are used to evaluate policies found in model-free algorithms, however also model-free evaluation methods exist (Hans et al., 2011;

Original: Paine et al., 2020; Konyushova et al., 2021; Zhang et al., 2021b;
Revised: Paine et al., 2020; Konyushova et al., 2021; Zhang et al., 2021b;

Original: Fu et al., 2021).
Revised: Fu et al., 2021).

Original: Unfortunately, but also intuitively, this problem is rather hard since if any method is found that can more accurately assess the policy performance than the mechanism in the offline algorithm used for training, it should be used instead of the previously employed method for training.
Revised: Unfortunately, but also intuitively, this problem is rather hard since if any method is found that can more accurately assess the policy performance than the mechanism in the offline algorithm used for training, it should be used instead of the previously employed method for training.

Original: Also, the general dilemma of not knowing in which parts of the state-action space we know enough to optimize behavior seems to always remain.
Revised: Also, the general dilemma of not knowing in which parts of the state-action space we know enough to optimize behavior seems to always remain.

Original: Works such as Zhang et al.
Revised: Works such as Zhang et al.

Original: (2021a)
Revised: (2021a)

Original: ; Lu et al.
Revised: ; Lu et al.

Original: (2021) become applicable if limited online evaluations are allowed, making hyperparameter tuning much more viable.
Revised: (2021) become applicable if limited online evaluations are allowed, making hyperparameter tuning much more viable.

Original: Offline RL with online adaptation Other works propose an online learning phase that follows after offline learning has conceded.
Revised: Offline RL with online adaptation Other works propose an online learning phase that follows after offline learning has conceded.

Original: In the most basic form, Kurenkov & Kolesnikov (2021) introduce an online evaluation budget that lets them find the best set of hyperparameters for an offline RL algorithm given limited online evaluation resources.
Revised: In the most basic form, Kurenkov & Kolesnikov (2021) introduce an online evaluation budget that lets them find the best set of hyperparameters for an offline RL algorithm given limited online evaluation resources.

Original: In an effort to minimize such a budget, Yang et al.
Revised: In an effort to minimize such a budget, Yang et al.

Original: (2021) train a set of policies spanning a diverse set of uncertainty-performance trade-offs.
Revised: (2021) train a set of policies spanning a diverse set of uncertainty-performance trade-offs.

Original: Ma et al.
Revised: Ma et al.

Original: (2021) propose a conservative adaptive penalty, that penalizes unknown behavior more during the beginning and less during the end of training, leading to safer policies during training.
Revised: (2021) propose a conservative adaptive penalty, that penalizes unknown behavior more during the beginning and less during the end of training, leading to safer policies during training.

Original: In Pong et al.
Revised: In Pong et al.

Original: (2021); Nair et al.
Revised: (2021); Nair et al.

Original: Zhao et al.
Revised: Zhao et al.

Original: (2021) methods for effective online learning phases that follow the offline learning phase are proposed.
Revised: (2021) methods for effective online learning phases that follow the offline learning phase are proposed.

Original: In contrast to these methods, we are not aiming for a fully automated solution.
Revised: In contrast to these methods, we are not aiming for a fully automated solution.

Original: Instead, we want to provide the user with a valuable tool after training, so we do not propose an actual online phase, also since practitioners may find any performance deterioration inacceptable.
Revised: Instead, we want to provide the user with a valuable tool after training, so we do not propose an actual online phase, also since practitioners may find any performance deterioration inacceptable.

Original: To the best of our knowledge, no prior offline RL method produces policies that remain adaptable after deployment without any further training.
Revised: To the best of our knowledge, no prior offline RL method produces policies that remain adaptable after deployment without any further training.

Original:  LION: L EARNING IN I NTERACTIVE O FFLINE E N VIRONMENTS
Revised:  LION: L EARNING IN I NTERACTIVE O FFLINE E N VIRONMENTS

Original: In this work, we address two dilemmas of the offline RL setting: First and foremost, we would like to provide the user with a high level control option in order to influence the behavior of the policy, since we argue that the user is crucially important for solving the task and not to be made obsolete by an algorithm.
Revised: In this work, we address two dilemmas of the offline RL setting: First and foremost, we would like to provide the user with a high level control option in order to influence the behavior of the policy, since we argue that the user is crucially important for solving the task and not to be made obsolete by an algorithm.

Original: Further we address the issue that in offline RL, the correct hyperparameter controlling the trade-off between conservatism and performance is unknown and can hardly be tuned.
Revised: Further we address the issue that in offline RL, the correct hyperparameter controlling the trade-off between conservatism and performance is unknown and can hardly be tuned.

Original: By training a policy conditioned in the proximity hyperparameter, we aim to enable the user to find a good trade-off hyperparameter.
Revised: By training a policy conditioned in the proximity hyperparameter, we aim to enable the user to find a good trade-off hyperparameter.

Original: As mentioned, behavior cloning, will most likely yield the most trustworthy solution due to its familiarity, however the solution is of very limited use since it does not outperform the previous one.
Revised: As mentioned, behavior cloning, will most likely yield the most trustworthy solution due to its familiarity, however the solution is of very limited use since it does not outperform the previous one.

Original: Offline RL on the other hand is problematic since we cannot simply evaluate policy candidates on the real system and offline policy evaluation is still an open problem (Hans et al., 2011; Paine et al., 2020;
Revised: Offline RL on the other hand is problematic since we cannot simply evaluate policy candidates on the real system and offline policy evaluation is still an open problem (Hans et al., 2011; Paine et al., 2020;

Original: Konyushova et al., 2021; Zhang et al., 2021b;
Revised: Konyushova et al., 2021; Zhang et al., 2021b;

Original: Fu et al., 2021).
Revised: Fu et al., 2021).

Original: In the following, we thus propose a solution that moves the hyperparameter choice from training to deployment time, enabling the user to interactively find the desired trade-off between BC and offline optimization.
Revised: In the following, we thus propose a solution that moves the hyperparameter choice from training to deployment time, enabling the user to interactively find the desired trade-off between BC and offline optimization.

Original: A user may then slowly move from conservative towards better solutions.
Revised: A user may then slowly move from conservative towards better solutions.

Original: 3. T RAINING
Revised: 3. T RAINING

Original: During training time, we optimize three components: A model of the original policy β ϕ ( s ) , an ensemble of transition dynamics models { f iψ i ( s, a ) | i ∈ 0 , . . .
Revised: During training time, we optimize three components: A model of the original policy β ϕ ( s ) , an ensemble of transition dynamics models { f iψ i ( s, a ) | i ∈ 0 , . . .

Original: , N − 1 } , as well as the user adaptive policy π θ ( s, λ ) .
Revised: , N − 1 } , as well as the user adaptive policy π θ ( s, λ ) .

Original: The dynamics models { f i } as well as the original policy β are trained in isolation before the actual policy training starts.
Revised: The dynamics models { f i } as well as the original policy β are trained in isolation before the actual policy training starts.

Original: Both π and β are always simple feedforward neural networks which map states directly to actions in a deterministic fashion (practitioners likely favor deterministic policies over stochastic ones due to trust issues).
Revised: Both π and β are always simple feedforward neural networks which map states directly to actions in a deterministic fashion (practitioners likely favor deterministic policies over stochastic ones due to trust issues).

Original: β is trained to simply imitate the behavior present in the dataset by minimizing the mean squared distance to the observed actions:
Revised: β is trained to simply imitate the behavior present in the dataset by minimizing the mean squared distance to the observed actions:

Original: [Equation]
Revised: [Equation]

Original: Depending on the environment, the transition models are either also feedforward networks or simple recurrent networks with a single recurrent layer.
Revised: Depending on the environment, the transition models are either also feedforward networks or simple recurrent networks with a single recurrent layer.

Original: The recurrent networks build their hidden state over G steps and are then trained to predict a window of size F into the future (similarly to (Hein et al., 2017b)), while the feedforward dynamics simply predict single step transitions.
Revised: The recurrent networks build their hidden state over G steps and are then trained to predict a window of size F into the future (similarly to (Hein et al., 2017b)), while the feedforward dynamics simply predict single step transitions.

Original: Both use mean squared error as loss:
Revised: Both use mean squared error as loss:

Original: [Equation]
Revised: [Equation]

Original: where ˆ s t + H + f are the model predictions that are fed back to be used as input again.
Revised: where ˆ s t + H + f are the model predictions that are fed back to be used as input again.

Original: For simplicity, in this notation we assume the reward to be part of the state.
Revised: For simplicity, in this notation we assume the reward to be part of the state.

Original: Also we do not explicitly show the recurrence and carrying over of the hidden states.
Revised: Also we do not explicitly show the recurrence and carrying over of the hidden states.

Original: After having trained the two components β ϕ ( s ) and { f iψ i ( s, a ) } , we can then move on to policy training.
Revised: After having trained the two components β ϕ ( s ) and { f iψ i ( s, a ) } , we can then move on to policy training.

Original: Similarly to MOOSE and WSBC, we optimize the policy π θ by sampling start states from D and performing virtual rollouts throughout the dynamics ensemble using the current policy candidate.
Revised: Similarly to MOOSE and WSBC, we optimize the policy π θ by sampling start states from D and performing virtual rollouts throughout the dynamics ensemble using the current policy candidate.

Original: In every step, the ensemble predicts the reward as the minimum among its members and the next state that goes with it.
Revised: In every step, the ensemble predicts the reward as the minimum among its members and the next state that goes with it.

Original: At the same time we collect the mean squared differences between the actions that π θ took in the rollout and the one that β ϕ would have taken.
Revised: At the same time we collect the mean squared differences between the actions that π θ took in the rollout and the one that β ϕ would have taken.

Original: The loss is then computed as a weighted sum of the two components.
Revised: The loss is then computed as a weighted sum of the two components.

Original: Crucially, we sample the weighting factor λ randomly and pass it to the policy as an additional input - the policy thus needs to learn all behaviors ranging from pure behavior cloning to entirely free optimization:
Revised: Crucially, we sample the weighting factor λ randomly and pass it to the policy as an additional input - the policy thus needs to learn all behaviors ranging from pure behavior cloning to entirely free optimization:

Original: [Equation]
Revised: [Equation]

Original: where we sample λ between 0 & 1, e ( s t , a t )
Revised: where we sample λ between 0 & 1, e ( s t , a t )

Original: =
Revised: =

Original: min { r ( f iψ i ( s t , a t ))
Revised: min { r ( f iψ i ( s t , a t ))

Original: | i ∈ 0 , ..., N − 1 } denotes the output of the ensemble prediction for reward (we omit explicit notation of recurrence for simplicity) and p ( a t ) =
Revised: | i ∈ 0 , ..., N − 1 } denotes the output of the ensemble prediction for reward (we omit explicit notation of recurrence for simplicity) and p ( a t ) =

Original: [ β ψ ( s t ) − a t ] 2 denotes the penalty based on the mean squared distance between the original policy and the actions proposed by π θ .
Revised: [ β ψ ( s t ) − a t ] 2 denotes the penalty based on the mean squared distance between the original policy and the actions proposed by π θ .

Original: See Fig.
Revised: See Fig.

Original: 1 for a visualization of our proposed training procedure.
Revised: 1 for a visualization of our proposed training procedure.

Original: weighted
Revised: weighted

Original: We motivate our purely model-based approach (no value function involved) with the fact that we have fewer moving parts: Our ensemble can be kept fixed once it is trained, while a value function has to be learned jointly with π θ , which is in our case more complex than usual.
Revised: We motivate our purely model-based approach (no value function involved) with the fact that we have fewer moving parts: Our ensemble can be kept fixed once it is trained, while a value function has to be learned jointly with π θ , which is in our case more complex than usual.

Original: See experimental results in
Revised: See experimental results in

Original: Fig.
Revised: Fig.

Original: 10 a brief attempt at making our approach work in the model-free domain.
Revised: 10 a brief attempt at making our approach work in the model-free domain.

Original: In addition to Eq. 3, we need to penalize divergence not only from the learned model of the original policy during virtual roll-outs, but also from the actual actions in the dataset at λ = 0 .
Revised: In addition to Eq. 3, we need to penalize divergence not only from the learned model of the original policy during virtual roll-outs, but also from the actual actions in the dataset at λ = 0 .

Original: It seems that if this is not done, the trained policy π sticks to the (also trained) original policy β during the rollouts, but during those rollouts, there are states that did not appear in the original dataset, enabling π to actually diverge from the true trajectory distribution.
Revised: It seems that if this is not done, the trained policy π sticks to the (also trained) original policy β during the rollouts, but during those rollouts, there are states that did not appear in the original dataset, enabling π to actually diverge from the true trajectory distribution.

Original: We thus penalize both rollout as well as data divergence at λ = 0 :
Revised: We thus penalize both rollout as well as data divergence at λ = 0 :

Original: [Equation]
Revised: [Equation]

Original: where η controls the penalty weight for not following dataset actions at λ = 0 , see Appendix A for more details.
Revised: where η controls the penalty weight for not following dataset actions at λ = 0 , see Appendix A for more details.

Original: Furthermore, we normalize states to have zero mean and unit variance during every forward pass through dynamics model or policy, using the mean and standard deviation observed in the dataset.
Revised: Furthermore, we normalize states to have zero mean and unit variance during every forward pass through dynamics model or policy, using the mean and standard deviation observed in the dataset.

Original: We also normalize the rewards provided by the ensemble r t =
Revised: We also normalize the rewards provided by the ensemble r t =

Original: e ( s t , a t ) , so that they live in the same magnitude as the action penalties (we assume actions to be in [ − 1 , 1] D , so that the penalty can be in [0 , 4] D where D is the action dimensionality).
Revised: e ( s t , a t ) , so that they live in the same magnitude as the action penalties (we assume actions to be in [ − 1 , 1] D , so that the penalty can be in [0 , 4] D where D is the action dimensionality).

Original: Intuitively, one might choose to sample λ uniformly between zero and one, however instead we choose a beta distribution with parameters (0 . 1 , 0 . 1) , which could be called bathtub-shaped.
Revised: Intuitively, one might choose to sample λ uniformly between zero and one, however instead we choose a beta distribution with parameters (0 . 1 , 0 . 1) , which could be called bathtub-shaped.

Original: Similarly to (Seo et al., 2021), we find that it is important to put emphasis on the edge cases, so that the extreme behavior is properly learned, rather than putting equal probability mass on each value in the [0, 1] range.
Revised: Similarly to (Seo et al., 2021), we find that it is important to put emphasis on the edge cases, so that the extreme behavior is properly learned, rather than putting equal probability mass on each value in the [0, 1] range.

Original: The interpolation between the edges seems to be easier and thus require less samples.
Revised: The interpolation between the edges seems to be easier and thus require less samples.

Original: Fig.shows policy results for different lambda distributions during training.
Revised: Fig.shows policy results for different lambda distributions during training.

Original: 3. D EPLOYMENT
Revised: 3. D EPLOYMENT

Original: 1: Require Dataset D = { τ i } , randomly initialized parameters θ , ϕ , ψ , lambda distribution parameters Beta(a , b) , horizon H , number of policy updates U 2: // dynamics and original policy models can be trained supervised and independently of other components 3: train original policy model β ϕ using D and Equation4: train dynamics models f iψ i with D and Equation5: for j in 1..U do 6: sample start states S 0 ∼ D 7: sample lambda values λ ∼ Beta(a , b) 8: initialize policy loss
Revised: 1: Require Dataset D = { τ i } , randomly initialized parameters θ , ϕ , ψ , lambda distribution parameters Beta(a , b) , horizon H , number of policy updates U 2: // dynamics and original policy models can be trained supervised and independently of other components 3: train original policy model β ϕ using D and Equation4: train dynamics models f iψ i with D and Equation5: for j in 1..U do 6: sample start states S 0 ∼ D 7: sample lambda values λ ∼ Beta(a , b) 8: initialize policy loss

Original: L ( θ ) =9: for t in 0..
Revised: L ( θ ) =9: for t in 0..

Original: H do 10: calculate policy actions a t =
Revised: H do 10: calculate policy actions a t =

Original: π θ ( s t , λ ) 11: calculate behavioral actions b t = β ϕ ( s t ) 12: calculate penalty term p ( a t ) =
Revised: π θ ( s t , λ ) 11: calculate behavioral actions b t = β ϕ ( s t ) 12: calculate penalty term p ( a t ) =

Original: [ β ψ ( s t ) − a t ]13: r t , s t +

Revised: [ β ψ ( s t ) − a t ]13: r t , s t +

Original: =
Revised: =

Original: f iψ i ( s t , a t ) s.t.
Revised: f iψ i ( s t , a t ) s.t.

Original: i =
Revised: i =

Original: arg min i { r ( f iψ i ( s t , a t )) } 14:
Revised: arg min i { r ( f iψ i ( s t , a t )) } 14:

Original: L ( θ )+ = − γ t [ λr t − (1 − λ ) p ( a t )] 15: update π θ using gradient ∇ θ L ( θ ) and Adam 16: return π θ ;
Revised: L ( θ )+ = − γ t [ λr t − (1 − λ ) p ( a t )] 15: update π θ using gradient ∇ θ L ( θ ) and Adam 16: return π θ ;

Original: At inference time, the trained policy can at any point be influenced by the user that would otherwise be in control of the system, by choosing the λ that is passed to the policy together with the current system state to obtain an action:
Revised: At inference time, the trained policy can at any point be influenced by the user that would otherwise be in control of the system, by choosing the λ that is passed to the policy together with the current system state to obtain an action:

Original: [Equation]
Revised: [Equation]

Original: He or she may choose to be conservative or adventurous, observe the feedback and always adjust the proximity parameter of the policy accordingly.
Revised: He or she may choose to be conservative or adventurous, observe the feedback and always adjust the proximity parameter of the policy accordingly.

Original: At this point, any disliked behavior can immediately be corrected without any time loss due to re-training and deploying a new policy, even if the user’s specific preferences were not known at training time.
Revised: At this point, any disliked behavior can immediately be corrected without any time loss due to re-training and deploying a new policy, even if the user’s specific preferences were not known at training time.

Original: We propose to initially start with λ = 0 during deployment, in order to check whether the policy is actually able to reproduce the original policy and to gain the user’s trust in the found solution.
Revised: We propose to initially start with λ = 0 during deployment, in order to check whether the policy is actually able to reproduce the original policy and to gain the user’s trust in the found solution.

Original: Then, depending on how critical failures are and how much time is at hand, λ may be increased in small steps for as long as the user is still comfortable with the observed behavior.
Revised: Then, depending on how critical failures are and how much time is at hand, λ may be increased in small steps for as long as the user is still comfortable with the observed behavior.

Original: Figure 3 shows an example of how the policy behavior changes over the course of λ .
Revised: Figure 3 shows an example of how the policy behavior changes over the course of λ .

Original: Once the performance stops to increase or the user is otherwise not satisfied, we can immediately return to the last satisfying λ value.
Revised: Once the performance stops to increase or the user is otherwise not satisfied, we can immediately return to the last satisfying λ value.

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: At first, we intuitively showcase LION in a simple 2D-world in order to get an understanding of how the policy changes its behavior based on λ .
Revised: At first, we intuitively showcase LION in a simple 2D-world in order to get an understanding of how the policy changes its behavior based on λ .

Original: Afterwards, we move to a more serious test, evaluating our algorithm on the 16 industrial benchmark (IB) datasets (Hein et al., 2017a; Swazinna et al., 2021b).
Revised: Afterwards, we move to a more serious test, evaluating our algorithm on the 16 industrial benchmark (IB) datasets (Hein et al., 2017a; Swazinna et al., 2021b).

Original: We aim to answer the following questions:
Revised: We aim to answer the following questions:

Original: • Do LION policies behave as expected,
Revised: • Do LION policies behave as expected,

Original: i
Revised: i

Original: e. do they reproduce the original policy at λ =and deviate more and more from it with increased freedom to optimize for return?
Revised: e. do they reproduce the original policy at λ =and deviate more and more from it with increased freedom to optimize for return?

Original: Do LION policies at least in parts of the spanned λ space perform better or similarly well to state of the art offline RL algorithms?
Revised: Do LION policies at least in parts of the spanned λ space perform better or similarly well to state of the art offline RL algorithms?

Original: • Is it easy to find the λ values that maximize return for practitioners?
Revised: • Is it easy to find the λ values that maximize return for practitioners?

Original: That is, are the performance courses smooth or do they have multiple local mini- & maxima?
Revised: That is, are the performance courses smooth or do they have multiple local mini- & maxima?

Original: • Is it possible for users to exploit the λ regularization at runtime to restrict the policy to only exhibit behavior he or she is comfortable with?
Revised: • Is it possible for users to exploit the λ regularization at runtime to restrict the policy to only exhibit behavior he or she is comfortable with?

Original: 4. 2D-W ORLD
Revised: 4. 2D-W ORLD

Original: 8 10    10 (a) Behavioral Policy w/o noise    8 

Revised: 8 10    10 (a) Behavioral Policy w/o noise    8

Original:    10 (b) 2D Env reward distribution 0.
Revised:    10 (b) 2D Env reward distribution 0.

Original: a n g l e t o ( 1 , 0 ) 0.
Revised: a n g l e t o ( 1 , 0 ) 0.

Original: r e w a r d
Revised: r e w a r d

Original: We evaluate the LION approach on a simplistic 2D benchmark.
Revised: We evaluate the LION approach on a simplistic 2D benchmark.

Original: The states are x & y coordinates in the environment and rewards are given based on the position of the agent, following a
Revised: The states are x & y coordinates in the environment and rewards are given based on the position of the agent, following a

Original: Gaussian distribution around a fixed point in the state space, i.e. r ( s t ) =
Revised: Gaussian distribution around a fixed point in the state space, i.e. r ( s t ) =

Original: [Equation]
Revised: [Equation]

Original: In this example we set µ = (3 , 6) T and σ = (1 . 5 , 1 . 5) T .
Revised: In this example we set µ = (3 , 6) T and σ = (1 . 5 , 1 . 5) T .

Original: A visualization of the reward distribution can be seen in Fig.
Revised: A visualization of the reward distribution can be seen in Fig.

Original: 2 (b).
Revised: 2 (b).

Original: We collect data from the environment using a simple policy that moves either to position (2 . 5 , 2 . 5) T or to (7 . 5 , 7 . 5) T , depending on which is closer to the randomly drawn start state (shown in Fig. 2(a)), adding ε = 10% random actions as exploration.
Revised: We collect data from the environment using a simple policy that moves either to position (2 . 5 , 2 . 5) T or to (7 . 5 , 7 . 5) T , depending on which is closer to the randomly drawn start state (shown in Fig. 2(a)), adding ε = 10% random actions as exploration.

Original: Then we follow the outlined training procedure, by training a transition model, original policy model and finally a new policy that can at runtime change its behavior based on the desired proximity to the original policy.
Revised: Then we follow the outlined training procedure, by training a transition model, original policy model and finally a new policy that can at runtime change its behavior based on the desired proximity to the original policy.

Original: Fig.
Revised: Fig.

Original: 3 shows policy maps for λ ∈ { 0 . 0 , 0 . 6 , 0 .
Revised: 3 shows policy maps for λ ∈ { 0 . 0 , 0 . 6 , 0 .

Original: 7 , 0 . 85 , 1 . 0 } , moving from simply imitating the original policy, over different mixtures, to pure return optimization.
Revised: 7 , 0 . 85 , 1 . 0 } , moving from simply imitating the original policy, over different mixtures, to pure return optimization.

Original: Since the task is easy and accurately modeled by the dynamics ensemble, one may give absolute freedom to the policy and optimize for return only.
Revised: Since the task is easy and accurately modeled by the dynamics ensemble, one may give absolute freedom to the policy and optimize for return only.

Original: As it can be seen, the policy moves quickly to the center of the reward distribution for λ = 1 .
Revised: As it can be seen, the policy moves quickly to the center of the reward distribution for λ = 1 .

Original: [Figure]
Revised: [Figure]

Original: 4. I NDUSTRIAL B ENCHMARK
Revised: 4. I NDUSTRIAL B ENCHMARK

Original: Datasets We evaluate LION on the industrial benchmark datasets initially proposed in (Swazinna et al., 2021b).
Revised: Datasets We evaluate LION on the industrial benchmark datasets initially proposed in (Swazinna et al., 2021b).

Original: The 16 datasets are created with three different baseline original policies ( optimized , mediocre , bad ) mixed with varying degrees of exploration.
Revised: The 16 datasets are created with three different baseline original policies ( optimized , mediocre , bad ) mixed with varying degrees of exploration.

Original: The optimized baseline is an RL trained policy and simulates an expert practitioner.
Revised: The optimized baseline is an RL trained policy and simulates an expert practitioner.

Original: The mediocre baseline moves the system back and forth around a fixed point that is rather well behaved, while the bad baseline steers to a point on the edge of the state space in which rewards are deliberately bad.
Revised: The mediocre baseline moves the system back and forth around a fixed point that is rather well behaved, while the bad baseline steers to a point on the edge of the state space in which rewards are deliberately bad.

Original: Each baseline is combined with ε ∈ { 0 . 0 , 0 . 2 , 0 . 4 , 0 . 6 , 0 . 8 , 1 . 0 } -greedy exploration to collect a dataset (making the ε = 0 .
Revised: Each baseline is combined with ε ∈ { 0 . 0 , 0 . 2 , 0 . 4 , 0 . 6 , 0 . 8 , 1 . 0 } -greedy exploration to collect a dataset (making the ε = 0 .

Original: datasets extreme cases of the narrow distribution problem).
Revised: datasets extreme cases of the narrow distribution problem).

Original: Together, they constitute a diverse set of offline
Revised: Together, they constitute a diverse set of offline

Original: RL settings.
Revised: RL settings.

Original: The exact baseline policies are given by:
Revised: The exact baseline policies are given by:

Original: [Equation]
Revised: [Equation]

Original: The datasets contain 100,000 interactions collected by the respective baseline policy combined with the ε -greedy exploration.
Revised: The datasets contain 100,000 interactions collected by the respective baseline policy combined with the ε -greedy exploration.

Original: The IB is a high dimensional and partially observable environment - if access to the full Markov state were provided, it would contain 20 state variables.
Revised: The IB is a high dimensional and partially observable environment - if access to the full Markov state were provided, it would contain 20 state variables.

Original: Since only six of those are observable, and the relationship to the other variables and their subdynamics are complex and feature heavily delayed components, prior work Hein et al.
Revised: Since only six of those are observable, and the relationship to the other variables and their subdynamics are complex and feature heavily delayed components, prior work Hein et al.

Original: (2017b) has stated that up to 30 past time steps are needed to form a state that can hope to recover the true dynamics, so the state can be considered 180 dimensional.
Revised: (2017b) has stated that up to 30 past time steps are needed to form a state that can hope to recover the true dynamics, so the state can be considered 180 dimensional.

Original: In our case we thus set the number of history steps G = 30 .
Revised: In our case we thus set the number of history steps G = 30 .

Original: The action space is 3 dimensional.
Revised: The action space is 3 dimensional.

Original: The benchmark is not supposed to mimic a single industrial application, but rather exhibit common issues observable in many different applications (partial observability, delayed rewards, multimodal and heteroskedastic noise, ...).
Revised: The benchmark is not supposed to mimic a single industrial application, but rather exhibit common issues observable in many different applications (partial observability, delayed rewards, multimodal and heteroskedastic noise, ...).

Original: The reward is a weighted combination of the observable variables fatigue and consumption, which are conflicting (usually move in opposite directions and need trade-off) and are influenced by various unobservable variables.
Revised: The reward is a weighted combination of the observable variables fatigue and consumption, which are conflicting (usually move in opposite directions and need trade-off) and are influenced by various unobservable variables.

Original: As in prior work
Revised: As in prior work

Original: Hein et al.
Revised: Hein et al.

Original: ; Depeweg et al. (2016); Swazinna et al.
Revised: ; Depeweg et al. (2016); Swazinna et al.

Original: (2021b)
Revised: (2021b)

Original: we optimize for a horizon of 100.
Revised: we optimize for a horizon of 100.

Original: The datasets are available at https://github.com/siemens/industrialbenchmark/ tree/offline_datasets/datasets under the Apache License 2.0.
Revised: The datasets are available at https://github.com/siemens/industrialbenchmark/ tree/offline_datasets/datasets under the Apache License 2.0.

Original: [Figure]
Revised: [Figure]

Original: of the art baselines are added as dashed lines with their standard set of hyperparameters (results from (Swazinna et al., 2022)).
Revised: of the art baselines are added as dashed lines with their standard set of hyperparameters (results from (Swazinna et al., 2022)).

Original: Even though the baselines all exhibit some hyperparameter that controls the distance to the original policy, all are implemented differently and we can neither map them to a corresponding lambda value of our algorithm, nor change the behavior at runtime, which is why we display them as dashed lines over the entire λ -spectrum.
Revised: Even though the baselines all exhibit some hyperparameter that controls the distance to the original policy, all are implemented differently and we can neither map them to a corresponding lambda value of our algorithm, nor change the behavior at runtime, which is why we display them as dashed lines over the entire λ -spectrum.

Original: See Fig.
Revised: See Fig.

Original: 12 for the 100% exploration dataset.
Revised: 12 for the 100% exploration dataset.

Original: Baselines We compare performances of LION with various state of the art offline RL baselines:
Revised: Baselines We compare performances of LION with various state of the art offline RL baselines:

Original: • BEAR, BRAC, BCQ, CQL and TD3+BC (Kumar et al., 2019; Wu et al., 2019; Fujimoto et al., 2019; Kumar et al., 2020; Fujimoto & Gu, 2021) are model-free algorithms.
Revised: • BEAR, BRAC, BCQ, CQL and TD3+BC (Kumar et al., 2019; Wu et al., 2019; Fujimoto et al., 2019; Kumar et al., 2020; Fujimoto & Gu, 2021) are model-free algorithms.

Original: They mostly regularize the policy by minimizing a divergence to the original policy.
Revised: They mostly regularize the policy by minimizing a divergence to the original policy.

Original: BCQ samples only likely actions and CQL searches for a Q-function that lower bounds the true one.
Revised: BCQ samples only likely actions and CQL searches for a Q-function that lower bounds the true one.

Original: • MOOSE and WSBC (Swazinna et al., 2021a;b) are purely model based algorithms that optimize the policy via virtual trajectories through the learned transition model.
Revised: • MOOSE and WSBC (Swazinna et al., 2021a;b) are purely model based algorithms that optimize the policy via virtual trajectories through the learned transition model.

Original: MOOSE penalizes reconstruction loss of actions under the original policy (learned by an autoencoder), while WSBC constrains the policy directly in weight space.
Revised: MOOSE penalizes reconstruction loss of actions under the original policy (learned by an autoencoder), while WSBC constrains the policy directly in weight space.

Original: MOOSE is from the policy training perspective the closest to our LION approach.
Revised: MOOSE is from the policy training perspective the closest to our LION approach.

Original: • MOPO and MOReL (Yu et al., 2020; Kidambi et al., 2020) are hybrid methods that learn a transition model as well as a value function.
Revised: • MOPO and MOReL (Yu et al., 2020; Kidambi et al., 2020) are hybrid methods that learn a transition model as well as a value function.

Original: Both use the models to collect additional data and regularize the policy by means of model uncertainty.
Revised: Both use the models to collect additional data and regularize the policy by means of model uncertainty.

Original: MOPO penalizes uncertainty directly, while MOReL simply stops episodes in which future states become too unreliable.
Revised: MOPO penalizes uncertainty directly, while MOReL simply stops episodes in which future states become too unreliable.

Original: MOReL uses model-disagreement and MOPO Gaussian outputs to quantify uncertainty.
Revised: MOReL uses model-disagreement and MOPO Gaussian outputs to quantify uncertainty.

Original: Evaluation In order to test whether the trained LION policies are able to provide state of the art performance anywhere in the λ range, we evaluate them for λ from 0 to 1 in many small steps.
Revised: Evaluation In order to test whether the trained LION policies are able to provide state of the art performance anywhere in the λ range, we evaluate them for λ from 0 to 1 in many small steps.

Original: Figs.
Revised: Figs.

Original: 4 and 12 show results for the 16 IB datasets.
Revised: 4 and 12 show results for the 16 IB datasets.

Original: We find that the performance curves do not exhibit many local optima.
Revised: We find that the performance curves do not exhibit many local optima.

Original: Rather, there is usually a single maximum before which the performance is rising and after which the performance is strictly dropping.
Revised: Rather, there is usually a single maximum before which the performance is rising and after which the performance is strictly dropping.

Original: This is a very desirable characteristic for usage in the user interactive setting, as it enables users to easily find the best performing λ value for the policy.
Revised: This is a very desirable characteristic for usage in the user interactive setting, as it enables users to easily find the best performing λ value for the policy.

Original: In 13 out of 16 datasets, users can thus match or outperform the current state of the art method on that dataset, and achieve close to on-par performance on the remaining three.
Revised: In 13 out of 16 datasets, users can thus match or outperform the current state of the art method on that dataset, and achieve close to on-par performance on the remaining three.

Original: The distance-to-original-policy curves are even monotonously increasing from start to finish, making it possible for the practitioner to find the best solution he or she is still comfortable with in terms of distance to the familiar behavior.
Revised: The distance-to-original-policy curves are even monotonously increasing from start to finish, making it possible for the practitioner to find the best solution he or she is still comfortable with in terms of distance to the familiar behavior.

Original: Discrete baseline
Revised: Discrete baseline

Original: A simpler approach might be to train an existing offline RL algorithm for many trade-offs in advance, to provide at least discrete options.
Revised: A simpler approach might be to train an existing offline RL algorithm for many trade-offs in advance, to provide at least discrete options.

Original: Two downsides are obvious: (a) we wouldn’t be able to handle the continuous case, i.e. when a user wants a trade-off that lies between two discrete policies, and (b) the computational cost increases linearly with the number of policies trained.
Revised: Two downsides are obvious: (a) we wouldn’t be able to handle the continuous case, i.e. when a user wants a trade-off that lies between two discrete policies, and (b) the computational cost increases linearly with the number of policies trained.

Original: We show that a potentially even bigger issue exists in Figure 5: When we train a discrete collection of policies with different hyperparameters, completely independently of each other, they often exhibit wildly different behaviors even when the change in hyperparameter was small.
Revised: We show that a potentially even bigger issue exists in Figure 5: When we train a discrete collection of policies with different hyperparameters, completely independently of each other, they often exhibit wildly different behaviors even when the change in hyperparameter was small.

Original: LION instead expresses the collection as a single policy network, training them jointly and thus forcing them to smoothly interpolate among each other.
Revised: LION instead expresses the collection as a single policy network, training them jointly and thus forcing them to smoothly interpolate among each other.

Original: This helps to make the performance a smooth function of the hyperparameter (although this must not always be the case) and results in a performance landscape that is much easier to navigate for a user searching for a good trade-off.
Revised: This helps to make the performance a smooth function of the hyperparameter (although this must not always be the case) and results in a performance landscape that is much easier to navigate for a user searching for a good trade-off.

Original: [Figure]
Revised: [Figure]

Original: o n R e t u r n
Revised: o n R e t u r n

Original: [Figure]
Revised: [Figure]

Original: Return conditioning baseline
Revised: Return conditioning baseline

Original: Another interesting line of work trains policies conditional on the return to go, such as RvS (Emmons et al., 2021)
Revised: Another interesting line of work trains policies conditional on the return to go, such as RvS (Emmons et al., 2021)

Original: (Reinforcement Learning via Supervised Learning) or
Revised: (Reinforcement Learning via Supervised Learning) or

Original: DT (Chen et al., 2021)
Revised: DT (Chen et al., 2021)

Original: (Decision Transformer).
Revised: (Decision Transformer).

Original: A key advantage of these methods is their simplicitythey require neither transition model nor value function, just a policy suffices, and the learning can be performed in an entirely supervised fashion.
Revised: A key advantage of these methods is their simplicitythey require neither transition model nor value function, just a policy suffices, and the learning can be performed in an entirely supervised fashion.

Original: The resulting policies could be interpreted in a similar way as LION policies: Conditioning on returns close to the original performance would result in the original behavior, while choosing to condition on higher returns may lead to improved performance if the extrapolation works well.
Revised: The resulting policies could be interpreted in a similar way as LION policies: Conditioning on returns close to the original performance would result in the original behavior, while choosing to condition on higher returns may lead to improved performance if the extrapolation works well.

Original: In Fig.
Revised: In Fig.

Original: 6 we report results of the RvS algorithm on the same datasets as the discrete baseline.
Revised: 6 we report results of the RvS algorithm on the same datasets as the discrete baseline.

Original: The returns in the datasets do not exhibit a lot of variance, so it is unsurprising that the approach did not succeed in learning a lot of different behaviors.
Revised: The returns in the datasets do not exhibit a lot of variance, so it is unsurprising that the approach did not succeed in learning a lot of different behaviors.

Original: [Figure]
Revised: [Figure]

Original: a l u a t i o n
Revised: a l u a t i o n

Original: [Figure]
Revised: [Figure]

Original: t
Revised: t

Original: [Figure]
Revised: [Figure]

Original: r n
Revised: r n

Original: [Figure]
Revised: [Figure]

Original: Finding a suitable λ
Revised: Finding a suitable λ

Original: We would like to emphasize that we neither want to optimize all offline hyperparameters with our solution, nor are we interested in a fully automated solution.
Revised: We would like to emphasize that we neither want to optimize all offline hyperparameters with our solution, nor are we interested in a fully automated solution.

Original: Users may thus adopt arbitrary strategies to finding their personal trade-off of preference.
Revised: Users may thus adopt arbitrary strategies to finding their personal trade-off of preference.

Original: We will however provide a conservative example strategy:
Revised: We will however provide a conservative example strategy:

Original: The operator starts with the most conservative value available and then moves in small, but constant steps towards more freedom.
Revised: The operator starts with the most conservative value available and then moves in small, but constant steps towards more freedom.

Original: Whenever the performance drops below the previous best or the baseline performance, he immediately stops and uses the last λ before that.
Revised: Whenever the performance drops below the previous best or the baseline performance, he immediately stops and uses the last λ before that.

Original: Table 1 summarizes how this strategy would perform.
Revised: Table 1 summarizes how this strategy would perform.

Original: [Table]
Revised: [Table]

Original:  D ISCUSSION & C ONCLUSION
Revised:  D ISCUSSION & C ONCLUSION

Original: In this work we presented a novel offline RL approach that, to the best of our knowledge, is the first to let the user adapt the policy behavior after training is finished.
Revised: In this work we presented a novel offline RL approach that, to the best of our knowledge, is the first to let the user adapt the policy behavior after training is finished.

Original: We let the user tune the behavior by allowing him to choose the desired proximity to the original policy, in an attempt to solve two issues: (1) The problem that practitioners cannot tune the hyperparameter in offline RL & (2) the general issue that users have no high level control option when using RL policies (they might even have individual preferences with regards to the behavior of a policy that go beyond just performance).
Revised: We let the user tune the behavior by allowing him to choose the desired proximity to the original policy, in an attempt to solve two issues: (1) The problem that practitioners cannot tune the hyperparameter in offline RL & (2) the general issue that users have no high level control option when using RL policies (they might even have individual preferences with regards to the behavior of a policy that go beyond just performance).

Original: We find that effectively, LION provides a high level control option to the user, while still profiting from a high level of automation.
Revised: We find that effectively, LION provides a high level control option to the user, while still profiting from a high level of automation.

Original: It furthermore takes much of the risk that users normally assume in offline RL away since deployments can always start with a BC policy when they start at λ = 0 , before moving to better options.
Revised: It furthermore takes much of the risk that users normally assume in offline RL away since deployments can always start with a BC policy when they start at λ = 0 , before moving to better options.

Original: While behavior cloning does not have to work in general, we did not experience any issues with it in our experiments, and it should be easier than performing RL since it can be done entirely in a supervised fashion.
Revised: While behavior cloning does not have to work in general, we did not experience any issues with it in our experiments, and it should be easier than performing RL since it can be done entirely in a supervised fashion.

Original: Given that BC works, deployments can thus start with minimal risk.
Revised: Given that BC works, deployments can thus start with minimal risk.

Original: In prior offline algorithms, users experienced the risk that the algorithm did not produce a satisfying policy on the particular dataset they chose.
Revised: In prior offline algorithms, users experienced the risk that the algorithm did not produce a satisfying policy on the particular dataset they chose.

Original: E.g.: WSBC produces state of the art results for many of the IB datasets, however for mediocre-0.6 it produces a catastrophic - (original performance is -75).
Revised: E.g.: WSBC produces state of the art results for many of the IB datasets, however for mediocre-0.6 it produces a catastrophic - (original performance is -75).

Original: Similarly, CQL is the prior best method on optimized-0.8, however the same method produces a performance of -292 on bad-0.2 (MOOSE, MOPO, and WSBC get between -110 & -130).
Revised: Similarly, CQL is the prior best method on optimized-0.8, however the same method produces a performance of -292 on bad-0.2 (MOOSE, MOPO, and WSBC get between -110 & -130).

Original: Due to the smoothness of the interpolation of behaviors in LION, practitioners should be able to use it to find better trade-offs with lower risk than prior methods.
Revised: Due to the smoothness of the interpolation of behaviors in LION, practitioners should be able to use it to find better trade-offs with lower risk than prior methods.

Original: Adaptable policies are thus likely a step towards more deployments in industrial applications.
Revised: Adaptable policies are thus likely a step towards more deployments in industrial applications.

Original: Future Work As outlined at the end of section C of the appendix, we were unable to incorporate value functions into our approach.
Revised: Future Work As outlined at the end of section C of the appendix, we were unable to incorporate value functions into our approach.

Original: This can be seen as a limiting factor, since there exist environments with sparse or very delayed rewards or that for other reasons exhibit long planning horizons.
Revised: This can be seen as a limiting factor, since there exist environments with sparse or very delayed rewards or that for other reasons exhibit long planning horizons.

Original: The industrial benchmark features delayed rewards and evaluation trajectories are 100 steps long, however other environments can be more extreme in their characteristics.
Revised: The industrial benchmark features delayed rewards and evaluation trajectories are 100 steps long, however other environments can be more extreme in their characteristics.

Original: At some point, even the best dynamics models suffer from compounding errors and cannot accurately predict the far away future.
Revised: At some point, even the best dynamics models suffer from compounding errors and cannot accurately predict the far away future.

Original: We do not believe that it is in principle not possible to combine the LION approach with value functions, however future work will likely need to find methods to stabilize the learning process.
Revised: We do not believe that it is in principle not possible to combine the LION approach with value functions, however future work will likely need to find methods to stabilize the learning process.

Original: Other potential limitations of our approach include difficulties with the behavior cloning, e.g. when the original policy is stochastic or was not defined in the same state space as we use (e.g. different human operators controlled the system at different times in the dataset), as well as difficulties when interpolating between vastly different behaviors on the pareto front spanned by proximity and performance.
Revised: Other potential limitations of our approach include difficulties with the behavior cloning, e.g. when the original policy is stochastic or was not defined in the same state space as we use (e.g. different human operators controlled the system at different times in the dataset), as well as difficulties when interpolating between vastly different behaviors on the pareto front spanned by proximity and performance.

Original: We mention these potential limitations only for the sake of completeness since we were unable to observe them in our practical experiments.
Revised: We mention these potential limitations only for the sake of completeness since we were unable to observe them in our practical experiments.

Original:  E THICS S TATEMENT
Revised:  E THICS S TATEMENT

Original: Generally, (offline) reinforcement learning methods can be used to optimize control policies for many different systems beyond the control of the researchers.
Revised: Generally, (offline) reinforcement learning methods can be used to optimize control policies for many different systems beyond the control of the researchers.

Original: Malicious individuals may thus use findings in manners that negatively impact others or society as a whole (e g. by using it in weapons).
Revised: Malicious individuals may thus use findings in manners that negatively impact others or society as a whole (e g. by using it in weapons).

Original: Faulty policies could also potentially result in other safety concerns (e g. policies for heavy machinery).
Revised: Faulty policies could also potentially result in other safety concerns (e g. policies for heavy machinery).

Original: In ML research, there is also always the concern that increased automation may lead to rising unemployment.
Revised: In ML research, there is also always the concern that increased automation may lead to rising unemployment.

Original: While some institutions like the UN and the WEF are convinced AI will lead to long term job growth, Bordot (2022) found that a slightly increased unemployment risk can be found empirically.
Revised: While some institutions like the UN and the WEF are convinced AI will lead to long term job growth, Bordot (2022) found that a slightly increased unemployment risk can be found empirically.

Original: Beyond these usual concerns that mostly apply to ML/RL research as a whole, rather than our individual paper, we believe that no additional considerations are necessary for our method.
Revised: Beyond these usual concerns that mostly apply to ML/RL research as a whole, rather than our individual paper, we believe that no additional considerations are necessary for our method.

Original: If at all, the societal impact should be positive, since our solution fosters trust by practitioners and should thus increase the usage and human-machine collaborative deployment of offline RL policies in practice, enabling more efficient control strategies in many industrial domains
Revised: If at all, the societal impact should be positive, since our solution fosters trust by practitioners and should thus increase the usage and human-machine collaborative deployment of offline RL policies in practice, enabling more efficient control strategies in many industrial domains

Original: A PPENDIX A O THER H YPERPARAMETERS
Revised: A PPENDIX A O THER H YPERPARAMETERS

Original: Similarly to other methods, we introduce a set of hyperparameters in our method either explicitly or implicitly.
Revised: Similarly to other methods, we introduce a set of hyperparameters in our method either explicitly or implicitly.

Original: Any hyperparameter that is involved in training the original policy model β ϕ or the transition dynamics models { f ψ i } can obviously be tuned offline, by holding out a validation set of transitions from the original dataset and evaluating the trained models on them to test how well they predict dataset actions or future states and rewards.
Revised: Any hyperparameter that is involved in training the original policy model β ϕ or the transition dynamics models { f ψ i } can obviously be tuned offline, by holding out a validation set of transitions from the original dataset and evaluating the trained models on them to test how well they predict dataset actions or future states and rewards.

Original: This is true for example for the architecture of the transition models, their learning rate, or the number of epochs to train.
Revised: This is true for example for the architecture of the transition models, their learning rate, or the number of epochs to train.

Original: When we train the policy in offline reinforcement learning however, the equivalent of an evaluation dataset does not exist, since we cannot evaluate the policy on the true environment dynamics.
Revised: When we train the policy in offline reinforcement learning however, the equivalent of an evaluation dataset does not exist, since we cannot evaluate the policy on the true environment dynamics.

Original: While efforts are being made to make hyperparameter tuning possible via offline policy evaluation, the problem is hard for obvious reasons and we cannot really rely on them yet.
Revised: While efforts are being made to make hyperparameter tuning possible via offline policy evaluation, the problem is hard for obvious reasons and we cannot really rely on them yet.

Original: Especially the arguably most important hyperparameter, how closely the newly trained policy needs to follow the actions proposed by the original policy, cannot realistically be tuned since it involves knowing when the evaluation method itself cannot be trusted any more.
Revised: Especially the arguably most important hyperparameter, how closely the newly trained policy needs to follow the actions proposed by the original policy, cannot realistically be tuned since it involves knowing when the evaluation method itself cannot be trusted any more.

Original: This is precisely why we propose the selection of this hyperparameter at runtime via user interaction.
Revised: This is precisely why we propose the selection of this hyperparameter at runtime via user interaction.

Original: Our method however introduces some hyperparameters that are used during policy training and that could thus be seen as critical hyperparameters that cannot be tuned:
Revised: Our method however introduces some hyperparameters that are used during policy training and that could thus be seen as critical hyperparameters that cannot be tuned:

Original: η , controlling the penalty magnitude for not following the dataset actions at λ = 0 , and the parameters of the Beta distribution from which λ is sampled during training.
Revised: η , controlling the penalty magnitude for not following the dataset actions at λ = 0 , and the parameters of the Beta distribution from which λ is sampled during training.

Original: We did not tune them, since we simply copied the parameters from (Seo et al., 2021) so that λ ∼ Beta(0 . 1 , 0 . 1) and also set η = 0 .
Revised: We did not tune them, since we simply copied the parameters from (Seo et al., 2021) so that λ ∼ Beta(0 . 1 , 0 . 1) and also set η = 0 .

Original: 1 without any experiments.
Revised: 1 without any experiments.

Original: We would however like to point out, that these parameters are at least partially tunable even in the offline setting, since they do not depend on the accuracy of the transition models: η controls how strongly one adheres to the actions of the dataset, and we can easily asses whether this is working properly, by evaluating whether the final trained policy still adheres to the actions of the dataset at λ = 0 .
Revised: We would however like to point out, that these parameters are at least partially tunable even in the offline setting, since they do not depend on the accuracy of the transition models: η controls how strongly one adheres to the actions of the dataset, and we can easily asses whether this is working properly, by evaluating whether the final trained policy still adheres to the actions of the dataset at λ = 0 .

Original: We evaluated policies for different η in Figure 7 (a) and show that there is not a great difference between different η , as long as it is not zero, so it seems reasonable to choose something small that is still doing the trick.
Revised: We evaluated policies for different η in Figure 7 (a) and show that there is not a great difference between different η , as long as it is not zero, so it seems reasonable to choose something small that is still doing the trick.

Original: Similarly, we show an evaluation for different parameters of the beta distribution in Fig.
Revised: Similarly, we show an evaluation for different parameters of the beta distribution in Fig.

Original: 7 (b).
Revised: 7 (b).

Original: The parameters control how often which parts of the λ -spectrum are seen during training (see Fig. 11).
Revised: The parameters control how often which parts of the λ -spectrum are seen during training (see Fig. 11).

Original: As can be seen, the more the distribution tends towards a uniform distribution, the more the policy deviates from the original policy model at λ = 0 , which is undesired.
Revised: As can be seen, the more the distribution tends towards a uniform distribution, the more the policy deviates from the original policy model at λ = 0 , which is undesired.

Original: When more probability mass is focused on the edges of the distribution, we can see that the original policy model is reproduced more accurately.
Revised: When more probability mass is focused on the edges of the distribution, we can see that the original policy model is reproduced more accurately.

Original: Both η and β can thus be reasonably well tuned entirely offline, even without using the transition models.
Revised: Both η and β can thus be reasonably well tuned entirely offline, even without using the transition models.

Original: [Figure]
Revised: [Figure]

Original: B C OMPLETE P OLICY V ISUALIZATION IN 2D-E NV
Revised: B C OMPLETE P OLICY V ISUALIZATION IN 2D-E NV

Original: In Fig.
Revised: In Fig.

Original: 3, we chose only a set of interesting λ values for visualization for page limit reasons.
Revised: 3, we chose only a set of interesting λ values for visualization for page limit reasons.

Original: See Fig 8 for a more fine-grained evaluation.
Revised: See Fig 8 for a more fine-grained evaluation.

Original: Policymap - =0. Policymap - =0.
Revised: Policymap - =0. Policymap - =0.

Original: Policymap - =0. Policymap - =0.
Revised: Policymap - =0. Policymap - =0.

Original: Policymap - =0. Policymap - =0.
Revised: Policymap - =0. Policymap - =0.

Original: Policymap - =0. Policymap - =0.
Revised: Policymap - =0. Policymap - =0.

Original: Policymap - =0. Policymap - =0.
Revised: Policymap - =0. Policymap - =0.

Original: Policymap - =0. Policymap - =0.
Revised: Policymap - =0. Policymap - =0.

Original: Policymap - =0. Policymap - =0.
Revised: Policymap - =0. Policymap - =0.

Original: Policymap - =0. Policymap - =0.
Revised: Policymap - =0. Policymap - =0.

Original: Policymap - =0. Policymap - =0.
Revised: Policymap - =0. Policymap - =0.

Original: Policymap - =0. Policymap - =0.
Revised: Policymap - =0. Policymap - =0.

Original: Policymap - =1.
Revised: Policymap - =1.

Original: a n g l e t o ( 1 , 0 ) 0. a n g l e t o ( 1 , 0 ) 0.
Revised: a n g l e t o ( 1 , 0 ) 0. a n g l e t o ( 1 , 0 ) 0.

Original: a n g l e t o ( 1 , 0 )
Revised: a n g l e t o ( 1 , 0 )

Original: C M ODEL - FREE EXPERIMENTS
Revised: C M ODEL - FREE EXPERIMENTS

Original: [Figure]
Revised: [Figure]

Original: Model-free
Revised: Model-free

Original: We motivate our purely model-based implementation with the idea that it should be simpler to implement compared to model-free policy training.
Revised: We motivate our purely model-based implementation with the idea that it should be simpler to implement compared to model-free policy training.

Original: When learning a policy with a value function, we have always two models that are trained jointly - the policy and the Q-function interact with each other and both are essentially a moving target.
Revised: When learning a policy with a value function, we have always two models that are trained jointly - the policy and the Q-function interact with each other and both are essentially a moving target.

Original: While it should be possible to derive a similar algorithm as LION in the model-free world, we were not quite able to do so: Figs.
Revised: While it should be possible to derive a similar algorithm as LION in the model-free world, we were not quite able to do so: Figs.

Original: 9 and 10 show experiments in which we augment TD3+BC with our approach by sampling λ from the same distribution as in LION and providing it to the policy, only that now it controls the influence the value function has on the optimization of the policy and (1- λ ) controls the distance to the behavior actions.
Revised: 9 and 10 show experiments in which we augment TD3+BC with our approach by sampling λ from the same distribution as in LION and providing it to the policy, only that now it controls the influence the value function has on the optimization of the policy and (1- λ ) controls the distance to the behavior actions.

Original: Interestingly however, the trained policy is unable to alter its behavior anywhere in the λ -range.
Revised: Interestingly however, the trained policy is unable to alter its behavior anywhere in the λ -range.

Original: Instead it seems that the policy training is rather unstable and the policy collapses to a solution that behaves always the same, regardless of λ .
Revised: Instead it seems that the policy training is rather unstable and the policy collapses to a solution that behaves always the same, regardless of λ .

Original: Similarly, the distance to the original policy does not change with varying λ .
Revised: Similarly, the distance to the original policy does not change with varying λ .

Original: We chose TD3+BC due to its simplicity - it exhibits fewer trained models and implementational pitfalls than others.
Revised: We chose TD3+BC due to its simplicity - it exhibits fewer trained models and implementational pitfalls than others.

Original: The original Q-function and policy optimization objectives in TD3+BC are:
Revised: The original Q-function and policy optimization objectives in TD3+BC are:

Original: [Equation]
Revised: [Equation]

Original: where Q t denotes the slow moving target Q-function used for computing the Q-targets.
Revised: where Q t denotes the slow moving target Q-function used for computing the Q-targets.

Original: And:
Revised: And:

Original: [Equation]
Revised: [Equation]

Original: In our extension, denoted by λ -TD3+BC, we provide the sampled λ to the policy and use it to balance the two optimization terms, similarly to our LION approach.
Revised: In our extension, denoted by λ -TD3+BC, we provide the sampled λ to the policy and use it to balance the two optimization terms, similarly to our LION approach.

Original: The new objectives are:
Revised: The new objectives are:

Original: [Equation]
Revised: [Equation]

Original: and:
Revised: and:

Original: [Equation]
Revised: [Equation]

Original: We show complete experiments for all of the IB datasets in Figs.
Revised: We show complete experiments for all of the IB datasets in Figs.

Original: As already mentioned in section C, we are unable to observe that the policy is able to alter its behavior anywhere in the λ -range.
Revised: As already mentioned in section C, we are unable to observe that the policy is able to alter its behavior anywhere in the λ -range.

Original: We hypothesize that methods for stabilizing the Q-function are needed in order for the policy to not collapse
Revised: We hypothesize that methods for stabilizing the Q-function are needed in order for the policy to not collapse

Original: [Figure]
Revised: [Figure]

Original: D S AMPLING λ
Revised: D S AMPLING λ

Original: [Figure]
Revised: [Figure]

Original: As mentioned, we do not sample λ uniformly since doing so leads to less accurate learning at the edges of the λ -spectrum.
Revised: As mentioned, we do not sample λ uniformly since doing so leads to less accurate learning at the edges of the λ -spectrum.

Original: In Fig 11, we show visualizations of different symmetric Beta distributions from which we draw λ together with the policy results on the bad-0.2 dataset.
Revised: In Fig 11, we show visualizations of different symmetric Beta distributions from which we draw λ together with the policy results on the bad-0.2 dataset.

Original: The Beta(1, 1) case corresponds to the uniform distribution and has a significant discrepancy at the λ = 0 end of the range:
Revised: The Beta(1, 1) case corresponds to the uniform distribution and has a significant discrepancy at the λ = 0 end of the range:

Original: The original policy (its performance) is not accurately reproduced.
Revised: The original policy (its performance) is not accurately reproduced.

Original: Generally, it seems the flatter the distribution becomes, the more are the two extreme cases moved together.
Revised: Generally, it seems the flatter the distribution becomes, the more are the two extreme cases moved together.

Original: We observe this phenomenon even though the policy has plenty of capacity and even in the simple 2D environment.
Revised: We observe this phenomenon even though the policy has plenty of capacity and even in the simple 2D environment.

Original: E E XPERIMENTAL D ETAILS
Revised: E E XPERIMENTAL D ETAILS

Original: [Figure]
Revised: [Figure]

Original: as presented in Fig.for the 100% exploration dataset.
Revised: as presented in Fig.for the 100% exploration dataset.

Original: We conducted experiments on a system with a Xeon Gold 5122 CPU ( 4 × 3 .
Revised: We conducted experiments on a system with a Xeon Gold 5122 CPU ( 4 × 3 .

Original: 6 GHz, no GPU support used).
Revised: 6 GHz, no GPU support used).

Original: A single policy training took about 45 minutes, a single dynamics model about 2 hours.
Revised: A single policy training took about 45 minutes, a single dynamics model about 2 hours.

Original: We train dynamics models using a 90/10 random data split and select the best models according to their validation performance.
Revised: We train dynamics models using a 90/10 random data split and select the best models according to their validation performance.

Original: The final ensemble contains four models.
Revised: The final ensemble contains four models.

Original: The recurrent models for the industrial benchmark have an RNN cell with size 30 and an output layer mapping from the cell state to the state space.
Revised: The recurrent models for the industrial benchmark have an RNN cell with size 30 and an output layer mapping from the cell state to the state space.

Original: We use G = 30 history steps to build up the hidden state of the RNN and then predict F = 50 steps into the future.
Revised: We use G = 30 history steps to build up the hidden state of the RNN and then predict F = 50 steps into the future.

Original: The feedforward models of the 2D env have two layers of size 20 & 10.
Revised: The feedforward models of the 2D env have two layers of size 20 & 10.

Original: We use adam (Kingma & Ba, 2014) with standard parameters and an exponentially decaying learning rate with factor 0 .
Revised: We use adam (Kingma & Ba, 2014) with standard parameters and an exponentially decaying learning rate with factor 0 .

Original: 99 and train for up to 3000 epochs.
Revised: 99 and train for up to 3000 epochs.

Original: The models of the original policy have a single hidden layer of size 30 and the final policies have two layers of size 1024.
Revised: The models of the original policy have a single hidden layer of size 30 and the final policies have two layers of size 1024.

Original: We use ReLU nonlinearities throughout all experiments.
Revised: We use ReLU nonlinearities throughout all experiments.

Original: During policy and original policy model training we use the entire dataset instead of just the 90% split from the dynamics training.
Revised: During policy and original policy model training we use the entire dataset instead of just the 90% split from the dynamics training.

Original: We use a discount factor of γ = 0 . 97 and perform rollouts of length H = 100 to train and evaluate the policy.
Revised: We use a discount factor of γ = 0 . 97 and perform rollouts of length H = 100 to train and evaluate the policy.

Original: F H YPERPARAMETERS OF THE T RANSITION E NSEMBLE
Revised: F H YPERPARAMETERS OF THE T RANSITION E NSEMBLE

Original: Instead of using the minimum over the predicted rewards during rollouts, one might as well use other forms of aggregation, like the mean.
Revised: Instead of using the minimum over the predicted rewards during rollouts, one might as well use other forms of aggregation, like the mean.

Original: In Fig.
Revised: In Fig.

Original: 14 we show results for such mean reward experimentsthe future state was then randomly selected among the predictions of the transition ensemble.
Revised: 14 we show results for such mean reward experimentsthe future state was then randomly selected among the predictions of the transition ensemble.

Original: The resulting performance curves look similar as those in 4, except that in the mediocre and the optimized setting, the performance decrease on the λ = 1 end is even steeper than with the minimum reward prediction.
Revised: The resulting performance curves look similar as those in 4, except that in the mediocre and the optimized setting, the performance decrease on the λ = 1 end is even steeper than with the minimum reward prediction.

Original: This makes intuitively sense, since the mean is much easier exploited than the minimum
Revised: This makes intuitively sense, since the mean is much easier exploited than the minimum

Original: [Figure]
Revised: [Figure]

Original: Similar effects can be observed when the number of ensemble members is reduced.
Revised: Similar effects can be observed when the number of ensemble members is reduced.

Original: In Fig.
Revised: In Fig.

Original: A, we show results on the same datasets when only a single model instead of an ensemble with four members is used (thus mean and min become the same).
Revised: A, we show results on the same datasets when only a single model instead of an ensemble with four members is used (thus mean and min become the same).

Original: Here, the performance drops even earlier as well as stronger in the mediocre and optimized settings.
Revised: Here, the performance drops even earlier as well as stronger in the mediocre and optimized settings.

Original: [Figure]
Revised: [Figure]

Original: t u r n d i s t . t o o r g .
Revised: BCQ TD

Original: [Figure]
Revised: [Figure]

Revised: BC

Revised: CQL

Revised: MOPO

Original: G P RELIMINARIES ON O FFLINE RL
Revised: G P RELIMINARIES ON O FFLINE RL

Original: In offline reinforcement learning , we are trying to optimize the sum of discounted rewards, called return, R = (cid:80) t γ t r t obtained by acting in the MDP M = <
Revised: In offline reinforcement learning , we are trying to optimize the sum of discounted rewards, called return, R = (cid:80) t γ t r t obtained by acting in the MDP M = <

Original: S, A, R, T, γ, s 0 > , where S is the set of states, s 0 ⊆ S the set of starting states, A the set of actions, R : S ×
Revised: S, A, R, T, γ, s 0 > , where S is the set of states, s 0 ⊆ S the set of starting states, A the set of actions, R : S ×

Original: A → R the reward function, T : S ×
Revised: A → R the reward function, T : S ×

Original: A → S the transition dynamics function, and γ ∈ [0 , 1) the discount factor.
Revised: A → S the transition dynamics function, and γ ∈ [0 , 1) the discount factor.

Original: We train a policy π θ : S
Revised: We train a policy π θ : S

Original: → A to obtain an action a when in state s , in order to produce trajectories of length H : τ = ( s 0 , a 0 , r 0 , s 1 , a 1 , r 1 , . .
Revised: → A to obtain an action a when in state s , in order to produce trajectories of length H : τ = ( s 0 , a 0 , r 0 , s 1 , a 1 , r 1 , . .

Original: , s H , a H , r H ) .
Revised: , s H , a H , r H ) .

Original: While online RL methods are able to continuously explore their environment, collect new data and test new behaviors, offline RL methods need to optimize the return R by learning only from a fixed dataset of interactions D
Revised: While online RL methods are able to continuously explore their environment, collect new data and test new behaviors, offline RL methods need to optimize the return R by learning only from a fixed dataset of interactions D

Original: = { τ i } , i = 1 , ..., K .
Revised: = { τ i } , i = 1 , ..., K .

Original: Often, this is done by solving the approximate MDP ˆ M = <
Revised: Often, this is done by solving the approximate MDP ˆ M = <

Original: S, A, R, T D , γ, s 0 > , where T D is directly estimated with a transition model using the transitions from D .
Revised: S, A, R, T D , γ, s 0 > , where T D is directly estimated with a transition model using the transitions from D .

Original: However, also model-free offline approaches exist, that do not estimate T D and directly try to optimize a policy with a value function that is only trained on D .
Revised: However, also model-free offline approaches exist, that do not estimate T D and directly try to optimize a policy with a value function that is only trained on D .

Original: Since neither model-free nor model-based variants can be sure to accurately assess the policy’s performance in unknown parts of the state-action space, offline RL algorithms regularize their policy to stay in a way ’close’ to the policy that generated the data.
Revised: Since neither model-free nor model-based variants can be sure to accurately assess the policy’s performance in unknown parts of the state-action space, offline RL algorithms regularize their policy to stay in a way ’close’ to the policy that generated the data.

Original: The crucial question - how close should π θ be to the original policy? - is an open problem.
Revised: The crucial question - how close should π θ be to the original policy? - is an open problem.

Original: We address the dilemma that the user has no meaningful way of choosing the correct proximity since offline policy selection / evaluation remain generally unsolved problems.
Revised: We address the dilemma that the user has no meaningful way of choosing the correct proximity since offline policy selection / evaluation remain generally unsolved problems.