Merge branch 'main' of github.com:MarkFzp/act-plus-plus into main

这个提交包含在:
Zipeng Fu
2023-11-01 18:54:11 -07:00
当前提交 5ab307d5c4
共有 16 个文件被更改,包括 598 次插入 和 234 次删除

查看文件

@ -29,7 +29,7 @@
<site pos="0.15 0 0" size="0.003 0.003 0.03" type="box" name="cali_left_site1" rgba="0 0 1 0"/> <site pos="0.15 0 0" size="0.003 0.003 0.03" type="box" name="cali_left_site1" rgba="0 0 1 0"/>
<site pos="0.15 0 0" size="0.003 0.03 0.003" type="box" name="cali_left_site2" rgba="0 0 1 0"/> <site pos="0.15 0 0" size="0.003 0.03 0.003" type="box" name="cali_left_site2" rgba="0 0 1 0"/>
<site pos="0.15 0 0" size="0.03 0.003 0.003" type="box" name="cali_left_site3" rgba="0 0 1 0"/> <site pos="0.15 0 0" size="0.03 0.003 0.003" type="box" name="cali_left_site3" rgba="0 0 1 0"/>
<camera name="left_wrist" pos="-0.1 0 0.16" fovy="20" mode="targetbody" target="vx300s_left/camera_focus"/> <camera name="left_wrist" pos="-0.1 0 0.16" fovy="20" mode="fixed" euler="0 -1.05 -1.5707" />
<inertial pos="0.0395662 -2.56311e-07 0.00400649" quat="0.62033 0.619916 -0.339682 0.339869" mass="0.251652" diaginertia="0.000689546 0.000650316 0.000468142" /> <inertial pos="0.0395662 -2.56311e-07 0.00400649" quat="0.62033 0.619916 -0.339682 0.339869" mass="0.251652" diaginertia="0.000689546 0.000650316 0.000468142" />
<joint name="vx300s_left/wrist_rotate" pos="0 0 0" axis="1 0 0" limited="true" range="-3.14158 3.14158" frictionloss="30" /> <joint name="vx300s_left/wrist_rotate" pos="0 0 0" axis="1 0 0" limited="true" range="-3.14158 3.14158" frictionloss="30" />
<geom pos="-0.02 0 0" quat="0.707107 0 0 0.707107" type="mesh" mesh="vx300s_7_gripper" name="vx300s_left/7_gripper" /> <geom pos="-0.02 0 0" quat="0.707107 0 0 0.707107" type="mesh" mesh="vx300s_7_gripper" name="vx300s_left/7_gripper" />

查看文件

@ -29,7 +29,7 @@
<site pos="0.15 0 0" size="0.003 0.003 0.03" type="box" name="cali_right_site1" rgba="0 0 1 0"/> <site pos="0.15 0 0" size="0.003 0.003 0.03" type="box" name="cali_right_site1" rgba="0 0 1 0"/>
<site pos="0.15 0 0" size="0.003 0.03 0.003" type="box" name="cali_right_site2" rgba="0 0 1 0"/> <site pos="0.15 0 0" size="0.003 0.03 0.003" type="box" name="cali_right_site2" rgba="0 0 1 0"/>
<site pos="0.15 0 0" size="0.03 0.003 0.003" type="box" name="cali_right_site3" rgba="0 0 1 0"/> <site pos="0.15 0 0" size="0.03 0.003 0.003" type="box" name="cali_right_site3" rgba="0 0 1 0"/>
<camera name="right_wrist" pos="-0.1 0 0.16" fovy="20" mode="targetbody" target="vx300s_right/camera_focus"/> <camera name="right_wrist" pos="-0.1 0 0.16" fovy="20" mode="fixed" euler="0 -1.05 -1.5707" />
<inertial pos="0.0395662 -2.56311e-07 0.00400649" quat="0.62033 0.619916 -0.339682 0.339869" mass="0.251652" diaginertia="0.000689546 0.000650316 0.000468142" /> <inertial pos="0.0395662 -2.56311e-07 0.00400649" quat="0.62033 0.619916 -0.339682 0.339869" mass="0.251652" diaginertia="0.000689546 0.000650316 0.000468142" />
<joint name="vx300s_right/wrist_rotate" pos="0 0 0" axis="1 0 0" limited="true" range="-3.14158 3.14158" frictionloss="30" /> <joint name="vx300s_right/wrist_rotate" pos="0 0 0" axis="1 0 0" limited="true" range="-3.14158 3.14158" frictionloss="30" />
<geom pos="-0.02 0 0" quat="0.707107 0 0 0.707107" type="mesh" mesh="vx300s_7_gripper" name="vx300s_right/7_gripper" /> <geom pos="-0.02 0 0" quat="0.707107 0 0 0.707107" type="mesh" mesh="vx300s_7_gripper" name="vx300s_right/7_gripper" />

77
commands.txt 普通文件
查看文件

@ -0,0 +1,77 @@
conda activate mimic
export MUJOCO_GL=egl
cd /home/tonyzhao/Research/act-plus-plus
python3 imitate_episodes.py \
--task_name sim_transfer_cube_human \
--ckpt_dir /scr/tonyzhao/train_logs/vq_test \
--policy_class ACT --kl_weight 10 --chunk_size 100 \
--hidden_dim 512 --batch_size 8 --dim_feedforward 3200 \
--num_epochs 10000 --lr 1e-5 --seed 0 --vq
conda activate mobile
cd /home/tonyzhao/Research/act-plus-plus
CUDA_VISIBLE_DEVICES=0 python3 imitate_episodes.py \
--task_name all \
--ckpt_dir /scr/tonyzhao/train_logs/pretrain_all \
--policy_class ACT --kl_weight 10 --chunk_size 50 \
--hidden_dim 512 --batch_size 24 --dim_feedforward 3200 --num_epochs 5000 --lr 1e-4 --seed 0
#### NOTE to reproduce this experiment, uncomment the sim data filtering in utils.py
conda activate mobile
cd /home/tonyzhao/Research/act-plus-plus
CUDA_VISIBLE_DEVICES=0 python3 imitate_episodes.py \
--task_name all \
--ckpt_dir /scr/tonyzhao/train_logs/pretrain_all \
--policy_class ACT --kl_weight 10 --chunk_size 50 \
--hidden_dim 512 --batch_size 24 --dim_feedforward 3200 --lr 1e-4 --seed 0 \
--num_steps 1000000 --eval_every 10000000000 --validate_every 2000 --save_every 5000
# generate mirrored data
conda activate mobile
cd /home/tonyzhao/Research/act-plus-plus
python3 record_sim_episodes.py --task_name sim_transfer_cube_scripted_mirror --dataset_dir /scr/tonyzhao/datasets/sim_transfer_cube_scripted_mirror --num_episodes 50
python3 postprocess_episodes.py --dataset_dir /scr/tonyzhao/datasets/sim_transfer_cube_scripted_mirror --num_episodes 50
# the sim_transfer_cube_scripted_mirror will have 100 episodes
# I then copy the whole dir to sim_transfer_cube_scripted then removed all mirrored episodes
# this gives sim_transfer_cube_scripted_mirror (100 episodes) and sim_transfer_cube_scripted (50 episodes)
# visualize the original data
python3 visualize_episodes.py --dataset_dir /scr/tonyzhao/datasets/sim_transfer_cube_scripted_mirror --episode_idx 0
# visualize the artificially mirrored data
python3 visualize_episodes.py --dataset_dir /scr/tonyzhao/datasets/sim_transfer_cube_scripted_mirror --episode_idx 0 --ismirror
# sanity check
# replay the mirrored data action in the original env
python3 replay_episodes.py --dataset_path /scr/tonyzhao/datasets/sim_transfer_cube_scripted_mirror/mirror_episode_0.hdf5
# replay the original data action in the original env
python3 replay_episodes.py --dataset_path /scr/tonyzhao/datasets/sim_transfer_cube_scripted_mirror/episode_0.hdf5
# launch experiment on original data
conda activate mobile
export MUJOCO_GL=egl
cd /home/tonyzhao/Research/act-plus-plus
CUDA_VISIBLE_DEVICES=0 python3 imitate_episodes.py \
--task_name sim_transfer_cube_scripted \
--ckpt_dir /scr/tonyzhao/train_logs/cube_scripted \
--policy_class ACT --kl_weight 10 --chunk_size 50 \
--hidden_dim 512 --batch_size 12 --dim_feedforward 3200 --lr 1e-5 --seed 0 \
--num_steps 100000 --eval_every 2000 --validate_every 2000 --save_every 2000
# launch experiment on all data
conda activate mobile
export MUJOCO_GL=egl
cd /home/tonyzhao/Research/act-plus-plus
CUDA_VISIBLE_DEVICES=0 python3 imitate_episodes.py \
--task_name sim_transfer_cube_scripted_mirror \
--ckpt_dir /scr/tonyzhao/train_logs/cube_scripted_mirror \
--policy_class ACT --kl_weight 10 --chunk_size 50 \
--hidden_dim 512 --batch_size 12 --dim_feedforward 3200 --lr 1e-5 --seed 0 \
--num_steps 100000 --eval_every 2000 --validate_every 2000 --save_every 2000

