Conservative Data Sharing for Multi-Task Offline Reinforcement Learning

Offline reinforcement learning (RL) algorithms have shown promising results in domains where abundant pre-collected data is available. However, prior methods focus on solving individual problems from scratch with an offline dataset without considering how an offline RL agent can acquire multiple skills. We argue that a natural use case of offline RL is in settings where we can pool large amounts of data collected in various scenarios for solving different tasks, and utilize all of this data to learn behaviors for all the tasks more effectively rather than training each one in isolation. However, sharing data across all tasks in multi-task offline RL performs surprisingly poorly in practice. Thorough empirical analysis, we find that sharing data can actually exacerbate the distributional shift between the learned policy and the dataset, which in turn can lead to divergence of the learned policy and poor performance. To address this challenge, we develop a simple technique for data-sharing in multi-task offline RL that routes data based on the improvement over the task-specific data. We call this approach conservative data sharing (CDS), and it can be applied with multiple single-task offline RL methods. On a range of challenging multi-task locomotion, navigation, and vision-based robotic manipulation problems, CDS achieves the best or comparable performance compared to prior offline multi-task RL methods and previous data sharing approaches.


Introduction
Recent advances in offline reinforcement learning (RL) make it possible to train policies for real-world scenarios, such as robotics [32,60,33] and healthcare [24,67,35], entirely from previously collected data. Many realistic settings where we might want to apply offline RL are inherently multi-task problems, where we want to solve multiple tasks using all of the data available. For example, if our goal is to enable robots to acquire a range of different behaviors, it is more practical to collect a modest amount of data for each desired behavior, resulting in a large but heterogeneous dataset, rather than requiring a large dataset for every individual skill. Indeed, many existing datasets in robotics [17,11,66] and offline RL [19] include data collected in precisely this way. Unfortunately, leveraging such heterogeneous datasets leaves us with two unenviable choices. We could train each task only on data collected for that task, but such small datasets may be inadequate for good performance. Alternatively, we could combine all of the data together and use data relabeled from other tasks to improve offline training, but this naïve data sharing approach can actually often degrade performance over simple single-task training in practice [33]. In this paper, we aim to understand how data sharing affects RL performance in the offline setting and develop a reliable and effective method for selectively sharing data across tasks.
A number of prior works have studied multi-task RL in the online setting, confirming that multi-tasking can often lead to performance that is worse than training tasks individually [56,62,90]. These prior works focus on mitigating optimization challenges that are aggravated by the online data generation process [64,89,88]. As we will find in Section 4, multi-task RL remains a challenging problem in the offline setting when sharing data across tasks, even when exploration is not an issue. While prior works have developed heuristic methods for reweighting and relabeling data [3,16,44,33], they do not yet provide a principled explanation for why data sharing can hurt performance in the offline setting, nor do they provide a robust and general approach for selective data sharing that alleviates these issues while preserving the efficiency benefits of sharing experience across tasks.
In this paper, we hypothesize that data sharing can be harmful or brittle in the offline setting because it can exacerbate the distribution shift between the policy represented in the data and the policy being learned. We analyze the effect of data sharing in the offline multi-task RL setting, and present evidence to support this hypothesis. Based on this analysis, we then propose an approach for selective data sharing that aims to minimize distributional shift, by sharing only data that is particularly relevant to each task. Instantiating a method based on this principle requires some care, since we do not know a priori which data is most relevant for a given task before we've learned a good policy for that task. To provide a practical instantiation, we propose the conservative data sharing (CDS) algorithm. CDS reduces distributional shift by sharing data based on a learned conservative estimate of the Q-values that penalizes Q-values on out-of-distribution actions. Specifically, CDS relabels transitions when the conservative Q-value of the added transitions exceeds the expected conservative Q-values on the target task data. We visualize how CDS works in Figure 1. The main contributions of this work are an analysis of data sharing in offline multi-task RL and a new algorithm, conservative data sharing (CDS), for multitask offline RL problems. CDS relabels a transition into a given task only when it is expected to improve performance based on a conservative estimate of the Q-function. After data sharing, similarly to prior offline RL methods, CDS applies a standard conservative offline RL algorithm, such as CQL [39], that learns a conservative value function or BRAC [82], a policyconstraint offline RL algorithm. Further, we theoretically analyze CDS and characterize scenarios under which it provides safe policy improvement guarantees. Finally, we conduct extensive empirical analysis of CDS on multi-task locomotion, multi-task robotic manipulation with sparse rewards, multi-task navigation, and multi-task imaged-based robotic manipulation. We compare CDS to vanilla offline multi-task RL without sharing data, to naïvely sharing data for all tasks, and to existing data relabeling schemes for multi-task RL. CDS is the only method to attain good performance across all of these benchmarks, often significantly outperforming the best domain-specific method, improving over the next best method on each domain by 17.5% on average.
Multi-task RL algorithms. Multi-task RL algorithms [81,56,77,15,27,89,85,88,33,71] focus on solving multiple tasks jointly in an efficient way. While multi-task RL methods seem to provide a promising way to build general-purpose agents [33], prior works have observed major challenges in multi-task RL, in particular, the optimization challenge [27,64,89]. Beyond the optimization challenge, how to perform effective representation learning via weight sharing is another major challenge in multi-task RL. Prior works have considered distilling per-task policies into a single policy that solves all tasks [62,77,23,85], separate shared and task-specific modules with theoretical guarantees [13], and incorporating additional supervision [71]. Finally, sharing data across tasks emerges as a challenge in multi-task RL, especially in the off-policy setting, as naïvely sharing data across all tasks turns out to hurt performance in certain scenarios [33]. Unlike most of these prior works, we focus on the offline setting where the challenges in data sharing are most relevant. Methods that study optimization and representation learning issues are complementary and can be readily combined with our approach.
Data sharing in multi-task RL. Prior works [3,31,58,63,16,44,33,8] have found it effective to reuse data across tasks by recomputing the rewards of data collected for one task and using such relabeled data for other tasks, which effectively augments the amount of data available for learning each task and boosts performance. These methods perform relabeling either uniformly [33] or based on metrics such as estimated Q-values [16,44], domain knowledge [33], the distance to states or images in goal-conditioned settings [3,58,55,48,73,47,28,51,87,8], and metric learning for robust inference in the offline meta-RL setting [45]. All of these methods either require online data collection and do not consider data sharing in a fully offline setting, or only consider offline goal-conditioned or meta-RL problems [8,45]. While these prior works empirically find that data sharing helps, we believe that our analysis in Section 4 provides the first analytical understanding of why and when data sharing can help in multi-task offline RL and why it hurts in some cases. Specifically, our analysis reveals the effect of distributional shift introduced during data sharing, which is not taken into account by these prior works. Our proposed approach, CDS, tackles the challenge of distributional shift in data sharing by intelligently sharing data across tasks and improves multi-task performance by effectively trading off between the benefits of data sharing and the harms of excessive distributional shift.

