new antmaze generate and dataset

antmaze-large-play-v2_easy_dataset.npy

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

antmaze-large-play-v2_hard_dataset.npy

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

antmaze-large-play-v2_medium_dataset.npy

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

antmaze-medium-play-v2_easy_dataset.npy

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

antmaze-medium-play-v2_hard_dataset.npy

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

antmaze-medium-play-v2_medium_dataset.npy

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

antmaze_dataset.py

@@ -0,0 +1,196 @@
+import copy
+import os
+import random
+import uuid
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+import pickle
+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
+
+@dataclass
+class TrainConfig:
+    #############################
+    ######### Experiment ########
+    #############################
+    env_1: str = "antmaze-medium-play-v2"
+    level: str = "hard"
+
+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]
+
+    init_pos = []
+    init_pos_in_current_traj = dataset['observations'][0][:2]
+    for i in range(len(dataset['observations'])):
+        if i in init_obs_index:
+            init_pos_in_current_traj = dataset['observations'][i][:2]
+        init_pos.append(init_pos_in_current_traj)
+    init_pos = np.array(init_pos)
+    
+    hardness = {'easy': 0.36, 'medium': 0.4, 'hard': 0.45}
+    obs = dataset['observations']
+    length = dataset['observations'].shape[0]
+    POSITIONS = obs[:,:2]
+    GOAL = dataset['infos/goal']
+    MINIMAL_POSITION = init_pos
+    # get maximal Euclidean distance
+    # MAX_EU_DIS = (GOAL - MINIMAL_POSITION)**2
+    MAX_EU_DIS = np.linalg.norm(GOAL - MINIMAL_POSITION, axis=1)
+    # DIS = ((POSITIONS - MINIMAL_POSITION)**2) / MAX_EU_DIS
+    DIS = np.linalg.norm(POSITIONS - MINIMAL_POSITION, axis=1) / MAX_EU_DIS
+    save_idx = np.random.random(size=length) > (DIS * hardness[config.level] * 10)
+    small_data = {}
+    for key in dataset.keys():
+        small_data[key] = dataset[key][save_idx]
+    dataset = small_data
+
+    
+
+    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),
+    }
+
+
+if __name__ == "__main__":
+    config = pyrallis.parse(config_class=TrainConfig)
+
+    env = gym.make(config.env_1)
+    dataset = qlearning_dataset(env)
+
+    # save dataset as npy
+    with open(f'./{config.env_1}_{config.level}_dataset.npy', 'wb') as f:
+        pickle.dump(dataset, f)
+
+