查看文件

@ -1,13 +1,14 @@
import pathlib import pathlib
import os
### Task parameters ### Task parameters
DATA_DIR = 'data' DATA_DIR = '/home/zfu/interbotix_ws/src/act/data' if os.getlogin() == 'zfu' else '/scr/tonyzhao/datasets'
SIM_TASK_CONFIGS = { SIM_TASK_CONFIGS = {
'sim_transfer_cube_scripted':{ 'sim_transfer_cube_scripted':{
'dataset_dir': DATA_DIR + '/sim_transfer_cube_scripted', 'dataset_dir': DATA_DIR + '/sim_transfer_cube_scripted',
'num_episodes': 50, 'num_episodes': 50,
'episode_len': 400, 'episode_len': 400,
'camera_names': ['top'] 'camera_names': ['top', 'left_wrist', 'right_wrist']
}, },
'sim_transfer_cube_human':{ 'sim_transfer_cube_human':{
@ -21,7 +22,7 @@ SIM_TASK_CONFIGS = {
'dataset_dir': DATA_DIR + '/sim_insertion_scripted', 'dataset_dir': DATA_DIR + '/sim_insertion_scripted',
'num_episodes': 50, 'num_episodes': 50,
'episode_len': 400, 'episode_len': 400,
'camera_names': ['top'] 'camera_names': ['top', 'left_wrist', 'right_wrist']
}, },
'sim_insertion_human': { 'sim_insertion_human': {
@ -30,6 +31,28 @@ SIM_TASK_CONFIGS = {
'episode_len': 500, 'episode_len': 500,
'camera_names': ['top'] 'camera_names': ['top']
}, },
'all': {
'dataset_dir': DATA_DIR + '/',
'num_episodes': None,
'episode_len': None,
'name_filter': lambda n: 'sim' not in n,
'camera_names': ['cam_high', 'cam_left_wrist', 'cam_right_wrist']
},
'sim_transfer_cube_scripted_mirror':{
'dataset_dir': DATA_DIR + '/sim_transfer_cube_scripted_mirror',
'num_episodes': None,
'episode_len': 400,
'camera_names': ['top', 'left_wrist', 'right_wrist']
},
'sim_insertion_scripted_mirror': {
'dataset_dir': DATA_DIR + '/sim_insertion_scripted_mirror',
'num_episodes': None,
'episode_len': 400,
'camera_names': ['top', 'left_wrist', 'right_wrist']
},
} }
### Simulation envs fixed constants ### Simulation envs fixed constants

查看文件

@ -59,7 +59,7 @@ def get_args_parser():
parser.add_argument('--policy_class', action='store', type=str, help='policy_class, capitalize', required=True) parser.add_argument('--policy_class', action='store', type=str, help='policy_class, capitalize', required=True)
parser.add_argument('--task_name', action='store', type=str, help='task_name', required=True) parser.add_argument('--task_name', action='store', type=str, help='task_name', required=True)
parser.add_argument('--seed', action='store', type=int, help='seed', required=True) parser.add_argument('--seed', action='store', type=int, help='seed', required=True)
parser.add_argument('--num_epochs', action='store', type=int, help='num_epochs', required=True) parser.add_argument('--num_steps', action='store', type=int, help='num_epochs', required=True)
parser.add_argument('--kl_weight', action='store', type=int, help='KL Weight', required=False) parser.add_argument('--kl_weight', action='store', type=int, help='KL Weight', required=False)
parser.add_argument('--chunk_size', action='store', type=int, help='chunk_size', required=False) parser.add_argument('--chunk_size', action='store', type=int, help='chunk_size', required=False)
parser.add_argument('--temporal_agg', action='store_true') parser.add_argument('--temporal_agg', action='store_true')
@ -69,6 +69,12 @@ def get_args_parser():
parser.add_argument('--vq_dim', action='store', type=int, help='vq_dim', required=False) parser.add_argument('--vq_dim', action='store', type=int, help='vq_dim', required=False)
parser.add_argument('--load_pretrain', action='store_true', default=False) parser.add_argument('--load_pretrain', action='store_true', default=False)
parser.add_argument('--action_dim', action='store', type=int, required=False) parser.add_argument('--action_dim', action='store', type=int, required=False)
parser.add_argument('--eval_every', action='store', type=int, default=500, help='eval_every', required=False)
parser.add_argument('--validate_every', action='store', type=int, default=500, help='validate_every', required=False)
parser.add_argument('--save_every', action='store', type=int, default=500, help='save_every', required=False)
parser.add_argument('--resume_ckpt_path', action='store', type=str, help='load_ckpt_path', required=False)
parser.add_argument('--no_encoder', action='store_true')
parser.add_argument('--skip_mirrored_data', action='store_true')
return parser return parser

查看文件

@ -88,9 +88,14 @@ class DETRVAE(nn.Module):
def encode(self, qpos, actions=None, is_pad=None, vq_sample=None): def encode(self, qpos, actions=None, is_pad=None, vq_sample=None):
bs, _ = qpos.shape
if self.encoder is None:
latent_sample = torch.zeros([bs, self.latent_dim], dtype=torch.float32).to(qpos.device)
latent_input = self.latent_out_proj(latent_sample)
probs = binaries = mu = logvar = None
else:
# cvae encoder # cvae encoder
is_training = actions is not None # train or val is_training = actions is not None # train or val
bs, _ = qpos.shape
### Obtain latent z from action sequence ### Obtain latent z from action sequence
if is_training: if is_training:
# project action sequence to embedding dim, and concat with a CLS token # project action sequence to embedding dim, and concat with a CLS token
@ -136,7 +141,6 @@ class DETRVAE(nn.Module):
latent_sample = torch.zeros([bs, self.latent_dim], dtype=torch.float32).to(qpos.device) latent_sample = torch.zeros([bs, self.latent_dim], dtype=torch.float32).to(qpos.device)
latent_input = self.latent_out_proj(latent_sample) latent_input = self.latent_out_proj(latent_sample)
return latent_input, probs, binaries, mu, logvar return latent_input, probs, binaries, mu, logvar
def forward(self, qpos, image, env_state, actions=None, is_pad=None, vq_sample=None): def forward(self, qpos, image, env_state, actions=None, is_pad=None, vq_sample=None):
@ -275,7 +279,10 @@ def build(args):
transformer = build_transformer(args) transformer = build_transformer(args)
encoder = build_encoder(args) if args.no_encoder:
encoder = None
else:
encoder = build_transformer(args)
model = DETRVAE( model = DETRVAE(
backbones, backbones,

查看文件

@ -83,10 +83,10 @@ class BimanualViperXEETask(base.Task):
# (2) get env._physics.named.data.xpos['vx300s_left/gripper_link'] # (2) get env._physics.named.data.xpos['vx300s_left/gripper_link']
# get env._physics.named.data.xquat['vx300s_left/gripper_link'] # get env._physics.named.data.xquat['vx300s_left/gripper_link']
# repeat the same for right side # repeat the same for right side
np.copyto(physics.data.mocap_pos[0], [-0.31718881, 0.5, 0.29525084]) np.copyto(physics.data.mocap_pos[0], [-0.31718881+0.1, 0.5, 0.29525084])
np.copyto(physics.data.mocap_quat[0], [1, 0, 0, 0]) np.copyto(physics.data.mocap_quat[0], [1, 0, 0, 0])
# right # right
np.copyto(physics.data.mocap_pos[1], np.array([0.31718881, 0.49999888, 0.29525084])) np.copyto(physics.data.mocap_pos[1], np.array([0.31718881-0.1, 0.49999888, 0.29525084]))
np.copyto(physics.data.mocap_quat[1], [1, 0, 0, 0]) np.copyto(physics.data.mocap_quat[1], [1, 0, 0, 0])
# reset gripper control # reset gripper control
@ -136,8 +136,8 @@ class BimanualViperXEETask(base.Task):
obs['env_state'] = self.get_env_state(physics) obs['env_state'] = self.get_env_state(physics)
obs['images'] = dict() obs['images'] = dict()
obs['images']['top'] = physics.render(height=480, width=640, camera_id='top') obs['images']['top'] = physics.render(height=480, width=640, camera_id='top')
obs['images']['angle'] = physics.render(height=480, width=640, camera_id='angle') # obs['images']['angle'] = physics.render(height=480, width=640, camera_id='angle')
obs['images']['vis'] = physics.render(height=480, width=640, camera_id='front_close') # obs['images']['vis'] = physics.render(height=480, width=640, camera_id='front_close')
# used in scripted policy to obtain starting pose # used in scripted policy to obtain starting pose
obs['mocap_pose_left'] = np.concatenate([physics.data.mocap_pos[0], physics.data.mocap_quat[0]]).copy() obs['mocap_pose_left'] = np.concatenate([physics.data.mocap_pos[0], physics.data.mocap_quat[0]]).copy()
obs['mocap_pose_right'] = np.concatenate([physics.data.mocap_pos[1], physics.data.mocap_quat[1]]).copy() obs['mocap_pose_right'] = np.concatenate([physics.data.mocap_pos[1], physics.data.mocap_quat[1]]).copy()

查看文件

@ -5,8 +5,10 @@ import pickle
import argparse import argparse
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
from copy import deepcopy from copy import deepcopy
from itertools import repeat
from tqdm import tqdm from tqdm import tqdm
from einops import rearrange from einops import rearrange
import wandb
from constants import DT from constants import DT
from constants import PUPPET_GRIPPER_JOINT_OPEN from constants import PUPPET_GRIPPER_JOINT_OPEN
@ -33,11 +35,15 @@ def main(args):
task_name = args['task_name'] task_name = args['task_name']
batch_size_train = args['batch_size'] batch_size_train = args['batch_size']
batch_size_val = args['batch_size'] batch_size_val = args['batch_size']
num_epochs = args['num_epochs'] num_steps = args['num_steps']
eval_every = args['eval_every']
validate_every = args['validate_every']
save_every = args['save_every']
resume_ckpt_path = args['resume_ckpt_path']
# get task parameters # get task parameters
is_sim = task_name[:4] == 'sim_' is_sim = task_name[:4] == 'sim_'
if is_sim: if is_sim or task_name == 'all':
from constants import SIM_TASK_CONFIGS from constants import SIM_TASK_CONFIGS
task_config = SIM_TASK_CONFIGS[task_name] task_config = SIM_TASK_CONFIGS[task_name]
else: else:
@ -47,6 +53,7 @@ def main(args):
num_episodes = task_config['num_episodes'] num_episodes = task_config['num_episodes']
episode_len = task_config['episode_len'] episode_len = task_config['episode_len']
camera_names = task_config['camera_names'] camera_names = task_config['camera_names']
name_filter = task_config.get('name_filter', lambda n: True)
# fixed parameters # fixed parameters
state_dim = 14 state_dim = 14
@ -70,7 +77,8 @@ def main(args):
'vq': args['use_vq'], 'vq': args['use_vq'],
'vq_class': args['vq_class'], 'vq_class': args['vq_class'],
'vq_dim': args['vq_dim'], 'vq_dim': args['vq_dim'],
'action_dim': 16 'action_dim': 16,
'no_encoder': args['no_encoder'],
} }
elif policy_class == 'CNNMLP': elif policy_class == 'CNNMLP':
policy_config = {'lr': args['lr'], 'lr_backbone': lr_backbone, 'backbone' : backbone, 'num_queries': 1, policy_config = {'lr': args['lr'], 'lr_backbone': lr_backbone, 'backbone' : backbone, 'num_queries': 1,
@ -79,8 +87,12 @@ def main(args):
raise NotImplementedError raise NotImplementedError
config = { config = {
'num_epochs': num_epochs, 'num_steps': num_steps,
'eval_every': eval_every,
'validate_every': validate_every,
'save_every': save_every,
'ckpt_dir': ckpt_dir, 'ckpt_dir': ckpt_dir,
'resume_ckpt_path': resume_ckpt_path,
'episode_len': episode_len, 'episode_len': episode_len,
'state_dim': state_dim, 'state_dim': state_dim,
'lr': args['lr'], 'lr': args['lr'],
@ -95,11 +107,21 @@ def main(args):
'load_pretrain': args['load_pretrain'] 'load_pretrain': args['load_pretrain']
} }
if not os.path.isdir(ckpt_dir):
os.makedirs(ckpt_dir)
config_path = os.path.join(ckpt_dir, 'config.pkl')
expr_name = ckpt_dir.split('/')[-1]
if not is_eval:
wandb.init(project="mobile-aloha", reinit=True, entity="mobile-aloha", name=expr_name)
wandb.config.update(config)
with open(config_path, 'wb') as f:
pickle.dump(config, f)
if is_eval: if is_eval:
ckpt_names = [f'policy_last.ckpt'] ckpt_names = [f'policy_last.ckpt']
results = [] results = []
for ckpt_name in ckpt_names: for ckpt_name in ckpt_names:
success_rate, avg_return = eval_bc(config, ckpt_name, save_episode=True) success_rate, avg_return = eval_bc(config, ckpt_name, save_episode=True, num_rollouts=1)
# wandb.log({'success_rate': success_rate, 'avg_return': avg_return})
results.append([ckpt_name, success_rate, avg_return]) results.append([ckpt_name, success_rate, avg_return])
for ckpt_name, success_rate, avg_return in results: for ckpt_name, success_rate, avg_return in results:
@ -107,22 +129,21 @@ def main(args):
print() print()
exit() exit()
train_dataloader, val_dataloader, stats, _ = load_data(dataset_dir, num_episodes, camera_names, batch_size_train, batch_size_val, load_pretrain=config['load_pretrain']) train_dataloader, val_dataloader, stats, _ = load_data(dataset_dir, name_filter, camera_names, batch_size_train, batch_size_val, args['chunk_size'], args['skip_mirrored_data'], config['load_pretrain'])
# save dataset stats # save dataset stats
if not os.path.isdir(ckpt_dir):
os.makedirs(ckpt_dir)
stats_path = os.path.join(ckpt_dir, f'dataset_stats.pkl') stats_path = os.path.join(ckpt_dir, f'dataset_stats.pkl')
with open(stats_path, 'wb') as f: with open(stats_path, 'wb') as f:
pickle.dump(stats, f) pickle.dump(stats, f)
best_ckpt_info = train_bc(train_dataloader, val_dataloader, config) best_ckpt_info = train_bc(train_dataloader, val_dataloader, config)
best_epoch, min_val_loss, best_state_dict = best_ckpt_info best_step, min_val_loss, best_state_dict = best_ckpt_info
# save best checkpoint # save best checkpoint
ckpt_path = os.path.join(ckpt_dir, f'policy_best.ckpt') ckpt_path = os.path.join(ckpt_dir, f'policy_best.ckpt')
torch.save(best_state_dict, ckpt_path) torch.save(best_state_dict, ckpt_path)
print(f'Best ckpt, val loss {min_val_loss:.6f} @ epoch{best_epoch}') print(f'Best ckpt, val loss {min_val_loss:.6f} @ step{best_step}')
wandb.finish()
def make_policy(policy_class, policy_config): def make_policy(policy_class, policy_config):
@ -155,7 +176,7 @@ def get_image(ts, camera_names):
return curr_image return curr_image
def eval_bc(config, ckpt_name, save_episode=True): def eval_bc(config, ckpt_name, save_episode=True, num_rollouts=50):
set_seed(1000) set_seed(1000)
ckpt_dir = config['ckpt_dir'] ckpt_dir = config['ckpt_dir']
state_dim = config['state_dim'] state_dim = config['state_dim']
@ -213,7 +234,6 @@ def eval_bc(config, ckpt_name, save_episode=True):
max_timesteps = int(max_timesteps * 1) # may increase for real-world tasks max_timesteps = int(max_timesteps * 1) # may increase for real-world tasks
num_rollouts = 1
episode_returns = [] episode_returns = []
highest_rewards = [] highest_rewards = []
for rollout_id in range(num_rollouts): for rollout_id in range(num_rollouts):
@ -299,7 +319,10 @@ def eval_bc(config, ckpt_name, save_episode=True):
base_action = calibrate_linear_vel(base_action, c=0) base_action = calibrate_linear_vel(base_action, c=0)
### step the environment ### step the environment
if real_robot:
ts = env.step(target_qpos, base_action) ts = env.step(target_qpos, base_action)
else:
ts = env.step(target_qpos)
### for visualization ### for visualization
qpos_list.append(qpos_numpy) qpos_list.append(qpos_numpy)
@ -349,11 +372,14 @@ def forward_pass(data, policy):
def train_bc(train_dataloader, val_dataloader, config): def train_bc(train_dataloader, val_dataloader, config):
num_epochs = config['num_epochs'] num_steps = config['num_steps']
ckpt_dir = config['ckpt_dir'] ckpt_dir = config['ckpt_dir']
seed = config['seed'] seed = config['seed']
policy_class = config['policy_class'] policy_class = config['policy_class']
policy_config = config['policy_config'] policy_config = config['policy_config']
eval_every = config['eval_every']
validate_every = config['validate_every']
save_every = config['save_every']
set_seed(seed) set_seed(seed)
@ -361,88 +387,84 @@ def train_bc(train_dataloader, val_dataloader, config):
if config['load_pretrain']: if config['load_pretrain']:
loading_status = policy.load_state_dict(torch.load(os.path.join('/home/zfu/interbotix_ws/src/act/ckpts/pretrain_all', 'policy_step_50000_seed_0.ckpt'))) loading_status = policy.load_state_dict(torch.load(os.path.join('/home/zfu/interbotix_ws/src/act/ckpts/pretrain_all', 'policy_step_50000_seed_0.ckpt')))
print(f'loaded! {loading_status}') print(f'loaded! {loading_status}')
if config['resume_ckpt_path'] is not None:
loading_status = policy.load_state_dict(torch.load(config['resume_ckpt_path']))
print(f'Resume policy from: {config["resume_ckpt_path"]}, Status: {loading_status}')
policy.cuda() policy.cuda()
optimizer = make_optimizer(policy_class, policy) optimizer = make_optimizer(policy_class, policy)
train_history = []
validation_history = []
min_val_loss = np.inf min_val_loss = np.inf
best_ckpt_info = None best_ckpt_info = None
for epoch in tqdm(range(num_epochs)):
print(f'\nEpoch {epoch}') train_dataloader = repeater(train_dataloader)
for step in tqdm(range(num_steps+1)):
# validation # validation
if step % validate_every == 0:
print('validating')
with torch.inference_mode(): with torch.inference_mode():
policy.eval() policy.eval()
epoch_dicts = [] validation_dicts = []
for batch_idx, data in enumerate(val_dataloader): for batch_idx, data in enumerate(val_dataloader):
forward_dict = forward_pass(data, policy) forward_dict = forward_pass(data, policy)
epoch_dicts.append(forward_dict) validation_dicts.append(forward_dict)
epoch_summary = compute_dict_mean(epoch_dicts)
validation_history.append(epoch_summary)
epoch_val_loss = epoch_summary['loss'] validation_summary = compute_dict_mean(validation_dicts)
epoch_val_loss = validation_summary['loss']
if epoch_val_loss < min_val_loss: if epoch_val_loss < min_val_loss:
min_val_loss = epoch_val_loss min_val_loss = epoch_val_loss
best_ckpt_info = (epoch, min_val_loss, deepcopy(policy.state_dict())) best_ckpt_info = (step, min_val_loss, deepcopy(policy.state_dict()))
for k in validation_summary.keys():
validation_summary[f'val_{k}'] = validation_summary.pop(k)
wandb.log(validation_summary, step=step)
print(f'Val loss: {epoch_val_loss:.5f}') print(f'Val loss: {epoch_val_loss:.5f}')
summary_string = '' summary_string = ''
for k, v in epoch_summary.items(): for k, v in validation_summary.items():
summary_string += f'{k}: {v.item():.3f} ' summary_string += f'{k}: {v.item():.3f} '
print(summary_string) print(summary_string)
# evaluation
if (step > 0) and (step % eval_every == 0):
# first save then eval
ckpt_name = f'policy_step_{step}_seed_{seed}.ckpt'
ckpt_path = os.path.join(ckpt_dir, ckpt_name)
torch.save(policy.state_dict(), ckpt_path)
success, _ = eval_bc(config, ckpt_name, save_episode=True, num_rollouts=10)
wandb.log({'success': success}, step=step)
# training # training
policy.train() policy.train()
optimizer.zero_grad() optimizer.zero_grad()
for batch_idx, data in enumerate(train_dataloader): data = next(train_dataloader)
forward_dict = forward_pass(data, policy) forward_dict = forward_pass(data, policy)
# backward # backward
loss = forward_dict['loss'] loss = forward_dict['loss']
loss.backward() loss.backward()
optimizer.step() optimizer.step()
optimizer.zero_grad() wandb.log(forward_dict, step=step) # not great, make training 1-2% slower
train_history.append(detach_dict(forward_dict))
epoch_summary = compute_dict_mean(train_history[(batch_idx+1)*epoch:(batch_idx+1)*(epoch+1)])
epoch_train_loss = epoch_summary['loss']
print(f'Train loss: {epoch_train_loss:.5f}')
summary_string = ''
for k, v in epoch_summary.items():
summary_string += f'{k}: {v.item():.3f} '
print(summary_string)
if epoch % 1000 == 0: if step % save_every == 0:
ckpt_path = os.path.join(ckpt_dir, f'policy_epoch_{epoch}_seed_{seed}.ckpt') ckpt_path = os.path.join(ckpt_dir, f'policy_step_{step}_seed_{seed}.ckpt')
torch.save(policy.state_dict(), ckpt_path) torch.save(policy.state_dict(), ckpt_path)
plot_history(train_history, validation_history, epoch, ckpt_dir, seed)
ckpt_path = os.path.join(ckpt_dir, f'policy_last.ckpt') ckpt_path = os.path.join(ckpt_dir, f'policy_last.ckpt')
torch.save(policy.state_dict(), ckpt_path) torch.save(policy.state_dict(), ckpt_path)
best_epoch, min_val_loss, best_state_dict = best_ckpt_info best_step, min_val_loss, best_state_dict = best_ckpt_info
ckpt_path = os.path.join(ckpt_dir, f'policy_epoch_{best_epoch}_seed_{seed}.ckpt') ckpt_path = os.path.join(ckpt_dir, f'policy_step_{best_step}_seed_{seed}.ckpt')
torch.save(best_state_dict, ckpt_path) torch.save(best_state_dict, ckpt_path)
print(f'Training finished:\nSeed {seed}, val loss {min_val_loss:.6f} at epoch {best_epoch}') print(f'Training finished:\nSeed {seed}, val loss {min_val_loss:.6f} at step {best_step}')
# save training curves
plot_history(train_history, validation_history, num_epochs, ckpt_dir, seed)
return best_ckpt_info return best_ckpt_info
def repeater(data_loader):
def plot_history(train_history, validation_history, num_epochs, ckpt_dir, seed): epoch = 0
# save training curves for loader in repeat(data_loader):
for key in train_history[0]: for data in loader:
plot_path = os.path.join(ckpt_dir, f'train_val_{key}_seed_{seed}.png') yield data
plt.figure() print(f'Epoch {epoch} done')
train_values = [summary[key].item() for summary in train_history] epoch += 1
val_values = [summary[key].item() for summary in validation_history]
plt.plot(np.linspace(0, num_epochs-1, len(train_history)), train_values, label='train')
plt.plot(np.linspace(0, num_epochs-1, len(validation_history)), val_values, label='validation')
# plt.ylim([-0.1, 1])
plt.tight_layout()
plt.legend()
plt.title(key)
plt.savefig(plot_path)
print(f'Saved plots to {ckpt_dir}')
if __name__ == '__main__': if __name__ == '__main__':
@ -454,9 +476,14 @@ if __name__ == '__main__':
parser.add_argument('--task_name', action='store', type=str, help='task_name', required=True) parser.add_argument('--task_name', action='store', type=str, help='task_name', required=True)
parser.add_argument('--batch_size', action='store', type=int, help='batch_size', required=True) parser.add_argument('--batch_size', action='store', type=int, help='batch_size', required=True)
parser.add_argument('--seed', action='store', type=int, help='seed', required=True) parser.add_argument('--seed', action='store', type=int, help='seed', required=True)
parser.add_argument('--num_epochs', action='store', type=int, help='num_epochs', required=True) parser.add_argument('--num_steps', action='store', type=int, help='num_steps', required=True)
parser.add_argument('--lr', action='store', type=float, help='lr', required=True) parser.add_argument('--lr', action='store', type=float, help='lr', required=True)
parser.add_argument('--load_pretrain', action='store_true', default=False) parser.add_argument('--load_pretrain', action='store_true', default=False)
parser.add_argument('--eval_every', action='store', type=int, default=500, help='eval_every', required=False)
parser.add_argument('--validate_every', action='store', type=int, default=500, help='validate_every', required=False)
parser.add_argument('--save_every', action='store', type=int, default=500, help='save_every', required=False)
parser.add_argument('--resume_ckpt_path', action='store', type=str, help='resume_ckpt_path', required=False)
parser.add_argument('--skip_mirrored_data', action='store_true')
# for ACT # for ACT
parser.add_argument('--kl_weight', action='store', type=int, help='KL Weight', required=False) parser.add_argument('--kl_weight', action='store', type=int, help='KL Weight', required=False)
@ -467,5 +494,6 @@ if __name__ == '__main__':
parser.add_argument('--use_vq', action='store_true') parser.add_argument('--use_vq', action='store_true')
parser.add_argument('--vq_class', action='store', type=int, help='vq_class') parser.add_argument('--vq_class', action='store', type=int, help='vq_class')
parser.add_argument('--vq_dim', action='store', type=int, help='vq_dim') parser.add_argument('--vq_dim', action='store', type=int, help='vq_dim')
parser.add_argument('--no_encoder', action='store_true')
main(vars(parser.parse_args())) main(vars(parser.parse_args()))

查看文件

@ -28,11 +28,12 @@ class ACTPolicy(nn.Module):
loss_dict = dict() loss_dict = dict()
a_hat, is_pad_hat, (mu, logvar), probs, binaries = self.model(qpos, image, env_state, actions, is_pad, vq_sample) a_hat, is_pad_hat, (mu, logvar), probs, binaries = self.model(qpos, image, env_state, actions, is_pad, vq_sample)
if self.vq: if self.vq or self.model.encoder is None:
total_kld = [torch.tensor(0.0)] total_kld = [torch.tensor(0.0)]
loss_dict['vq_discrepancy'] = F.l1_loss(probs, binaries, reduction='mean')
else: else:
total_kld, dim_wise_kld, mean_kld = kl_divergence(mu, logvar) total_kld, dim_wise_kld, mean_kld = kl_divergence(mu, logvar)
if self.vq:
loss_dict['vq_discrepancy'] = F.l1_loss(probs, binaries, reduction='mean')
all_l1 = F.l1_loss(actions, a_hat, reduction='none') all_l1 = F.l1_loss(actions, a_hat, reduction='none')
l1 = (all_l1 * ~is_pad.unsqueeze(-1)).mean() l1 = (all_l1 * ~is_pad.unsqueeze(-1)).mean()
loss_dict['l1'] = l1 loss_dict['l1'] = l1

119
postprocess_episodes.py 普通文件
查看文件

@ -0,0 +1,119 @@
import os
import numpy as np
import cv2
import h5py
import argparse
import time
from visualize_episodes import visualize_joints, visualize_timestamp, save_videos
import matplotlib.pyplot as plt
from constants import DT
import IPython
e = IPython.embed
JOINT_NAMES = ["waist", "shoulder", "elbow", "forearm_roll", "wrist_angle", "wrist_rotate"]
STATE_NAMES = JOINT_NAMES + ["gripper"]
MIRROR_STATE_MULTIPLY = np.array([-1, 1, 1, -1, 1, -1, 1]).astype('float32')
MIRROR_BASE_MULTIPLY = np.array([1, -1]).astype('float32')
def load_hdf5(dataset_dir, dataset_name):
dataset_path = os.path.join(dataset_dir, dataset_name + '.hdf5')
if not os.path.isfile(dataset_path):
print(f'Dataset does not exist at \n{dataset_path}\n')
exit()
with h5py.File(dataset_path, 'r') as root:
is_sim = root.attrs['sim']
qpos = root['/observations/qpos'][()]
qvel = root['/observations/qvel'][()]
action = root['/action'][()]
image_dict = dict()
for cam_name in root[f'/observations/images/'].keys():
image_dict[cam_name] = root[f'/observations/images/{cam_name}'][()]
if 'base_action' in root.keys():
print('base_action exists')
base_action = root['/base_action'][()]
else:
base_action = None
return qpos, qvel, action, base_action, image_dict
def main(args):
dataset_dir = args['dataset_dir']
num_episodes = args['num_episodes']
for episode_idx in range(num_episodes):
dataset_name = f'episode_{episode_idx}'
qpos, qvel, action, base_action, image_dict = load_hdf5(dataset_dir, dataset_name)
# process proprioception
qpos = np.concatenate([qpos[:, 7:] * MIRROR_STATE_MULTIPLY, qpos[:, :7] * MIRROR_STATE_MULTIPLY], axis=1)
qvel = np.concatenate([qvel[:, 7:] * MIRROR_STATE_MULTIPLY, qvel[:, :7] * MIRROR_STATE_MULTIPLY], axis=1)
action = np.concatenate([action[:, 7:] * MIRROR_STATE_MULTIPLY, action[:, :7] * MIRROR_STATE_MULTIPLY], axis=1)
if base_action is not None:
base_action = base_action * MIRROR_BASE_MULTIPLY
# mirror image obs
if 'left_wrist' in image_dict.keys():
image_dict['left_wrist'], image_dict['right_wrist'] = image_dict['right_wrist'][:, :, ::-1], image_dict['left_wrist'][:, :, ::-1]
elif 'cam_left_wrist':
image_dict['cam_left_wrist'], image_dict['cam_right_wrist'] = image_dict['cam_right_wrist'][:, :, ::-1], image_dict['cam_left_wrist'][:, :, ::-1]
else:
raise Exception('No left_wrist or cam_left_wrist in image_dict')
if 'top' in image_dict.keys():
image_dict['top'] = image_dict['top'][:, :, ::-1]
elif 'cam_high' in image_dict.keys():
image_dict['cam_high'] = image_dict['cam_high'][:, :, ::-1]
else:
raise Exception('No top or cam_high in image_dict')
# saving
data_dict = {
'/observations/qpos': qpos,
'/observations/qvel': qvel,
'/action': action,
'/base_action': base_action,
} if base_action is not None else {
'/observations/qpos': qpos,
'/observations/qvel': qvel,
'/action': action,
}
for cam_name in image_dict.keys():
data_dict[f'/observations/images/{cam_name}'] = image_dict[cam_name]
max_timesteps = len(qpos)
# HDF5
t0 = time.time()
dataset_path = os.path.join(dataset_dir, f'mirror_episode_{episode_idx}')
with h5py.File(dataset_path + '.hdf5', 'w', rdcc_nbytes=1024 ** 2 * 2) as root:
root.attrs['sim'] = True
obs = root.create_group('observations')
image = obs.create_group('images')
for cam_name in image_dict.keys():
_ = image.create_dataset(cam_name, (max_timesteps, 480, 640, 3), dtype='uint8',
chunks=(1, 480, 640, 3), )
# compression='gzip',compression_opts=2,)
# compression=32001, compression_opts=(0, 0, 0, 0, 9, 1, 1), shuffle=False)
qpos = obs.create_dataset('qpos', (max_timesteps, 14))
qvel = obs.create_dataset('qvel', (max_timesteps, 14))
action = root.create_dataset('action', (max_timesteps, 14))
if base_action is not None:
base_action = root.create_dataset('base_action', (max_timesteps, 2))
for name, array in data_dict.items():
root[name][...] = array
print(f'Saving {dataset_path}: {time.time() - t0:.1f} secs\n')
# save_videos(image_dict, DT, video_path=os.path.join(dataset_dir, dataset_name + '_mirror_video.mp4'))
# visualize_joints(qpos, action, plot_path=os.path.join(dataset_dir, dataset_name + '_mirror_qpos.png'))
# visualize_timestamp(t_list, dataset_path) # TODO addn timestamp back
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--dataset_dir', action='store', type=str, help='Dataset dir.', required=True)
parser.add_argument('--num_episodes', action='store', type=int, help='Number of episodes.', required=True)
main(vars(parser.parse_args()))

查看文件

@ -28,7 +28,7 @@ def main(args):
num_episodes = args['num_episodes'] num_episodes = args['num_episodes']
onscreen_render = args['onscreen_render'] onscreen_render = args['onscreen_render']
inject_noise = False inject_noise = False
render_cam_name = 'angle' render_cam_name = 'top'
if not os.path.isdir(dataset_dir): if not os.path.isdir(dataset_dir):
os.makedirs(dataset_dir, exist_ok=True) os.makedirs(dataset_dir, exist_ok=True)
@ -39,6 +39,8 @@ def main(args):
policy_cls = PickAndTransferPolicy policy_cls = PickAndTransferPolicy
elif task_name == 'sim_insertion_scripted': elif task_name == 'sim_insertion_scripted':
policy_cls = InsertionPolicy policy_cls = InsertionPolicy
elif task_name == 'sim_transfer_cube_scripted_mirror':
policy_cls = PickAndTransferPolicy
else: else:
raise NotImplementedError raise NotImplementedError

48
replay_episodes.py 普通文件
查看文件

@ -0,0 +1,48 @@
import os
import h5py
import argparse
from collections import defaultdict
from sim_env import make_sim_env
from utils import sample_box_pose, sample_insertion_pose
from sim_env import BOX_POSE
from constants import DT
from visualize_episodes import save_videos
import IPython
e = IPython.embed
def main(args):
dataset_path = args['dataset_path']
if not os.path.isfile(dataset_path):
print(f'Dataset does not exist at \n{dataset_path}\n')
exit()
with h5py.File(dataset_path, 'r') as root:
actions = root['/action'][()]
env = make_sim_env('sim_transfer_cube')
BOX_POSE[0] = sample_box_pose() # used in sim reset
ts = env.reset()
episode_replay = [ts]
for action in actions:
ts = env.step(action)
episode_replay.append(ts)
# saving
image_dict = defaultdict(lambda: [])
while episode_replay:
ts = episode_replay.pop(0)
for cam_name, image in ts.observation['images'].items():
image_dict[cam_name].append(image)
video_path = dataset_path.replace('episode_', 'replay_episode_').replace('hdf5', 'mp4')
save_videos(image_dict, DT, video_path=video_path)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--dataset_path', action='store', type=str, help='Dataset path.', required=True)
main(vars(parser.parse_args()))

查看文件

@ -108,8 +108,10 @@ class BimanualViperXTask(base.Task):
obs['env_state'] = self.get_env_state(physics) obs['env_state'] = self.get_env_state(physics)
obs['images'] = dict() obs['images'] = dict()
obs['images']['top'] = physics.render(height=480, width=640, camera_id='top') obs['images']['top'] = physics.render(height=480, width=640, camera_id='top')
obs['images']['angle'] = physics.render(height=480, width=640, camera_id='angle') obs['images']['left_wrist'] = physics.render(height=480, width=640, camera_id='left_wrist')
obs['images']['vis'] = physics.render(height=480, width=640, camera_id='front_close') obs['images']['right_wrist'] = physics.render(height=480, width=640, camera_id='right_wrist')
# obs['images']['angle'] = physics.render(height=480, width=640, camera_id='angle')
# obs['images']['vis'] = physics.render(height=480, width=640, camera_id='front_close')
return obs return obs

查看文件

@ -47,6 +47,7 @@ def main(args):
num_episodes = task_config['num_episodes'] num_episodes = task_config['num_episodes']
episode_len = task_config['episode_len'] episode_len = task_config['episode_len']
camera_names = task_config['camera_names'] camera_names = task_config['camera_names']
name_filter = task_config.get('name_filter', lambda n: True)
# fixed parameters # fixed parameters
state_dim = 14 state_dim = 14
@ -105,7 +106,7 @@ def main(args):
# print() # print()
# exit() # exit()
train_dataloader, val_dataloader, stats, _ = load_data(dataset_dir, num_episodes, camera_names, batch_size_train, batch_size_val) train_dataloader, val_dataloader, stats, _ = load_data(dataset_dir, name_filter, camera_names, batch_size_train, batch_size_val)
# save dataset stats # save dataset stats
# if not os.path.isdir(ckpt_dir): # if not os.path.isdir(ckpt_dir):

143
utils.py
查看文件

@ -3,43 +3,56 @@ import torch
import os import os
import h5py import h5py
import pickle import pickle
import fnmatch
from torch.utils.data import TensorDataset, DataLoader from torch.utils.data import TensorDataset, DataLoader
import IPython import IPython
e = IPython.embed e = IPython.embed
class EpisodicDataset(torch.utils.data.Dataset): class EpisodicDataset(torch.utils.data.Dataset):
def __init__(self, episode_ids, dataset_dir, camera_names, norm_stats): def __init__(self, dataset_path_list, camera_names, norm_stats, episode_ids, episode_len, chunk_size):
super(EpisodicDataset).__init__() super(EpisodicDataset).__init__()
self.episode_ids = episode_ids self.episode_ids = episode_ids
self.dataset_dir = dataset_dir self.dataset_path_list = dataset_path_list
self.camera_names = camera_names self.camera_names = camera_names
self.norm_stats = norm_stats self.norm_stats = norm_stats
self.is_sim = None self.episode_len = episode_len
self.chunk_size = chunk_size
self.cumulative_len = np.cumsum(self.episode_len)
self.max_episode_len = max(episode_len)
self.__getitem__(0) # initialize self.is_sim self.__getitem__(0) # initialize self.is_sim
self.is_sim = False
def __len__(self): def __len__(self):
return len(self.episode_ids) return sum(self.episode_len)
def _locate_transition(self, index):
assert index < self.cumulative_len[-1]
episode_index = np.argmax(self.cumulative_len > index) # argmax returns first True index
start_ts = index - (self.cumulative_len[episode_index] - self.episode_len[episode_index])
episode_id = self.episode_ids[episode_index]
return episode_id, start_ts
def __getitem__(self, index): def __getitem__(self, index):
sample_full_episode = False # hardcode episode_id, start_ts = self._locate_transition(index)
dataset_path = self.dataset_path_list[episode_id]
episode_id = self.episode_ids[index] try:
dataset_path = os.path.join(self.dataset_dir, f'episode_{episode_id}.hdf5') # print(dataset_path)
with h5py.File(dataset_path, 'r') as root: with h5py.File(dataset_path, 'r') as root:
try: # some legacy data does not have this attribute
is_sim = root.attrs['sim'] is_sim = root.attrs['sim']
except:
is_sim = False
if '/base_action' in root: if '/base_action' in root:
base_action = root['/base_action'][()] base_action = root['/base_action'][()]
base_action = preprocess_base_action(base_action) base_action = preprocess_base_action(base_action)
action = np.concatenate([root['/action'][()], base_action], axis=-1) action = np.concatenate([root['/action'][()], base_action], axis=-1)
else: else:
action = root['/action'][()] action = root['/action'][()]
dummy_base_action = np.zeros([action.shape[0], 2])
action = np.concatenate([action, dummy_base_action], axis=-1)
original_action_shape = action.shape original_action_shape = action.shape
episode_len = original_action_shape[0] episode_len = original_action_shape[0]
if sample_full_episode:
start_ts = 0
else:
start_ts = np.random.choice(episode_len)
# get observation at start_ts only # get observation at start_ts only
qpos = root['/observations/qpos'][start_ts] qpos = root['/observations/qpos'][start_ts]
qvel = root['/observations/qvel'][start_ts] qvel = root['/observations/qvel'][start_ts]
@ -54,12 +67,15 @@ class EpisodicDataset(torch.utils.data.Dataset):
action = action[max(0, start_ts - 1):] # hack, to make timesteps more aligned action = action[max(0, start_ts - 1):] # hack, to make timesteps more aligned
action_len = episode_len - max(0, start_ts - 1) # hack, to make timesteps more aligned action_len = episode_len - max(0, start_ts - 1) # hack, to make timesteps more aligned
self.is_sim = is_sim # self.is_sim = is_sim
padded_action = np.zeros(original_action_shape, dtype=np.float32) padded_action = np.zeros((self.max_episode_len, original_action_shape[1]), dtype=np.float32)
padded_action[:action_len] = action padded_action[:action_len] = action
is_pad = np.zeros(episode_len) is_pad = np.zeros(self.max_episode_len)
is_pad[action_len:] = 1 is_pad[action_len:] = 1
padded_action = padded_action[:self.chunk_size]
padded_action = padded_action[:self.chunk_size]
# new axis for different cameras # new axis for different cameras
all_cam_images = [] all_cam_images = []
for cam_name in self.camera_names: for cam_name in self.camera_names:
@ -80,74 +96,101 @@ class EpisodicDataset(torch.utils.data.Dataset):
action_data = (action_data - self.norm_stats["action_mean"]) / self.norm_stats["action_std"] action_data = (action_data - self.norm_stats["action_mean"]) / self.norm_stats["action_std"]
qpos_data = (qpos_data - self.norm_stats["qpos_mean"]) / self.norm_stats["qpos_std"] qpos_data = (qpos_data - self.norm_stats["qpos_mean"]) / self.norm_stats["qpos_std"]
except:
print(f'Error loading {dataset_path} in __getitem__')
quit()
# print(image_data.dtype, qpos_data.dtype, action_data.dtype, is_pad.dtype)
return image_data, qpos_data, action_data, is_pad return image_data, qpos_data, action_data, is_pad
def get_norm_stats(dataset_dir, num_episodes): def get_norm_stats(dataset_path_list):
all_qpos_data = [] all_qpos_data = []
all_action_data = [] all_action_data = []
for episode_idx in range(num_episodes): all_episode_len = []
dataset_path = os.path.join(dataset_dir, f'episode_{episode_idx}.hdf5')
for dataset_path in dataset_path_list:
try: try:
with h5py.File(dataset_path, 'r') as root: with h5py.File(dataset_path, 'r') as root:
qpos = root['/observations/qpos'][()] qpos = root['/observations/qpos'][()]
qvel = root['/observations/qvel'][()] qvel = root['/observations/qvel'][()]
if '/base_action' in root:
base_action = root['/base_action'][()] base_action = root['/base_action'][()]
base_action = preprocess_base_action(base_action) base_action = preprocess_base_action(base_action)
action = np.concatenate([root['/action'][()], base_action], axis=-1) action = np.concatenate([root['/action'][()], base_action], axis=-1)
except: else:
print(f'Error loading {dataset_path}') action = root['/action'][()]
dummy_base_action = np.zeros([action.shape[0], 2])
action = np.concatenate([action, dummy_base_action], axis=-1)
except Exception as e:
print(f'Error loading {dataset_path} in get_norm_stats')
print(e)
quit() quit()
all_qpos_data.append(torch.from_numpy(qpos)) all_qpos_data.append(torch.from_numpy(qpos))
all_action_data.append(torch.from_numpy(action)) all_action_data.append(torch.from_numpy(action))
all_qpos_data = torch.stack(all_qpos_data) all_episode_len.append(len(qpos))
all_action_data = torch.stack(all_action_data) all_qpos_data = torch.cat(all_qpos_data, dim=0)
all_action_data = all_action_data all_action_data = torch.cat(all_action_data, dim=0)
# normalize action data # normalize action data
action_mean = all_action_data.mean(dim=[0, 1], keepdim=True) action_mean = all_action_data.mean(dim=[0]).float()
action_std = all_action_data.std(dim=[0, 1], keepdim=True) action_std = all_action_data.std(dim=[0]).float()
action_std = torch.clip(action_std, 1e-2, np.inf) # clipping action_std = torch.clip(action_std, 1e-2, np.inf) # clipping
# normalize qpos data # normalize qpos data
qpos_mean = all_qpos_data.mean(dim=[0, 1], keepdim=True) qpos_mean = all_qpos_data.mean(dim=[0]).float()
qpos_std = all_qpos_data.std(dim=[0, 1], keepdim=True) qpos_std = all_qpos_data.std(dim=[0]).float()
qpos_std = torch.clip(qpos_std, 1e-2, np.inf) # clipping qpos_std = torch.clip(qpos_std, 1e-2, np.inf) # clipping
stats = {"action_mean": action_mean.numpy().squeeze(), "action_std": action_std.numpy().squeeze(), stats = {"action_mean": action_mean.numpy(), "action_std": action_std.numpy(),
"qpos_mean": qpos_mean.numpy().squeeze(), "qpos_std": qpos_std.numpy().squeeze(), "qpos_mean": qpos_mean.numpy(), "qpos_std": qpos_std.numpy(),
"example_qpos": qpos} "example_qpos": qpos}
return stats return stats, all_episode_len
def find_all_hdf5(dataset_dir, skip_mirrored_data):
hdf5_files = []
for root, dirs, files in os.walk(dataset_dir):
for filename in fnmatch.filter(files, '*.hdf5'):
if skip_mirrored_data and 'mirror' in filename:
continue
hdf5_files.append(os.path.join(root, filename))
print(f'Found {len(hdf5_files)} hdf5 files')
return hdf5_files
def load_data(dataset_dir, num_episodes, camera_names, batch_size_train, batch_size_val, load_pretrain=False): def load_data(dataset_dir, name_filter, camera_names, batch_size_train, batch_size_val, chunk_size, skip_mirrored_data=False, load_pretrain=False):
print(f'\nData from: {dataset_dir}\n') dataset_path_list = find_all_hdf5(dataset_dir, skip_mirrored_data)
dataset_path_list = [n for n in dataset_path_list if name_filter(n)]
num_episodes = len(dataset_path_list)
# obtain train test split # obtain train test split
train_ratio = 0.99 train_ratio = 0.995
shuffled_indices = np.random.permutation(num_episodes) shuffled_episode_ids = np.random.permutation(num_episodes)
train_indices = shuffled_indices[:int(train_ratio * num_episodes)] train_episode_ids = shuffled_episode_ids[:int(train_ratio * num_episodes)]
val_indices = shuffled_indices[int(train_ratio * num_episodes):] val_episode_ids = shuffled_episode_ids[int(train_ratio * num_episodes):]
print(f'\n\nData from: {dataset_dir}\n- Train on {len(train_episode_ids)} episodes\n- Test on {len(val_episode_ids)} episodes\n\n')
# obtain normalization stats for qpos and action # obtain normalization stats for qpos and action
if load_pretrain: # if load_pretrain:
with open(os.path.join('/home/zfu/interbotix_ws/src/act/ckpts/pretrain_all', 'dataset_stats.pkl'), 'rb') as f: # with open(os.path.join('/home/zfu/interbotix_ws/src/act/ckpts/pretrain_all', 'dataset_stats.pkl'), 'rb') as f:
norm_stats = pickle.load(f) # norm_stats = pickle.load(f)
print('Loaded pretrain dataset stats') # print('Loaded pretrain dataset stats')
else: norm_stats, all_episode_len = get_norm_stats(dataset_path_list)
norm_stats = get_norm_stats(dataset_dir, num_episodes) train_episode_len = [all_episode_len[i] for i in train_episode_ids]
val_episode_len = [all_episode_len[i] for i in val_episode_ids]
# construct dataset and dataloader # construct dataset and dataloader
train_dataset = EpisodicDataset(train_indices, dataset_dir, camera_names, norm_stats) train_dataset = EpisodicDataset(dataset_path_list, camera_names, norm_stats, train_episode_ids, train_episode_len, chunk_size)
val_dataset = EpisodicDataset(val_indices, dataset_dir, camera_names, norm_stats) val_dataset = EpisodicDataset(dataset_path_list, camera_names, norm_stats, val_episode_ids, val_episode_len, chunk_size)
train_dataloader = DataLoader(train_dataset, batch_size=batch_size_train, shuffle=True, pin_memory=True, num_workers=1, prefetch_factor=1, persistent_workers=True) train_dataloader = DataLoader(train_dataset, batch_size=batch_size_train, shuffle=True, pin_memory=True, num_workers=1, prefetch_factor=1)
val_dataloader = DataLoader(val_dataset, batch_size=batch_size_val, shuffle=True, pin_memory=True, num_workers=1, prefetch_factor=1, persistent_workers=True) val_dataloader = DataLoader(val_dataset, batch_size=batch_size_val, shuffle=True, pin_memory=True, num_workers=1, prefetch_factor=1)
return train_dataloader, val_dataloader, norm_stats, train_dataset.is_sim return train_dataloader, val_dataloader, norm_stats, train_dataset.is_sim
def calibrate_linear_vel(base_action, c=None): def calibrate_linear_vel(base_action, c=None):
if c is None: if c is None:
c = 0.19 c = 0.0 # 0.19
v = base_action[..., 0] v = base_action[..., 0]
w = base_action[..., 1] w = base_action[..., 1]
base_action = base_action.copy() base_action = base_action.copy()
@ -156,12 +199,12 @@ def calibrate_linear_vel(base_action, c=None):
def smooth_base_action(base_action): def smooth_base_action(base_action):
return np.stack([ return np.stack([
np.convolve(base_action[:, i], np.ones(20)/20, mode='same') for i in range(base_action.shape[1]) np.convolve(base_action[:, i], np.ones(5)/5, mode='same') for i in range(base_action.shape[1])
], axis=-1) ], axis=-1).astype(np.float32)
def preprocess_base_action(base_action): def preprocess_base_action(base_action):
# base_action = calibrate_linear_vel(base_action) # base_action = calibrate_linear_vel(base_action)
base_action = smooth_base_action(base_action).astype(np.float32) base_action = smooth_base_action(base_action)
return base_action return base_action

查看文件

@ -33,6 +33,10 @@ def load_hdf5(dataset_dir, dataset_name):
def main(args): def main(args):
dataset_dir = args['dataset_dir'] dataset_dir = args['dataset_dir']
episode_idx = args['episode_idx'] episode_idx = args['episode_idx']
ismirror = args['ismirror']
if ismirror:
dataset_name = f'mirror_episode_{episode_idx}'
else:
dataset_name = f'episode_{episode_idx}' dataset_name = f'episode_{episode_idx}'
qpos, qvel, action, image_dict = load_hdf5(dataset_dir, dataset_name) qpos, qvel, action, image_dict = load_hdf5(dataset_dir, dataset_name)
@ -44,6 +48,7 @@ def main(args):
def save_videos(video, dt, video_path=None): def save_videos(video, dt, video_path=None):
if isinstance(video, list): if isinstance(video, list):
cam_names = list(video[0].keys()) cam_names = list(video[0].keys())
cam_names = sorted(cam_names)
h, w, _ = video[0][cam_names[0]].shape h, w, _ = video[0][cam_names[0]].shape
w = w * len(cam_names) w = w * len(cam_names)
fps = int(1/dt) fps = int(1/dt)
@ -60,6 +65,7 @@ def save_videos(video, dt, video_path=None):
print(f'Saved video to: {video_path}') print(f'Saved video to: {video_path}')
elif isinstance(video, dict): elif isinstance(video, dict):
cam_names = list(video.keys()) cam_names = list(video.keys())
cam_names = sorted(cam_names)
all_cam_videos = [] all_cam_videos = []
for cam_name in cam_names: for cam_name in cam_names:
all_cam_videos.append(video[cam_name]) all_cam_videos.append(video[cam_name])
@ -144,4 +150,5 @@ if __name__ == '__main__':
parser = argparse.ArgumentParser() parser = argparse.ArgumentParser()
parser.add_argument('--dataset_dir', action='store', type=str, help='Dataset dir.', required=True) parser.add_argument('--dataset_dir', action='store', type=str, help='Dataset dir.', required=True)
parser.add_argument('--episode_idx', action='store', type=int, help='Episode index.', required=False) parser.add_argument('--episode_idx', action='store', type=int, help='Episode index.', required=False)
parser.add_argument('--ismirror', action='store_true')
main(vars(parser.parse_args())) main(vars(parser.parse_args()))