dataset and generate script

create_dataset.py

@@ -0,0 +1,267 @@
+import copy
+import os, sys
+import random
+import uuid
+import pickle
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+import d4rl
+import gym
+import numpy as np
+import pyrallis
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import wandb
+from torch.distributions import Normal
+from torch.optim.lr_scheduler import CosineAnnealingLR
+from torch import autograd
+
+import imageio
+import yaml
+
+TensorBatch = List[torch.Tensor]
+DEFAULT_DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+@dataclass
+class TrainConfig:
+    #############################
+    ######### Experiment ########
+    #############################
+    percent_expert: float = 0.1
+    env_1: str = "halfcheetah-random-v2"
+    env_2: str = "halfcheetah-expert-v2"
+    file_name: str = "halfcheetah-10%-expert-random.npy"
+
+def get_trajectory_indices(terminals):
+    # Finds the indices where each trajectory begins and ends
+    end_indices = np.where(terminals)[0]
+    if len(end_indices) == 0 or end_indices[-1] != len(terminals) - 1:
+        # Ensure the last index is included as an end if not already
+        end_indices = np.append(end_indices, len(terminals) - 1)
+    start_indices = np.append(0, end_indices[:-1] + 1)
+    return list(zip(start_indices, end_indices + 1))
+
+def modify_dataset(dataset, expert_dataset):
+    # Assuming terminals are stored as boolean where True indicates the end of a trajectory
+    trajectory_indices = get_trajectory_indices(dataset['terminals'] + dataset['timeouts'])
+    expert_trajectory_indices = get_trajectory_indices(expert_dataset['terminals'] + expert_dataset['timeouts'])
+
+    # Determine how many trajectories to replace
+    trajectories_to_replace = int(config.percent_expert * len(trajectory_indices))
+
+    # Handle the case when there are no trajectories to replace
+    if trajectories_to_replace == 0 or len(expert_trajectory_indices) == 0:
+        print("No trajectories to replace or no expert trajectories available.")
+        trajectories_to_replace = 0
+        indices_replace_map = {}
+    else:
+        # Randomly choose trajectories to replace
+        indices_to_replace = np.random.choice(len(trajectory_indices), trajectories_to_replace, replace=False)
+        expert_indices = np.random.choice(len(expert_trajectory_indices), trajectories_to_replace, replace=False)
+
+        # Create a mapping from dataset trajectory indices to expert trajectory indices
+        indices_replace_map = dict(zip(indices_to_replace, expert_indices))
+
+    mixed_dataset = {}
+    keys = ['observations', 'actions', 'next_observations', 'rewards', 'terminals']
+
+    # Replacement process
+    for key in keys:
+        mixed_data = []
+        for i in range(len(trajectory_indices)):
+            if i in indices_replace_map:
+                # Use expert trajectory
+                expert_traj_idx = indices_replace_map[i]
+                expert_start, expert_end = expert_trajectory_indices[expert_traj_idx]
+                data_to_append = expert_dataset[key][expert_start:expert_end]
+            else:
+                # Use original dataset trajectory
+                start, end = trajectory_indices[i]
+                data_to_append = dataset[key][start:end]
+            mixed_data.append(data_to_append)
+        if mixed_data:
+            # Concatenate all data for the current key
+            mixed_dataset[key] = np.concatenate(mixed_data, axis=0)
+        else:
+            # If mixed_data is empty, create an empty array with the appropriate shape
+            mixed_dataset[key] = np.array([], dtype=dataset[key].dtype)
+
+    # Combine 'init_states' from both datasets
+    mixed_dataset['init_states'] = np.concatenate([dataset['init_states'], expert_dataset['init_states']], axis=0)
+
+    return mixed_dataset
+
+def modify_dataset_direct(dataset, expert_dataset):
+    mixed_dataset = {}
+    keys = ['observations', 'actions', 'next_observations', 'rewards', 'terminals']
+    # replace config.percent_expert of the dataset with expert_dataset
+    for key in keys:
+        mixed_data = []
+        for i in reversed(range(len(dataset[key]))):
+            if i > len(expert_dataset[key]) - int(config.percent_expert * len(dataset[key])):
+                data_to_append = expert_dataset[key][i - len(dataset[key]) + 1]
+            else:
+                data_to_append = dataset[key][i]
+            mixed_data.append(data_to_append)
+        if mixed_data:
+            # Concatenate all data for the current key
+            mixed_dataset[key] = np.array(mixed_data)
+        else:
+            # If mixed_data is empty, create an empty array with the appropriate shape
+            mixed_dataset[key] = np.array([], dtype=dataset[key].dtype)
+
+    # Combine 'init_states' from both datasets
+    mixed_dataset['init_states'] = np.concatenate([dataset['init_states'], expert_dataset['init_states']], axis=0)
+
+    mixed_dataset['transition_ids'] = np.arange(len(mixed_dataset["observations"]))
+
+    return mixed_dataset
+
+
+def qlearning_dataset(env, dataset=None, terminate_on_end=False, **kwargs):
+    if dataset is None:
+        dataset = env.get_dataset(**kwargs)
+    
+    init_obs_index = np.unique(np.concatenate((np.where(dataset['terminals'])[0][:-1] + 1, np.where(dataset['timeouts'])[0][:-1] + 1)))
+    init_obs_ = dataset['observations'][init_obs_index]
+
+    N = dataset['rewards'].shape[0]
+    obs_ = []
+    next_obs_ = []
+    action_ = []
+    reward_ = []
+    done_ = []
+    timeout_ = []
+    task_horizon = []
+
+    # The newer version of the dataset adds an explicit
+    # timeouts field. Keep old method for backwards compatability.
+    use_timeouts = False
+    if 'timeouts' in dataset:
+        use_timeouts = True
+
+    episode_step = 0
+    for i in range(N-1):
+        obs = dataset['observations'][i].astype(np.float32)
+        new_obs = dataset['observations'][i+1].astype(np.float32)
+        action = dataset['actions'][i].astype(np.float32)
+        reward = dataset['rewards'][i].astype(np.float32)
+        done_bool = bool(dataset['terminals'][i])
+        timeout_bool = bool(dataset['timeouts'][i])
+
+        if use_timeouts:
+            final_timestep = dataset['timeouts'][i]
+        else:
+            final_timestep = (episode_step == env._max_episode_steps - 1)
+        if (not terminate_on_end) and final_timestep:
+            # Skip this transition and don't apply terminals on the last step of an episode
+            episode_step = 0
+            continue
+        if done_bool or final_timestep:
+            episode_step = 0
+
+        obs_.append(obs)
+        next_obs_.append(new_obs)
+        action_.append(action)
+        reward_.append(reward)
+        done_.append(done_bool)
+        timeout_.append(timeout_bool)
+        task_horizon.append(episode_step)
+        episode_step += 1
+    
+    
+    # add in return for each episode
+    return_list = [0]
+    length = [0]
+    for i in range(len(done_)):
+        return_list[-1] += reward_[i]
+        length[-1] += 1
+        if done_[i] or timeout_[i]:
+            return_list.append(0)
+            length.append(0)
+
+    count = 0
+    data_return_list = [0] * len(done_)
+    for i in range(len(done_)):
+        data_return_list[i] = return_list[count]
+        if done_[i] or timeout_[i]:
+            count +=1
+    
+    data_return_list = env.get_normalized_score(np.array(data_return_list)) * 100.0
+    data_return_list = np.array(data_return_list)
+
+
+    epi_obs = []
+    epi_n_obs = []
+    epi_terminals = []
+    epi_rewards = []
+    epi_returns = []
+    epi_actions = []
+    obs = []
+    n_obs = []
+    terminals = []
+    rewards = []
+    actions = []
+    # task_horizon = []
+    task_step = 0
+    for i in range(len(done_)):
+        obs.append(obs_[i])
+        n_obs.append(next_obs_[i])
+        terminals.append(done_[i])
+        rewards.append(reward_[i])
+        actions.append(action_[i])
+        # task_horizon.append(task_step)
+        task_step += 1
+        if done_[i] or timeout_[i]:
+            epi_obs.append(np.array(obs))
+            epi_n_obs.append(np.array(n_obs))
+            epi_terminals.append(np.array(terminals))
+            epi_rewards.append(np.array(rewards))
+            epi_returns.append(data_return_list[i])
+            epi_actions.append(np.array(actions))
+            obs = []
+            n_obs = []
+            terminals = []
+            rewards = []
+            actions = []
+            task_step = 0
+
+    transition_ids = np.arange(len(obs_))
+    return {
+        'observations': np.array(obs_),
+        'actions': np.array(action_),
+        'next_observations': np.array(next_obs_),
+        'rewards': np.array(reward_),
+        'terminals': np.array(done_),
+        'timeouts': np.array(timeout_),
+        'init_states': np.array(init_obs_),
+        'transition_ids': transition_ids,
+        'returns': data_return_list,
+        'epi_obs': np.array(epi_obs, dtype=object),
+        'epi_n_obs': np.array(epi_n_obs, dtype=object),
+        'epi_terminals': np.array(epi_terminals, dtype=object),
+        'epi_rewards': np.array(epi_rewards, dtype=object),
+        'epi_returns': np.array(epi_returns, dtype=object),
+        'epi_actions': np.array(epi_actions, dtype=object),
+        'task_horizon':np.array(task_horizon, dtype=object),
+    }
+
+
+def create_dataset():
+    env = gym.make(config.env_1)
+    expert_env = gym.make(config.env_2)
+
+    dataset = qlearning_dataset(env)
+    expert_dataset = qlearning_dataset(expert_env)
+
+    # mixed_dataset = modify_dataset(dataset, expert_dataset)
+    mixed_dataset = modify_dataset_direct(dataset, expert_dataset)
+
+    with open(config.file_name, 'wb') as f:
+        pickle.dump(mixed_dataset, f)
+
+if __name__ == "__main__":
+    config = pyrallis.parse(config_class=TrainConfig)
+    create_dataset()