Preliminaries and Problem Statement
Multi-task offline RL. The goal in multi-task RL is to find a policy that maximizes expected return in a multi-task Markov decision process (MDP), defined as M = (S, A, P, γ, , with state space S, action space A, dynamics P (s |s, a), a discount factor γ ∈ [0, 1), and a finite set of task indices 1, · · · , N with corresponding reward functions R 1 , · · · , R N . Each task i presents a different reward function R i , but we assume that the dynamics P are shared across tasks. While this setting is not fully general, there are a wide variety of practical problem settings for which only the reward changes including various goal navigation tasks [19], distinct object manipulation objectives [83], and different user preferences [10]. In this work, we focus on learning a policy π(a|s, i), which in practice could be modelled as independent policies {π 1 (a|s), · · · , π N (a|s)} that do not share any parameters, or as a single task-conditioned policy, π(a|s, i) with parameter sharing. Our goal in this paper is to analyze and devise methods for data sharing and the choice of parameter sharing is orthogonal, and can be made independently. We formulate the policy optimization problem as finding a policy that maximizes expected return over all the tasks: π * (a|s, . The Q-function, Q π (s, a, i), of a policy π(·|·, i) is the long-term discounted reward obtained in task i by executing action a at state s and following policy π thereafter.
Standard offline RL is concerned with learning policies π(a|s) using only a given static dataset of transitions D = {(s j , a j , s j , r j )} N j=1 , collected by a behavior policy π β (a|s), without any additional environment interaction. In the multi-task offline RL setting, the dataset D is partitioned into per-task subsets, D = ∪ N i=1 D i , where D i consists of experience from task i. While algorithms can choose to train the policy for task i (i.e., π(·|·, i)) only on D i , in this paper, we are interested in data-sharing schemes that correspond to relabeling data from a different task, j = i with the reward function r i , and learn π(·|·, i) on the combined data. To be able to do so, we assume access to the functional form of the reward r i , a common assumption in goal-conditioned RL [3,16], and which often holds in robotics applications through the use of learned classifiers [83,32], and discriminators [18,9].
We assume that relabeling data D j from task j to task i generates a dataset D j→i , which is then additionally used to train on task i. Thus, the effective dataset for task i after relabeling is given by D eff i := D i ∪ (∪ j =i D j→i ). This notation simply formalizes data sharing and relabeling strategies explored in prior work [16,33]. Our aim in this paper will be to improve on this naïve strategy, which we will show leads to significantly better results.
Offline RL algorithms. A central challenge in offline RL is distributional shift: differences between the learned policy and the behavior policy can lead to erroneous target values, where the Q-function is queried at actions a ∼ π(a|s) that are far from the actions it is trained on, leading to massive overestimation [43,37]. A number of offline RL algorithms use some kind of regularization on either the policy [37,20,82,29,68,57] or on the learned Q-function [39,36] to ensure that the learned policy does not deviate too far from the behavior policy. For our analysis in this work, we will abstract these algorithms into a generic constrained policy optimization problem [39]: π * (a|s) := arg max π J D (π) − αD(π, π β ). (1) J D (π) denotes the average return of policy π in the empirical MDP induced by the transitions in the dataset, and D(π, π β ) denotes a divergence measure (e.g., KL-divergence [29,82], MMD distance [37] or D CQL [39]) between the learned policy π and the behavior policy π β . In the multi-task offline RL setting with data-sharing, the generic optimization problem in Equation 1 for a task i utilizes the effective dataset D eff i . In addition, we define π eff β (a|s, i) as the effective behavior policy for task i and it is given by: π eff β (a|s, i) := |D eff i (s, a)|/|D eff i (s)|. Hence, the counterpart of Equation 1 in the multi-task offline RL setting with data sharing is given by: We will utilize this generic optimization problem to motivate our method in Section 5.

When Does Data Sharing Actually Help in Offline Multi-Task RL?
Our goal is to leverage experience from all tasks to learn a policy for a particular task of interest. Perhaps the simplest approach to leveraging experience across tasks is to train the task policy on not just the data coming from that task, but also relabeled data from all other tasks [6]. Is this naïve data sharing strategy sufficient for learning effective behaviors from multi-task offline data? In this section, we aim to answer this question via empirical analysis on a relatively simple domain, which will reveal interesting aspects of data sharing. We first describe the experimental setup and then discuss the results and possible explanations for the observed behavior. Using insights obtained from this analysis, we will then derive a simple and effective data sharing strategy in Section 5.
Experimental analysis setup. To assess the efficacy of data sharing, we experimentally analyze various multi-task RL scenarios created with the walker2d environment in Gym [5]. We construct different test scenarios on this environment that mimic practical situations, including settings where different amounts of data of varied quality are available for different tasks [33,84,69]. In all these scenarios, the agent attempts three tasks: run forward, run backward, and jump, which we visualize in Figure 3. Following the problem statement in Section 3, these tasks share the same state-action space and transition dynamics, differing only in the reward function that the agent is trying to optimize. Different scenarios are generated with varying size offline datasets, each collected with policies that have different degrees of suboptimality. This might include, for each task, a single policy with mediocre or expert performance, or a mixture of policies given by the initial part of the replay buffer trained with online SAC [26]. We refer to these three types of offline datasets as medium, expert and medium-replay, respectively, following Fu et al. [19].
We train a single-task policy π CQL (a|s, i) with CQL [39] as the base offline RL method, along with two forms of data-sharing, as shown in Table 1: no sharing of data across tasks (No Sharing)) and complete sharing of data with relabeling across all tasks (Sharing All). In addition, we also measure the divergence term in Equation 2, D(π(·|·, i), π eff β (·|·, i)), for π = π CQL (a|s, i), averaged across tasks by using the Kullback-Liebler divergence. This value quantifies the average divergence between the single-task optimal policy and the relabeled behavior policy averaged across tasks. Table 1. To begin, note that even naïvely sharing data is better than not sharing any data at all on 5/9 tasks considered (compare the performance across No Sharing and Sharing All in Table 1). However, a closer look at Table 1 suggests that data-sharing can significantly degrade performance on certain tasks, especially in scenarios where the amount of data available for the original task is limited, and where the distribution of this data is narrow. For example, when using expert data for jumping in conjunction with more than 25 times as much lower-quality (mediocre & random) data for running forward and backward, we find that the agent performs poorly on the jumping task despite access to near-optimal jumping data.

Analysis of results in
Why does naïve data sharing degrade performance on certain tasks despite near-optimal behavior for these tasks in the original task dataset? We argue that the primary reason that naïve data sharing can actually hurt performance in such cases is because it exacerbates the distributional shift issues that afflict offline RL. Many offline RL methods combat distribution shift by implicitly or explicitly constraining the learned policy to stay close to the training data. Then, when the training data is changed by adding relabeled data from another task, the constraint causes the learned policy to change as well. When the added data is of  Table 1: We analyze how sharing data across all tasks (Sharing All) compares to No Sharing in the multi-task walker2d environment with three tasks: run forward, run backward, and jump. We provide three scenarios with different styles of per-task offline datasets in the leftmost column. The second column shows the number of transitions in each dataset. We report the per-task average return, the KL divergence between the single-task optimal policy π and the behavior policy π β after the data sharing scheme, as well as averages across tasks. Sharing All generally helps training while increasing the KL divergence. However, on the row highlighted in yellow, Sharing All yields a particularly large KL divergence between the single-task π and π β and degrades the performance, suggesting sharing data for all tasks is brittle. low quality for that task, it will correspondingly lead to a lower quality learned policy for that task, unless the constraint is somehow modified. This effect is evident from the higher divergence values between the learned policy without any data-sharing and the effective behavior policy for that task after relabeling (e.g., expert+jump) in Table 1. Although these results are only for CQL, we expect that any offline RL method would, insofar as it combats distributional shift by staying close to the data, would exhibit a similar problem.
To mathematically quantify the effects of data-sharing in multi-task offline RL, we appeal to safe policy improvement bounds [41,39,92] and discuss cases where data-sharing between tasks i and j can degrade the amount of worst-case guaranteed improvement over the behavior policy. Prior work [39] has shown that the generic offline RL algorithm in Equation 1 enjoys the following guarantees of policy improvement on the actual MDP, beyond the behavior policy: We will use Equation 3 to understand the scenarios where data sharing can hurt. When data sharing modifies D = D i to D = D eff i , which includes D i as a subset, it effectively aims at reducing the magnitude of the second term (i.e., sampling error) by increasing the denominator. This can be highly effective if the state distribution of the learned policy π * and the dataset D overlap. However, an increase in the divergence D(π(·|s), π β (·|s)) as a consequence of relabeling implies a potential increase in the sampling error, unless the increased value of |D eff (s)| compensates for this. Additionally, the bound also depends on the quality of the behavior data added after relabeling: if the resulting behavior policy π eff β is more suboptimal compared to π β , i.e., J(π eff β ) < J(π β ), then the guaranteed amount of improvement also reduces. To conclude, our analysis reveals that while data sharing is often helpful in multi-task offline RL, it can lead to substantially poor performance on certain tasks as a result of exacerbated distributional shift between the optimal policy and the effective behavior policy induced after sharing data.

CDS: Reducing Distributional Shift in Multi-Task Data Sharing
The analysis in Section 4 shows that naïve data sharing may be highly sub-optimal in some cases, and although it often does improve over no data sharing at all in practice, it can also lead to exceedingly poor performance. Can we devise a conservative approach that shares data intelligently to not exacerbate distributional shift as a result of relabeling?

A First Attempt at Designing a Data Sharing Strategy
A straightforward data sharing strategy is to utilize a transition for training only if it reduces the distributional shift. Formally, this means that for a given transition (s, a, r j (s, a), s ) ∈ D j sampled from the dataset D j , such a scheme would prescribe using it for training task i (i.e., (s, a, r i (s, a), s ) ∈ D eff i ) only if: The scheme presented in Equation 4 would guarantee that distributional shift (i.e., second term in Equation 2) is reduced. Moreover, since sharing data can only increase the size of the dataset and not reduce it, this scheme is guaranteed to not increase the sampling error term in Equation 3. We refer to this scheme as the basic variant of conservative data sharing (CDS (basic)).
While this scheme can prevent the negative effects of increased distributional shift, this scheme is quite pessimistic. Even in our experiments, we find that this variant of CDS does not improve performance by a large margin. Additionally, as observed in Table 1 (medium-medium-medium data composition) and discussed in Section 4, data sharing can often be useful despite an increased distributional shift (note the higher values of D KL (π, π β ) in Table 1) likely because it reduces sampling error and potentially utilizes data of higher quality for training. CDS (basic) described above does not take into account these factors. Formally, the effect of the first term in Equation 2, J D eff (π) (the policy return in the empirical MDP generated by the dataset) and a larger increase in |D eff (s)| at the cost of somewhat increased value of D(π(·|s), π β (·|s) are not taken into account. Thus we ask: can we instead design a more complete version of CDS that effectively balances the tradeoff by incorporating all the discussed factors (distributional shift, sampling error, data quality)?

Figure 2: A schematic comparing CDS and CDS (basic)
data sharing schemes relative to no sharing (left extreme) and full data sharing (right extreme). While p-CDS only shares data when distributional shift is strictly reduced, o-CDS is more optimistic and shares data when the objective in Equation 2 is larger. Typically, we would expect that CDS shares more transitions than CDS (basic).
Next, we present the complete version of our method. The complete version of CDS, which we will refer to as CDS, for notational brevity is derived from the following perspective: we note that a data sharing scheme can be viewed as altering the dataset D eff i , and hence the effective behavior policy, π eff β (a|s, i). Thus, we can directly optimize the objective in Equation 2 with respect to π eff β , in addition to π, where π eff β belongs to the set of all possible effective behavior policies that can be obtained via any form of data sharing. Note that unlike CDS (basic), this approach would not rely on only indirectly controlling the objective in Equation 2 by controlling distributional shift, but would aim to directly optimize the objective in Equation 2. We formalize this optimization below in Equation 5: where Π relabel denotes the set of all possible behavior policies that can be obtained via relabeling. The next result characterizes safe policy improvement for Equation 5 and discusses how it leads to improvement over the behavior policy and also produces an effective practical method. Proposition 5.1 (Characterizing safe-policy improvement for CDS.). Let π * (a|s) be the policy obtained by optimizing Equation 5, and let π β (a|s) be the behavior policy for D i . Then, w.h.p. ≥ 1 − δ, π * is a ζ-safe policy improvement over π β , i.e., J(π * ) ≥ J(π β ) − ζ, where ζ is given by: where D eff i ∼ d π * β (s) and π * β (a|s) denotes the policy π ∈ Π relabel that maximizes Equation 5.
A proof and analysis of this proposition is provided in Appendix A, where we note that the bound in Proposition 5.1 is stronger than both no data sharing as well as naïve data sharing. We show in Appendix A that optimizing Equation 5 reduces the numerator D CQL (π * , π * β ) term while also increasing |D eff i (s)|, thus reducing the amount of sampling error. In addition, Lemma A.1 shows that the improvement term (a) is guaranteed to be positive if a large enough α is chosen in Equation 5. Combining these, we find data sharing using Equation 5 improves over both complete data sharing (which may increase D CQL (π, π β )) and no data sharing (which does not increase |D eff i (s)|). A schematic comparing the two variants of CDS and naïve and no data sharing schemes is shown in Figure 2.
Optimizing Equation 5 tractably. The next step is to effectively convert Equation 5 into a simple condition for data sharing in multi-task offline RL. While directly solving Equation 5 is intractable in practice, since both the terms depend on π eff β (a|s) (since the first term J D eff (π) depends on the empirical MDP induced by the effective behavior policy and the amount of sampling error), we need to instead solve Equation 5 approximately. Fortunately, we can optimize a lower-bound approximation to Equation 5 that uses the dataset state distribution for the policy update in Equation 5 similar to modern actor-critic methods [12,46,21,26,39] which only introduces an additional D(π, π β ) term in the objective. This objective is given by: , which is equal to the expected "conservative Q-value" Q π (s, a, i) on dataset states, policy actions and task i. Optimizing this objective via a co-ordinate descent on π and π eff β dictates that π be updated using a standard update of maximizing the conservative Q-function, Q π (equal to the difference of the Q-function and D(π, π eff β ; i)). Moreover, π eff β should also be updated towards maximizing the same expectation, . This implies that when updating the behavior policy during relabeling, we should prefer state-action pairs that maximize the conservative Q-function.

Algorithm 1 CDS: Conservative Data Sharing
using Eq. 6 (CDS) or Eq. 7 (CDS(basic)). 6: Improve policy by solving eq. 2 using samples from D eff to obtain π k+1 θ . Deriving the data sharing strategy for CDS. Utilizing the insights for optimizing Equation 5 tractably as discussed above, we now present the effective data sharing rule prescribed by CDS. For any given task i, we want relabeling to incorporate transitions with the highest conservative Q-value into the resulting dataset D eff i , as this will directly optimize the tractable lower bound on Equation 5. While directly optimizing Equation 5 will enjoy benefits of reduced sampling error since J D eff i (π) also depends on sampling error, our tractable lower bound approximation does not enjoy this benefit. This is because optimizing the lower-bound only increases the frequency of a state in the dataset, |D eff i (s)| by atmost 1. To encourage further reduction in sampling error, we modify CDS to instead share all transitions with a conservative Q-value more than the top k th quantile of the original dataset D i , where k is a hyperparameter. This provably increases the objective value in Equation 5 still ensuring that term (a) > 0 in Proposition 5.1, while also reducing |D eff i (s)| in the denominator. Thus, for a given transition (s, a, s ) ∈ D j , whereQ π denotes the learned conservative Q-function estimate. If the condition in Equation 6 holds for the given (s, a), then the corresponding relabeled transition, (s, a, r i (s, a), s ) is added to D eff i .

Practical implementation of CDS
The pseudocode of CDS is summarized in Algorithm 1. The complete variant of CDS can be directly implemented using the rule in Equation 6 with conservative Q-value estimates obtained via any offline RL method that constrains the learned policy to the behavior policy. For implementing CDS (basic), we reparameterize the divergence D in Equation 4 to use the learned conservative Q-values. This is especially useful for our implementation since we utilize CQL as the base offline RL method, and hence we do not have access to an explicit divergence. In this case, ∆ π (s, a) can be redefined as, ∆ π (s, a) := Equation 7 can be viewed as the difference between the CQL [39] regularization term on a given (s, a) and the original dataset for task i, D i . This CQL regularization term is equal to the divergence between the learned policy π(·|s) and the behavior policy π β (·|s), therefore Equation 7 practically computes Equation 4.
Finally, both variants of CDS train a policy, π(a|s; i), either conditioned on the task i (i.e., with weight sharing) or a separate π(a|s) policy for each task with no weight sharing, using the resulting relabeled dataset, D eff i . For practical implementation details of CDS see Appendix B.

Experimental Evaluation
We conduct experiments to answer six main questions: (1) can CDS prevent performance degradation when sharing data as observed in Section 4?, (2) how does CDS compare to vanilla multi-task offline RL methods and prior data sharing methods? (3) can CDS handle sparse reward settings, where data sharing is particularly important due to scarce supervision signal? (4) can CDS handle goal-conditioned offline RL settings where the offline dataset is undirected and highly suboptimal? (5) Can CDS scale to complex visual observations? (6) Can CDS be combined with any offline RL algorithms? Besides these questions, we visualize CDS weights for better interpretation of the data sharing scheme learned by CDS in Figure 4 in Appendix C.2. Comparisons. To answer these questions, we consider the following prior methods. On tasks with low dimensional state spaces, we compare with the online multitask relabeling approach HIPI [16], which uses inverse RL to infer for which tasks the datapoints are optimal and in practice routes a transition to task with the highest Qvalue. We adapt HIPI to the offline setting by applying its data routing strategy to a conservative offline RL algorithm. We also compare to naïvely sharing data across all tasks (denoted as Sharing All) and vanilla multi-task offline RL method without any data sharing (denoted as No Sharing). On image-based domains, we compare CDS to the data sharing strategy based on human-defined skills [33] (denoted as Skill), which manually groups tasks into different skills (e.g. skill "pick" and skill "place") and only routes an episode to target tasks that belongs to the same skill. In these domains, we also compare to HIPI, Sharing All and No Sharing. Beyond these multi-task RL approaches with data sharing, to assess the importance of data sharing in offline RL, we perform an additional comparison to other alternatives to data sharing in multi-task offline RL settings. One traditionally considered approach is to use data from other tasks for some form of "pre-training" before learning to solve the actual task. We instantiate this idea by considering a method from Yang and Nachum [86] that conducts contrastive representation learning on the multi-task datasets to extract shared representation between tasks and then runs multi-task RL on the learned representations. We discuss this comparison in detail in Table 7 in Appendix C.
3. To answer question (6), we use CQL [39] (a Q-function regularization method) and BRAC [82] (a policy-constraint method) as the base offline RL algorithms for all methods. We discuss evaluations of CDS with CQL in the main text and include the results of CDS with BRAC in Table 5 in Appendix C.1. For more details on setup and hyperparameters, see Appendix B.
Multi-task environments. We consider a number of multi-task reinforcement learning problems on environments visualized in Figure 3. To answer questions (1) and (2), we consider the walker2d locomotion environment from OpenAI Gym [5] with dense rewards. We use three tasks, run forward, run backward and jump, as proposed in prior offline RL work [91]. To answer question (3), we also evaluate on robotic manipulation domains using environments from the Meta-World benchmark [90]. We consider four tasks: door open, door close, drawer open and drawer close. Meaningful data sharing requires a consistent state representation across tasks, so we put both the door and the drawer on the same table, as shown in Figure 3. Each task has a sparse reward of 1 when the success condition is met and 0 otherwise.
To answer question (4), we consider maze navigation tasks where the temporal "stitching" ability of an offline RL algorithm is crucial to obtain good performance. We create goal reaching tasks using the ant robot in the medium and hard mazes from D4RL [19]. The set of goals is a fixed discrete set of size 7 and 3 for large and medium mazes, respectively. Following Fu et al. [19], a reward of +1 is given and the episode terminates if the state is within a threshold radius of the goal. Finally, to explore how CDS scales to image-based manipulation tasks (question (5)), we utilize a simulation environment similar to the real-world setup presented in [33]. This environment, which was utilized by Kalashnikov et al. [33] as a representative and realistic simulation of a real-world robotic manipulation problem, consists of 10 image-based manipulation tasks that involve different combinations of picking specific objects (banana, bottle, sausage, milk box, food box, can and carrot) and placing them in one of the three fixtures (bowl, plate and divider plate) (see example task images in Fig. 3). We pick these tasks due to their similarity to the real-world setup introduced by Kalashnikov et al. [33], which utilized a skill-based data-sharing heuristic strategy (Skill) for data-sharing that significantly outperformed simple data-sharing alternatives, which we use as a point of comparison. More environment details are in the appendix. We report the average return for locomotion tasks and success rate for AntMaze and both manipluation environments, averaged over 6 and 3 random seeds for environments with low-dimensional inputs and image inputs respectively.  Table 2: Measuring DKL(π, π β ) on the walker2d environment. Sharing All degrades the performance on task jump with limited expert data as discussed in Table 1 (M-R refers to medium-replay, M refers to medium, and E refers to expert). CDS manages to obtain a π β after data sharing that is closer to the single-task optimal policy in terms of the KL divergence compared to No Sharing and Sharing All on task jump (highlighted in yellow). Since CDS also achieves better performance, this analysis suggests that reducing distribution shift is important for effective offline data sharing.
Multi-task datasets. Following the analysis in Section 4, we intentionally construct datasets with a variety of heterogeneous behavior policies to test if CDS can provide effective data sharing to improve performance while avoiding harmful data sharing that exacerbates distributional shift. For the locomotion domain, we use a large, diverse dataset (medium-replay) for run forward, a medium-sized dataset for run backward, and an expert dataset with limited data for run jump. For Meta-World, we consider medium-replay datasets with 152K transitions for task door open and drawer close and expert datasets with only 2K transitions for task door close and drawer open. For AntMaze, we modify the D4RL datasets for antmaze-*-play environments to construct two kinds of multi-task datasets: an "undirected" dataset, where data is equally divided between different tasks and the rewards are correspondingly relabeled, and a "directed" dataset, where a trajectory is associated with the goal closest to the final state of the trajectory. This means that the per-task data in the undirected setting may not be relevant to reaching the goal of interest. Thus, datasharing is crucial for good performance: methods that do not effectively perform data sharing and train on largely task-irrelevant data are expected to perform worse. Finally, for image-based manipulation tasks, we collect datasets for all the tasks individually by running online RL [32] until the task reaches medium-level performance (40% for picking tasks and 80% placing tasks). At that point, we merge the entire replay buffers from different tasks creating a final dataset of 100K RL episodes with 25 transitions for each episode.
Results on domains with low-dimensional states. We present the results on all non-vision environments in Table 3. CDS achieves the best average performance across all environments except that on walker2d, it achieves the second best performance, obtaining slightly worse the other variant CDS (basic). On the locomotion domain, we observe the most significant improvement on task jump on all three environments. We interpret this as strength of conservative data sharing, which mitigates the distribution shift that can be introduced by routing large amount of other task data to the task with limited data and narrow distribution. We also validate this by measuring the D KL (π, π β ) in Table 2 where π β is the behavior policy after we perform CDS to share data. As shown in Table 2, CDS achieves lower KL divergence between the single-task optimal policy and the behavior policy after data sharing on task jump with limited expert data, whereas Sharing All results in much higher KL divergence compared to No Sharing as discussed in Section 4 and Table 1. Hence, CDS is able to mitigate distribution shift when sharing data and result in performance boost.
On the Meta-World tasks, we find that the agent without data sharing completely fails to solve most of the tasks due to the low quality of the medium replay datasets and the insufficient data for the expert datasets. Sharing All improves performance since in the sparse reward settings, data sharing can introduce more supervision signal and help training. CDS further improves over Sharing All, suggesting that CDS can not only prevent harmful data sharing, but also lead to more effective multi-task learning compared to Sharing All in scenarios where data sharing is imperative. It's worth noting that CDS (basic) performs worse than CDS and Sharing All, indicating that relabeling data that only mitigates distributional shift is too pessimistic and might not be sufficient to discover the shared structure across tasks.
In the AntMaze tasks, we observe that CDS performs better than Sharing All and significantly outperforms HIPI in all four settings. Perhaps surprisingly, No Sharing is a strong baseline, however, is outperformed by  [19] large maze (7 tasks) / directed 24.6% ± 4.7% 0.0% ± 0.0% 11.8% ± 5.4% 20.6% ± 4.4% 19.2% ± 8.0% medium maze (3 tasks) / undirected 36.7% ± 6.2% 0.0% ± 0.0% 8.6% ± 3.2% 22.9% ± 3.6% 21.6% ± 7.1% medium maze (3 tasks) / directed 18.5% ± 6.0% 0.0% ± 0.0% 8.3% ± 9.1% 12.4% ± 5.4% 17.0% ± 3.2% Table 3: Results for multi-task locomotion (walker2d), robotic manipulation (Meta-World) and navigation environments (AntMaze) with low-dimensional state inputs. Numbers are averaged across 6 seeds, ± the 95%-confidence interval. We include per-task performance for walker2d and Meta-World domains and the overall performance averaged across tasks (highlighted in gray) for all three domains. We bold the highest score across all methods. CDS performs achieves the best or comparable performance on all of these multi-task environments.  Table 4: Results for multi-task vision-based robotic manipulation domains in [33]. Numbers are averaged across 3 seeds, ± the 95% confidence interval. We consider 7 tasks denoted as lift-object where the goal of each task is to lift a different object and 3 tasks denoted as place-fixture where the goal of each task is to place a lifted object onto different fixtures. CDS outperforms both a skill-based data sharing strategy [33] (Skill) and other data sharing methods on the average task success rate (highlighted in gray) and 7 out of 10 per-task success rate.
CDS with the harder undirected data. Moreover, CDS performs on-par or better in the undirected setting compared to the directed setting, indicating the effectiveness of CDS in routing data in challenging settings.
Results on image-based robotic manipulation domains. Here, we compare CDS to the hand-designed Skill sharing strategy, in addition to the other methods. Given that CDS achieves significantly better performance than CDS (basic) on low-dimensional robotic manipulation tasks in Meta-World, we only evaluate CDS in the vision-based robotic manipulation domains. Since CDS is applicable to any offline multi-task RL algorithm, we employ it as a separate data-sharing strategy in [33] while keeping the model architecture and all the other hyperparameters constant, which allows us to carefully evaluate the influence of data sharing in isolation. The results are reported in Table 4. CDS outperforms both Skill and other approaches, indicating that CDS is able to scale to high-dimensional observation inputs and can effectively remove the need for manual curation of data sharing strategies.

Appendices A Analysis of CDS
In this section, we will analyze the key idea behind our method CDS (Section 5) and show that the abstract version of our method (Equation 5) provides better policy improvement guarantees than naïve data sharing and that the practical version of our method (Equation 6) approximates Equation 5 resulting in an effective practical algorithm.

A.1 Analysis of the Algorithm in Equation 5
We begin with analyzing Equation 5, which is used to derive the practical variant of our method, CDS. We build on the analysis of safe-policy improvement guarantees of conventional offline RL algorithms [41,39] and show that data sharing using CDS attains better guarantees in the worst case. To begin the analysis, we introduce some notation and prior results that we will directly compare to.
Notation and prior results. Let π β (a|s) denote the behavior policy for task i (note that index i was dropped from π β (a|s; i) for brevity). The dataset, D i is generated from the marginal state-action distribution of π β , i.e., D ∼ d π β (s)π β (a|s). We define d π D as the state marginal distribution introduced by the dataset D under π. Let D CQL (p, q) denote the following distance between two distributions p(x) and q(x) with equal support X : Unless otherwise mentioned, we will drop the subscript "CQL" from D CQL and use D and D CQL interchangeably. Prior works [39] have shown that the optimal policy π * i that optimizes Equation 1 attains a high probability safe-policy improvement guarantee, i.e., J(π * i ) ≥ J(π β ) − ζ i , where ζ i is: The first term in Equation 8 corresponds to the decrease in performance due to sampling error and this term is high when the single-task optimal policy π * i visits rarely observed states in the dataset D i and/or when the divergence from the behavior policy π β is higher under the states visited by the single-task policy s ∼ d π * i Di . Let J D (π) denote the return of a policy π in the empirical MDP induced by the transitions in the dataset D. Further, let us assume that optimizing Equation 5 gives us the following policies: π * (a|s), π * β (a|s) := arg max π,π β ∈Πrelabel where the optimized behavior policy π * β is constrained to lie in a set of all policies that can be obtained via relabeling, Π relabel , and the dataset, D eff i is sampled according to the state-action marginal distribution of π * β , i.e., D eff i ∼ d π * β (s, a). Additionally, for convenience, define, f (π 1 , π 2 ; D) := J D (π 1 ) − αD(π 1 , π 2 ) for any two policies π 1 and π 2 , and a given dataset D.
Proof. To prove this proposition, we shall quantify the lower-bound on the improvement in the policy performance due to Equation 9 in the empirical MDP, and the potential drop in policy performance in the original MDP due to sampling error, and combine the terms to obtain our bound. First note that for any given policy π, and a dataset D eff i with effective behavior policy π β (a|s), the following bound holds [39]: where the O(·) notation hides constants depending upon the concentration properties of the MDP [41] and 1 − δ, the probability with which the statement holds. Next, we provide guarantees on policy improvement in the empirical MDP. To see this, note that the following statements on f (π 1 , π 2 ; D) are true: And additionally, we obtain: =⇒ ∀π ∈ Π relabel , D(π * , π * β ) ≤ D(π * , π ).
Utilizing 12, we obtain that: where ≈ ignores sampling error terms that do not depend on distributional shift measures like D CQL because π * β and π β are behavior policies which generated the complete and part of the dataset, and hence these terms are dominated by and subsumed into the sampling error for π * . Combining Equations 10 (by setting π = π * ) and 15, we obtain the following safe-policy improvement guarantee for π * : J(π * ) − J(π β ) ≥ ζ, where ζ is given by: which proves the desired result.
Proposition A.1 indicates that when optimizing the behavior policy with Equation 5, we can improve upon the conventional safe-policy improvement guarantee (Equation 8) with standard single-task offline RL: not only do we improve via D CQL (π * , π * β ), since, D CQL (π * , π * β ) ≤ D CQL (π * , π β ), which reduces sampling error, but utilizing this policy π * β also allows us to improve on term (a), since Equation 9 optimizes the behavior policy to be close to the learned policy π * and maximizes the learned policy return J D eff i (π * ) on the effective dataset, thus providing us with a high lower bound on J(π * β ). We formalize this insight as Lemma A.1 below: Proof. To prove this, we note that using standard difference of returns of two policies, we get the following inequality: . Moreover, from Equation 12, we obtain that: we find that: , implying that (a) ≥ 0. For the edge cases when either D TV (π * , π * β ) = 0 or D CQL (π * , π * β ) = 0, we note that π * (a|s) = π * β (a|s), which trivially implies that J D eff i (π * β ) = J D eff i (π * ) ≥ J D eff i (π β ), because π * improves over π β on the dataset. Thus, term (a) is positive for large-enough α and the bound in Proposition A.1 gains from this term additionally.
Finally, we show that the sampling error term is controlled when utilizing Equation 5. We will show in Lemma A.2 that the sampling error in Proposition A.1 is controlled to be not much bigger than the error just due to variance, since distributional shift is bounded with Equation 5. Lemma A.2. If π * and π * β obtained from Equation 5 satisfy, D CQL (π * , π * β ) ≤ ε 1, then: Proof. This lemma can be proved via a simple application of the Cauchy-Schwarz inequality. We can partition the first term as a sum over dot products of two vectors such that: To summarize, combining Lemmas A.1 and A.2 with Proposition A.1, we conclude that utilizing Equation 5 controls the increase in sampling error due to distributional shift, and provides improvement guarantees on the learned policy beyond the behavior policy of the original dataset. We also briefly now discuss the comparison between CDS and complete data sharing. Complete data sharing would try to reduce sampling error by increasing |D eff i (s)|, but then it can also increase distributional shift, D CQL (π * , π * β ) as discussed in Section 4. On the other hand, CDS increases the dataset size while also controlling for distributional shift (as we discussed in the analysis above), making it enjoy the benefits of complete data sharing and avoiding its pitfalls, intuitively. On the other hand, no data sharing will just incur high sampling error due to limited dataset size.

A.2 From Equation 5 to Practical CDS (Equation 6)
The goal of our practical algorithm is to convert Equation 5 to a practical algorithm while retaining the policy improvement guarantees derived in Proposition A.1. Since our algorithm does not utilize any estimator for dataset counts |D eff i (s)|, and since we operate in a continuous state-action space, our goal is to retain the guarantees of increased return of π * β , while also avoiding sampling error. With this goal, we first need to relax the state-distribution in Equation 5: while both J D eff i (π) and D CQL (π, π β ) are computed as expectations under the marginal state-distribution of policy π(a|s) on the MDP defined by the dataset D eff i , for deriving a practical method we relax the state distribution to use the dataset statedistribution d π * β and rewrite the objective in accordance with most practical implementations of actor-critic algorithms [12,1,26,21,46] below: This practical approximation in Equation 18 is even more justified with conservative RL algorithms when a large α is used, since a larger α implies a smaller value for D(π * , π * β ) found by Equation 5, which in turn means that state-distributions d π * β and d π * are close to each other [65]. Thus, our policy improvement objective optimizes the policies π and π β by maximizing the conservative Q-function:Q π (s, a) = Q(s, a) − α π(a|s) π β (a|s) − 1 , that appears inside the expectation in Equation 18. While optimizing the policy π with respect to this conservative Q-functionQ π (s, a) is equivalent to a standard policy improvement update utilized by most actor-critic methods [21,26,39], we can optimizeQ π (s, a) with respect to π β ∈ Π relabel by relabeling only those transitions (s, a, r i , s ) ∈ D j→i that increase the expected conservative Q-value s, a) . Note that we relaxed the expectation a ∼ π(a|s) to a ∼ π β (a|s) in this expectation, which can be done upto a lower-bound of the objective in Equation 18 for a large α, since the resulting policies π and π β are close to each other.
The last step in our practical algorithm is to modify the solution of Equation 18 to still retain the benefits of reduced sampling error as discussed in Proposition A.1. To do so, we want to relabel as many points as possible, thus increasing |D eff i (s)|, which leads to reduced sampling error. Since quantifying |D eff i (s)| in continuous state-action spaces will require additional machinery such as density-models, we avoid these for the sake of simplicity, and instead choose to relabel every datapoint (s, a) ∈ D j→i that satisfies Q π (s, a; i) ≥ E s,a∼Di [Q π (s, a; i)] ≥ 0 to task i. These datapoints definitely increase the conservative Q-value and hence increase the objective in Equation 18 (though do not globally maximize it), while also enjoying properties of reduced sampling error (Proposition A.1). This discussion motivates our practical algorithm in Equation 6.

B Experimental details
In this section, we provide the training details of CDS in Appendix B.1 and also include the details on the environment and datasets that we use for the evaluation in Appendix B.2. Finally, we include the discussion on the compute information in Appendix B.3. We also compare CDS to an offline RL with pretrained representations from multi-task datasets method [86].

B.1 Training details
Our practical implementation of CDS optimizes the following objectives for training the critic and the policy: where β is the coefficient of the CQL penalty on distribution shift, µ is a wide sampling distribution as in CQL and B is the sample-based Bellman operator.
To compute the relabeling weight w CDS (s, a; j → i) := σ ∆(s,a;j→i) τ , we need to pick the value of the temperature term τ . Instead of tuning τ manually, we follow the the adaptive temperature scaling scheme from [38]. Specifically, we compute an exponential running average of ∆(s, a; j → i) with decay 0.995 for each task and use it as τ . We additionally clip the adaptive temperature term with a minimum and maximum threshold, which we tune manually. For multi-task halfcheetah, walker2d and ant, we clip the adaptive temperature such that it lies within [10, ∞], [5, ∞] and [10,25] respectively. For the multi-task Meta-Wold experiment, we use [1,50] for the clipping. For multi-task Antmaze, we used a range of [10, ∞] for all the domains. We do not clip the temperature term on vision-based domains.
For state-based experiments, we use a stratified batch with 128 transitions for each task for the critic and policy learning. For each task i, we sample 64 transitions from D i and another 64 transitions from ∪ j =i D j→i , i.e. the relabeled datasets of all the other tasks. When computing ∆(s, a; j → i), we only apply the weight to relabeled data on multi-task Meta-World environments and multi-task vision-based robotic manipulation tasks while also applying the weight to the original data drawn from D i with 50% chance for each task i ∈ [N ] in the remaining domains.
We use CQL [39] as the base offline RL algorithm. On state-based experiments, we mostly follow the hyperparameters provided in prior work [39]. One exception is that on the multi-task ant domain, we set β = 5.0 and on the other two locomotion environments and the multi-task Meta-World domain, we use β = 1.0. On multi-task AntMaze, we use the Lagrange version of CQL, where the multiplier β is automatically tuned against a pre-specific constraint value on the CQL loss equal to τ = 5.0. We use a policy learning rate 1e − 4 and a critic learning rate 3e − 4 as in [39]. On the vision-based environment, instead of using the direct CQL algorithm, we follow [8] and sample unseen actions according to the soft-max distritbution of the Q-values and set its Q target value to 0. This algorithm can be viewed the version of CQL with β = 1.0 in Eq.1 in [39], i.e. removing the term of negative expected Q-values on the dataset. We follow the other hyperparameters from prior work [32,8,33].
For the choice architectures, in the domains with low-dimensional state inputs, we use 3-layer feedforward neural networks with 256 hidden units for both the Q-networks and the policy. We append a one-hot task vector to the state of each environment. For the vision-based experiment, our Q-network architecture follows from multi-headed convolutional networks used in MT-Opt [33]. For the observation input, we use images with dimension 472 × 472 × 3 along with additional state features (g status , g height ) as well as the one-hot task vector as in [33]. For the action input, we use Cartesian space control of the end-effector of the robot in 4D space (3D position and azimuth angle) along with two discrete actions for opening/closing the gripper and terminating the episode respectively. More details can be found in [32,33].

B.2 Environment and dataset details
In this subsection, we discuss the details of how we set up the multi-task environment and how we collect the offline datasets. We want to acknowledge that all datasets with state inputs use the MIT License.
Multi-task locomotion domains. We construct the environment by changing the reward function in [5]. On the halfcheetah environment, we follow [91] and set the reward functions of task run forward, run backward and jump as r(s, a) = max{v x , 3} − 0.1 * a 2 2 , r(s, a) = − max{v x , 3} − 0.1 * a 2 2 and r(s, a) = −0.1 * a 2 2 + 15 * (z − init z) respectively where v x denotes the velocity along the x-axis and z denotes the z-position of the half-cheetah and init z denotes the initial z-position. Similarly, on walker2d, the reward functions of the three tasks are r(s, a) = v x − 0.001 * a 2 2 , r(s, a) = −v x − 0.001 * a 2 2 and r(s, a) = − v x −0.001 * a 2 2 +10 * (z−init z) respectively. Finally, on ant, the reward functions of the three tasks are r(s, a) = v x − 0.5 * a 2 2 − 0.005 * contact-cost, r(s, a) = −v x − 0.5 * a 2 2 − 0.005 * contact-cost and r(s, a) = − v x − 0.5 * a 2 2 − 0.005 * contact-cost + 10 * (z − init z). On each of the multi-task locomotion environment, we train each task with SAC [26] for 500 epochs. For medium-replay datasets, we take the whole replay buffer after the online SAC is trained for 100 epochs. For medium datasets, we take the online single-task SAC policy after 100 epochs and collect 500 trajectories with the medium-level policy. For expert datasets, we take the final online SAC policy and collect 5 trajectories with it for walker2d and halfcheetah and 20 trajectories for ant.
Meta-World domains. We take the door open, door close, drawer open and drawer close environments from the open-sourced Meta-World [90] repo 1 . We put both the door and the drawer on the same scene to make sure the state space of all four tasks are shared. For offline training, we use sparse rewards for each task by replacing the dense reward defined in Meta-World with the success condition defined in the public repo. Therefore, each task gets a reward of 1 if the task is fully completed and 0 otherwise.
For generating the offline datasets, we train each task with online SAC using the dense reward defined in Meta-World for 500 epochs. For medium-replay datasets, we take the whole replay buffer of the online SAC until 150 epochs. For the expert datasets, we run the final online SAC policy to collect 10 trajectories.
AntMaze domains. We take the antmaze-medium-play and antmaze-large-play datasets from D4RL [19] and convert the datasets into multi-task datasets in two ways. In the undirected version of these tasks, we split the dataset randomly into equal sized partitions, and then assign each partition to a particular randomly chosen task. Thus, the task data observed in the data for each task is largely unsuccessful for the particular task it is assigned to and effective data sharing is essential for obtaining good performance. The second setting is the directed data setting where a trajectory in the dataset is marked to belong to the task corresponding to the actual end goal of the trajectory. A sparse reward equal to +1 is provided to an agent when the current state reaches within a 0.5 radius of the task goal as was used default by Fu et al. [19].
Vision-based robotic manipulation domains. Following MT-Opt [33], we use sparse rewards for each task, i.e. reward 1 for success episodes and 0 otherwise. We define successes using the success detectors defined in [33]. To collect data for vision-based experiments, we train a policy for each task individually by running QT-Opt [32] with default hyperparameters until the task reaches 40% success rate for picking skills and 80% success rate for placing skills. We take the whole replay buffer of each task and combine all of such replay buffers to form the multi-task offline dataset with total 100K episodes where each episode has 25 transitions.

B.3 Computation Complexity
For all the state-based experiments, we train CDS on a single NVIDIA GeForce RTX 2080 Ti for one day. For the image-based robotic manipulation experiments, we train it on 16 TPUs for three days.

C Visualizations, Comparisons and Additional Experiments
In this section, we perform diagnostic and ablation experiments to: (1) understand the efficacy of CDS when applied with other base offline RL algorithms, such as BRAC [82], (2) visualize the weights learned by CDS to understand if the weighting scheme induced by CDS corresponds to what we would intuitively expect on different tasks, and (3) compare CDS to a prior approach that performs representation learning from offline multi-task datasets and then runs vanilla multi-task RL algorithm on top of the learned representations. We discuss these experiments next.

C.1 Applying CDS with BRAC [82], A Policy-Constraint Offline RL Algorithm
We implemented CDS on top of BRAC which is different from CQL that penalizes Q-functions. BRAC computes the divergence D(π, π β ) in Equation 1 explicitly and penalizes the reward function r(s, a) with this value in the Bellman backups. To apply CDS to BRAC, we need to compute a conservative estimate of the Q-value as discussed in Section 5.2. While the Q-function from CQL directly provides us with this conservative estimate, BRAC does not directly learn a conservative Q-function estimator. Therefore, for BRAC, we compute this conservative estimate by explicitly subtracting KL divergence between the learned policy π(a|s) and the behavior policy π β on state-action tuples (s, a) from the learned Q-function's prediction. Formally, this means that we utilizeQ(s, a) := Q(s, a) − αD KL (π(a|s), π β (a|s)) as our conservative Q-value estimate for BRAC. Given these conservative Q-value estimate, CDS weights can be computed directly using Equation 6.  We evaluated BRAC + CDS on the Meta-World tasks and compared it to BRAC + Sharing All and BRAC + No Sharing. We present the results in Table 5. We use ± to denote the 95%-confidence interval. As observed below, BRAC + CDS significantly outperforms BRAC with Sharing All and BRAC with No sharing. This indicates that CDS is effective on top of BRAC.

C.2 Analyzing CDS weights for Different Scenarios
Next, to understand if the weights assigned by CDS align with our expectation for which transitions should be shared between tasks, we perform diagnostic analysis studies on the weights learned by CDS on the Meta-World and Antmaze domains.
On the Meta-World environment, we would expect that for a given target task, say Drawer Close, transitions from a task that involves a different object (door) and a different skill (open) would not be as useful for learning. To understand if CDS weights reflect this expectation, we compare the average CDS weights on transitions from all the other tasks to two target tasks, Door Open and Drawer Close, respectively and present the results in Table 6. We sort the CDS weights in the descending order. As shown, indeed CDS assigns higher weights to more related tasks and thus shares data from those tasks. In particular, the CDS weights for relabeling data from the task that handles the same object as the target task are much higher than the weights for tasks that consider a different object.  tasks door open and drawer close shown in the second row and third row respectively. We sort the CDS weights for relabeled tasks to a particular target task in the descending order. As shown in the table, CDS upweights tasks that are more related to the target task, e.g. manipulating the same object.
For example, when relabeling to the target task Door Open, datapoints from task Door Close are assigned with much higher weights than those from either task Drawer Open or task Drawer Close. This suggests that CDS filters the irrelevant transitions for learning a given task.
On the AntMaze-large environment, with undirected data, we visualize the CDS weight for the various tasks (goals) in the form of a heatmap and present the results in Figure 4. To generate this plot, we sample a set of state-action pairs from the entire dataset for all tasks, and then plot the weights assigned by CDS as the color of the point marker at the (x, y) locations of these state-action pairs in the maze. Each plot computes the CDS weight corresponding to the target task (goal) indicated by the red × in the plot. As can be seen in Figure 4, CDS assigns higher weights to transitions from nearby goals as compared to transitions from farther away goals. This matches our expectation: transitions from nearby (x, y) locations are likely to be the most useful in learning a particular target task and CDS chooses to share these transitions to the target task.

C.3 Comparison of CDS with Other Alternatives to Data Sharing: Utilizing Multi-Task Datasets for Learning Pre-Trained Representations
Finally, we aim to empirically verify how other alternatives to data sharing perform on multi-task offline RL problems. One simple approach to utilize data from other tasks is to use this data to learn low-dimensional representations that capture meaningful information about the environment initially in a pre-training phase and then utilize these representations for improved multi-task RL without any specialized data sharing schemes. To assess the efficacy of this alternate approach of using multi-task offline data, in Table 7, we performed an experiment on the Meta-World domain that first utilizes the data from all the tasks to learn a shared representation using the best method, ACL [86] and then runs standard offline multi-task RL on top  Table 7: Comparison between CDS and Offline Pretraining [86] that pretrains the representation from the multi-task offline data and then runs multi-task offline RL on top of the learned representation on the Meta-World domain. Numbers are averaged across 6 seeds, ± the 95%-confidence interval. CDS significantly outperforms Offline Pretraining.
of this representation. We denote the method as Offline Pretraining. We include the average task success rates of all tasks in the table below. While the representation learning approach improves over standard multi-task RL without representation learning (No Sharing) consistent with the findings in [86], we still find that CDS with no representation learning outperforms this representation learning approach by a large margin on multi-task performance, which suggests that conservative data sharing is more important than pure pretrained representation from multi-task datasets in the offline multi-task setting. We finally remark that in principle, we could also utilize representation learning approaches in conjunction with data sharing strategies and systematically characterizing this class of hybrid approaches is a topic of future work.