halfcheetah-1%-expert-random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4e18cc2ea8bbdb8b462905ffee4eab56f2dfc385e0384f9bff039d4f8d2275de
+size 172963474

halfcheetah-10%-expert-random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da85d979502e148a51e1791f72dbc3a0e564be77f4d56f330ba5a2d64b6a97ae
+size 172963474

halfcheetah-5%-expert-random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a3be120165d7c216ba29912cf8026e583486cb2267aff55aa4b8877b4cf21f11
+size 172963474

hopper-1%-expert-random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c92e8f721102cd506784fd7a94fd07181dfe3e2286739547ed432a7e9e129958
+size 115036069

hopper-10%-expert-random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f64ead3e6e1c3add72ed5b03a7ac98d26b8233102503401b21ac5ba27df4ee85
+size 115036069

hopper-5%-expert-random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:19ba2d78abf31bfab1dfa20c0ec710113a72361ff53f7f7663dadad2a048d415
+size 115036069

walker2d-1%-expert-random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a51ba580f8b98c1df6370d9ae79a4db29a7b40c1f2e1148dea1104ce292bda7
+size 176393909

walker2d-10%-expert-random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec35e7dfa318f3a4fb400600760c98b41cea59564804679cf99bd459c07ed187
+size 176393909

walker2d-5%-expert-random.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7bf098fcf913a2084a0646e80a8fd9eed884194e4a50ac30eede0fa4a93ebcaa
+size 176393909