比较提交
22 次代码提交
| 作者 | SHA1 | 提交日期 | |
|---|---|---|---|
| 637d4f9a93 | |||
| 71c46d8649 | |||
| b7e387a9b9 | |||
| 8f66f3bc88 | |||
| 79e5032002 | |||
| 61decb1e13 | |||
| 5376392e66 | |||
| 329a237290 | |||
| d89430f987 | |||
| 4cec62314b | |||
| 5ab307d5c4 | |||
| b401b8f9d6 | |||
| 902dae2236 | |||
| 60d0da09f8 | |||
| 6afe28b795 | |||
| 8119013853 | |||
| d6bb889d7d | |||
| d0aa344ff0 | |||
| 8f22418a7b | |||
| 654248d96f | |||
| 3474cc38e7 | |||
| ca82042c1c |
31
align.py
普通文件
31
align.py
普通文件
@ -0,0 +1,31 @@
|
|||||||
|
from interbotix_xs_modules.arm import InterbotixManipulatorXS
|
||||||
|
from aloha_scripts.robot_utils import move_arms, torque_on, move_grippers
|
||||||
|
from constants import PUPPET_GRIPPER_JOINT_OPEN, PUPPET_GRIPPER_JOINT_CLOSE
|
||||||
|
import argparse
|
||||||
|
import numpy as np
|
||||||
|
|
||||||
|
# for calibrating head cam and arms being symmetrical
|
||||||
|
|
||||||
|
def main():
|
||||||
|
argparser = argparse.ArgumentParser()
|
||||||
|
argparser.add_argument('--all', action='store_true', default=False)
|
||||||
|
args = argparser.parse_args()
|
||||||
|
|
||||||
|
puppet_bot_left = InterbotixManipulatorXS(robot_model="vx300s", group_name="arm", gripper_name="gripper", robot_name=f'puppet_left', init_node=True)
|
||||||
|
puppet_bot_right = InterbotixManipulatorXS(robot_model="vx300s", group_name="arm", gripper_name="gripper", robot_name=f'puppet_right', init_node=False)
|
||||||
|
|
||||||
|
all_bots = [puppet_bot_left, puppet_bot_right]
|
||||||
|
for bot in all_bots:
|
||||||
|
torque_on(bot)
|
||||||
|
|
||||||
|
multiplier = np.array([-1, 1, 1, -1, 1, 1])
|
||||||
|
puppet_sleep_position_left = np.array([-0.8, -0.5, 0.5, 0, 0.65, 0])
|
||||||
|
puppet_sleep_position_right = puppet_sleep_position_left * multiplier
|
||||||
|
all_positions = [puppet_sleep_position_left, puppet_sleep_position_right]
|
||||||
|
move_arms(all_bots, all_positions, move_time=2)
|
||||||
|
|
||||||
|
# move_grippers(all_bots, [PUPPET_GRIPPER_JOINT_OPEN] * 2, move_time=1) # open
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
main()
|
||||||
85
commands.txt
85
commands.txt
@ -58,7 +58,7 @@ CUDA_VISIBLE_DEVICES=0 python3 imitate_episodes.py \
|
|||||||
--ckpt_dir /scr/tonyzhao/train_logs/cube_scripted \
|
--ckpt_dir /scr/tonyzhao/train_logs/cube_scripted \
|
||||||
--policy_class ACT --kl_weight 10 --chunk_size 50 \
|
--policy_class ACT --kl_weight 10 --chunk_size 50 \
|
||||||
--hidden_dim 512 --batch_size 12 --dim_feedforward 3200 --lr 1e-5 --seed 0 \
|
--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
|
--num_steps 100000 --eval_every 2000 --validate_every 2000 --save_every 2000 --no_encoder
|
||||||
|
|
||||||
|
|
||||||
# launch experiment on all data
|
# launch experiment on all data
|
||||||
@ -70,8 +70,91 @@ CUDA_VISIBLE_DEVICES=0 python3 imitate_episodes.py \
|
|||||||
--ckpt_dir /scr/tonyzhao/train_logs/cube_scripted_mirror \
|
--ckpt_dir /scr/tonyzhao/train_logs/cube_scripted_mirror \
|
||||||
--policy_class ACT --kl_weight 10 --chunk_size 50 \
|
--policy_class ACT --kl_weight 10 --chunk_size 50 \
|
||||||
--hidden_dim 512 --batch_size 12 --dim_feedforward 3200 --lr 1e-5 --seed 0 \
|
--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 --no_encoder
|
||||||
|
|
||||||
|
|
||||||
|
####### DIFFUSION POLICY
|
||||||
|
|
||||||
|
- first install https://github.com/ARISE-Initiative/robomimic/tree/r2d2 (note the r2d2 branch)
|
||||||
|
- on top of it pip install the current repo requirements
|
||||||
|
|
||||||
|
|
||||||
|
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_diffusion_sweep_0 \
|
||||||
|
--policy_class Diffusion --chunk_size 32 \
|
||||||
|
--batch_size 32 --lr 1e-5 --seed 0 \
|
||||||
--num_steps 100000 --eval_every 2000 --validate_every 2000 --save_every 2000
|
--num_steps 100000 --eval_every 2000 --validate_every 2000 --save_every 2000
|
||||||
|
|
||||||
|
|
||||||
|
conda activate mobile
|
||||||
|
export MUJOCO_GL=egl
|
||||||
|
cd /home/tonyzhao/Research/act-plus-plus
|
||||||
|
CUDA_VISIBLE_DEVICES=1 python3 imitate_episodes.py \
|
||||||
|
--task_name sim_transfer_cube_scripted \
|
||||||
|
--ckpt_dir /scr/tonyzhao/train_logs/cube_scripted_diffusion_sweep_1 \
|
||||||
|
--policy_class Diffusion --chunk_size 16 \
|
||||||
|
--batch_size 32 --lr 1e-5 --seed 0 \
|
||||||
|
--num_steps 100000 --eval_every 2000 --validate_every 2000 --save_every 2000
|
||||||
|
|
||||||
|
|
||||||
|
# above are all 100 train diffusion steps, 1e-5
|
||||||
|
|
||||||
|
conda activate mobile
|
||||||
|
export MUJOCO_GL=egl
|
||||||
|
cd /home/tonyzhao/Research/act-plus-plus
|
||||||
|
CUDA_VISIBLE_DEVICES=1 python3 imitate_episodes.py \
|
||||||
|
--task_name sim_transfer_cube_scripted \
|
||||||
|
--ckpt_dir /scr/tonyzhao/train_logs/cube_scripted_diffusion_sweep_2_50step_1e-4 \
|
||||||
|
--policy_class Diffusion --chunk_size 32 \
|
||||||
|
--batch_size 32 --lr 1e-4 --seed 0 \
|
||||||
|
--num_steps 100000 --eval_every 2000 --validate_every 2000 --save_every 2000
|
||||||
|
|
||||||
|
|
||||||
|
# use EMA and train for longer (code changes)
|
||||||
|
|
||||||
|
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_diffusion_sweep_3_ema \
|
||||||
|
--policy_class Diffusion --chunk_size 32 \
|
||||||
|
--batch_size 32 --lr 1e-4 --seed 0 \
|
||||||
|
--num_steps 300000 --eval_every 6000 --validate_every 6000 --save_every 6000
|
||||||
|
|
||||||
|
# code regression test: no EMA
|
||||||
|
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_diffusion_sweep_4_regression_no_ema \
|
||||||
|
--policy_class Diffusion --chunk_size 32 \
|
||||||
|
--batch_size 32 --lr 1e-4 --seed 0 \
|
||||||
|
--num_steps 300000 --eval_every 6000 --validate_every 6000 --save_every 6000
|
||||||
|
|
||||||
|
conda activate mobile
|
||||||
|
export MUJOCO_GL=egl
|
||||||
|
cd /home/tonyzhao/Research/act-plus-plus
|
||||||
|
CUDA_VISIBLE_DEVICES=1 python3 imitate_episodes.py \
|
||||||
|
--task_name sim_transfer_cube_scripted \
|
||||||
|
--ckpt_dir /scr/tonyzhao/train_logs/cube_scripted_diffusion_sweep_5_ema_again \
|
||||||
|
--policy_class Diffusion --chunk_size 32 \
|
||||||
|
--batch_size 32 --lr 1e-4 --seed 0 \
|
||||||
|
--num_steps 300000 --eval_every 6000 --validate_every 6000 --save_every 6000
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
---------------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
NOTE: chunk size cannot be any number, try before launching
|
||||||
|
TODO: Add history, EMA at test time
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
185
compress_data.py
普通文件
185
compress_data.py
普通文件
@ -0,0 +1,185 @@
|
|||||||
|
"""
|
||||||
|
Example usage:
|
||||||
|
$ python3 script/compress_data.py --dataset_dir /scr/lucyshi/dataset/aloha_test
|
||||||
|
"""
|
||||||
|
import os
|
||||||
|
import h5py
|
||||||
|
import cv2
|
||||||
|
import numpy as np
|
||||||
|
import argparse
|
||||||
|
from tqdm import tqdm
|
||||||
|
|
||||||
|
# Constants
|
||||||
|
DT = 0.02
|
||||||
|
JOINT_NAMES = ["waist", "shoulder", "elbow", "forearm_roll", "wrist_angle", "wrist_rotate"]
|
||||||
|
STATE_NAMES = JOINT_NAMES + ["gripper"]
|
||||||
|
|
||||||
|
|
||||||
|
def compress_dataset(input_dataset_path, output_dataset_path):
|
||||||
|
# Check if output path exists
|
||||||
|
if os.path.exists(output_dataset_path):
|
||||||
|
print(f"The file {output_dataset_path} already exists. Exiting...")
|
||||||
|
return
|
||||||
|
|
||||||
|
# Load the uncompressed dataset
|
||||||
|
with h5py.File(input_dataset_path, 'r') as infile:
|
||||||
|
# Create the compressed dataset
|
||||||
|
with h5py.File(output_dataset_path, 'w') as outfile:
|
||||||
|
|
||||||
|
if 'sim' in infile.attrs:
|
||||||
|
outfile.attrs['sim'] = infile.attrs['sim']
|
||||||
|
else:
|
||||||
|
outfile.attrs['sim'] = False
|
||||||
|
outfile.attrs['compress'] = True
|
||||||
|
|
||||||
|
# Copy non-image data directly
|
||||||
|
for key in infile.keys():
|
||||||
|
if key != 'observations':
|
||||||
|
outfile.copy(infile[key], key)
|
||||||
|
|
||||||
|
obs_group = infile['observations']
|
||||||
|
|
||||||
|
# Create observation group in the output
|
||||||
|
out_obs_group = outfile.create_group('observations')
|
||||||
|
|
||||||
|
# Copy non-image data in observations directly
|
||||||
|
for key in obs_group.keys():
|
||||||
|
if key != 'images':
|
||||||
|
out_obs_group.copy(obs_group[key], key)
|
||||||
|
|
||||||
|
image_group = obs_group['images']
|
||||||
|
out_image_group = out_obs_group.create_group('images')
|
||||||
|
|
||||||
|
# JPEG compression parameters
|
||||||
|
encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 50]
|
||||||
|
|
||||||
|
compressed_lens = [] # List to store compressed lengths for each camera
|
||||||
|
|
||||||
|
for cam_name in image_group.keys():
|
||||||
|
if "_depth" in cam_name: # Depth images are not compressed
|
||||||
|
out_image_group.copy(image_group[cam_name], cam_name)
|
||||||
|
else:
|
||||||
|
images = image_group[cam_name]
|
||||||
|
compressed_images = []
|
||||||
|
cam_compressed_lens = [] # List to store compressed lengths for this camera
|
||||||
|
|
||||||
|
# Compress each image
|
||||||
|
for image in images:
|
||||||
|
result, encoded_image = cv2.imencode('.jpg', image, encode_param)
|
||||||
|
compressed_images.append(encoded_image)
|
||||||
|
cam_compressed_lens.append(len(encoded_image)) # Store the length
|
||||||
|
|
||||||
|
compressed_lens.append(cam_compressed_lens)
|
||||||
|
|
||||||
|
# Find the maximum length of the compressed images
|
||||||
|
max_len = max(len(img) for img in compressed_images)
|
||||||
|
|
||||||
|
# Create dataset to store compressed images
|
||||||
|
compressed_dataset = out_image_group.create_dataset(cam_name, (len(compressed_images), max_len), dtype='uint8')
|
||||||
|
|
||||||
|
# Store compressed images
|
||||||
|
for i, img in enumerate(compressed_images):
|
||||||
|
compressed_dataset[i, :len(img)] = img
|
||||||
|
|
||||||
|
# Save the compressed lengths to the HDF5 file
|
||||||
|
compressed_lens = np.array(compressed_lens)
|
||||||
|
_ = outfile.create_dataset('compress_len', compressed_lens.shape)
|
||||||
|
outfile['/compress_len'][...] = compressed_lens
|
||||||
|
|
||||||
|
print(f"Compressed dataset saved to {output_dataset_path}")
|
||||||
|
|
||||||
|
|
||||||
|
def save_videos(video, dt, video_path=None):
|
||||||
|
if isinstance(video, list):
|
||||||
|
cam_names = list(video[0].keys())
|
||||||
|
h, w, _ = video[0][cam_names[0]].shape
|
||||||
|
w = w * len(cam_names)
|
||||||
|
fps = int(1/dt)
|
||||||
|
out = cv2.VideoWriter(video_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))
|
||||||
|
# bitrate = 1000000
|
||||||
|
# out.set(cv2.VIDEOWRITER_PROP_BITRATE, bitrate)
|
||||||
|
for ts, image_dict in enumerate(video):
|
||||||
|
images = []
|
||||||
|
for cam_name in cam_names:
|
||||||
|
image = image_dict[cam_name]
|
||||||
|
image = image[:, :, [2, 1, 0]] # swap B and R channel
|
||||||
|
images.append(image)
|
||||||
|
images = np.concatenate(images, axis=1)
|
||||||
|
out.write(images)
|
||||||
|
out.release()
|
||||||
|
print(f'Saved video to: {video_path}')
|
||||||
|
elif isinstance(video, dict):
|
||||||
|
cam_names = list(video.keys())
|
||||||
|
# Remove depth images
|
||||||
|
cam_names = [cam_name for cam_name in cam_names if '_depth' not in cam_name]
|
||||||
|
all_cam_videos = []
|
||||||
|
for cam_name in cam_names:
|
||||||
|
all_cam_videos.append(video[cam_name])
|
||||||
|
all_cam_videos = np.concatenate(all_cam_videos, axis=2) # width dimension
|
||||||
|
|
||||||
|
n_frames, h, w, _ = all_cam_videos.shape
|
||||||
|
fps = int(1 / dt)
|
||||||
|
out = cv2.VideoWriter(video_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))
|
||||||
|
for t in range(n_frames):
|
||||||
|
image = all_cam_videos[t]
|
||||||
|
image = image[:, :, [2, 1, 0]] # swap B and R channel
|
||||||
|
out.write(image)
|
||||||
|
out.release()
|
||||||
|
print(f'Saved video to: {video_path}')
|
||||||
|
|
||||||
|
|
||||||
|
def load_and_save_first_episode_video(dataset_dir, video_path):
|
||||||
|
dataset_name = 'episode_0'
|
||||||
|
_, _, _, _, image_dict = load_hdf5(dataset_dir, dataset_name)
|
||||||
|
save_videos(image_dict, DT, video_path=video_path)
|
||||||
|
|
||||||
|
|
||||||
|
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:
|
||||||
|
compressed = root.attrs.get('compress', False)
|
||||||
|
image_dict = dict()
|
||||||
|
for cam_name in root[f'/observations/images/'].keys():
|
||||||
|
image_dict[cam_name] = root[f'/observations/images/{cam_name}'][()]
|
||||||
|
if compressed:
|
||||||
|
compress_len = root['/compress_len'][()]
|
||||||
|
|
||||||
|
if compressed:
|
||||||
|
for cam_id, cam_name in enumerate(image_dict.keys()):
|
||||||
|
padded_compressed_image_list = image_dict[cam_name]
|
||||||
|
image_list = []
|
||||||
|
for frame_id, padded_compressed_image in enumerate(padded_compressed_image_list):
|
||||||
|
image_len = int(compress_len[cam_id, frame_id])
|
||||||
|
compressed_image = padded_compressed_image
|
||||||
|
image = cv2.imdecode(compressed_image, 1)
|
||||||
|
image_list.append(image)
|
||||||
|
image_dict[cam_name] = image_list
|
||||||
|
|
||||||
|
return None, None, None, None, image_dict # Return only the image dict for this application
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
parser = argparse.ArgumentParser(description="Compress all HDF5 datasets in a directory.")
|
||||||
|
parser.add_argument('--dataset_dir', action='store', type=str, required=True, help='Directory containing the uncompressed datasets.')
|
||||||
|
|
||||||
|
args = parser.parse_args()
|
||||||
|
|
||||||
|
output_dataset_dir = args.dataset_dir + '_compressed'
|
||||||
|
os.makedirs(output_dataset_dir, exist_ok=True)
|
||||||
|
|
||||||
|
# Iterate over each file in the directory
|
||||||
|
for filename in tqdm(os.listdir(args.dataset_dir), desc="Compressing data"):
|
||||||
|
if filename.endswith('.hdf5'):
|
||||||
|
input_path = os.path.join(args.dataset_dir, filename)
|
||||||
|
output_path = os.path.join(output_dataset_dir, filename)
|
||||||
|
compress_dataset(input_path, output_path)
|
||||||
|
|
||||||
|
# After processing all datasets, load and save the video for the first episode
|
||||||
|
print(f'Saving video for episode 0 in {output_dataset_dir}')
|
||||||
|
video_path = os.path.join(output_dataset_dir, 'episode_0_video.mp4')
|
||||||
|
load_and_save_first_episode_video(args.dataset_dir, video_path)
|
||||||
|
|
||||||
@ -67,6 +67,7 @@ def get_args_parser():
|
|||||||
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', required=False)
|
parser.add_argument('--vq_class', action='store', type=int, help='vq_class', required=False)
|
||||||
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('--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('--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('--validate_every', action='store', type=int, default=500, help='validate_every', required=False)
|
||||||
|
|||||||
@ -14,8 +14,8 @@ from constants import DT
|
|||||||
from constants import PUPPET_GRIPPER_JOINT_OPEN
|
from constants import PUPPET_GRIPPER_JOINT_OPEN
|
||||||
from utils import load_data # data functions
|
from utils import load_data # data functions
|
||||||
from utils import sample_box_pose, sample_insertion_pose # robot functions
|
from utils import sample_box_pose, sample_insertion_pose # robot functions
|
||||||
from utils import compute_dict_mean, set_seed, detach_dict # helper functions
|
from utils import compute_dict_mean, set_seed, detach_dict, calibrate_linear_vel, postprocess_base_action # helper functions
|
||||||
from policy import ACTPolicy, CNNMLPPolicy
|
from policy import ACTPolicy, CNNMLPPolicy, DiffusionPolicy
|
||||||
from visualize_episodes import save_videos
|
from visualize_episodes import save_videos
|
||||||
|
|
||||||
from detr.models.latent_model import Latent_Model_Transformer
|
from detr.models.latent_model import Latent_Model_Transformer
|
||||||
@ -80,6 +80,19 @@ def main(args):
|
|||||||
'action_dim': 16,
|
'action_dim': 16,
|
||||||
'no_encoder': args['no_encoder'],
|
'no_encoder': args['no_encoder'],
|
||||||
}
|
}
|
||||||
|
elif policy_class == 'Diffusion':
|
||||||
|
|
||||||
|
policy_config = {'lr': args['lr'],
|
||||||
|
'camera_names': camera_names,
|
||||||
|
'action_dim': 16,
|
||||||
|
'observation_horizon': 1,
|
||||||
|
'action_horizon': 8,
|
||||||
|
'prediction_horizon': args['chunk_size'],
|
||||||
|
'num_queries': args['chunk_size'],
|
||||||
|
'num_inference_timesteps': 10,
|
||||||
|
'ema_power': 0.75,
|
||||||
|
'vq': False,
|
||||||
|
}
|
||||||
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,
|
||||||
'camera_names': camera_names,}
|
'camera_names': camera_names,}
|
||||||
@ -103,23 +116,25 @@ def main(args):
|
|||||||
'seed': args['seed'],
|
'seed': args['seed'],
|
||||||
'temporal_agg': args['temporal_agg'],
|
'temporal_agg': args['temporal_agg'],
|
||||||
'camera_names': camera_names,
|
'camera_names': camera_names,
|
||||||
'real_robot': not is_sim
|
'real_robot': not is_sim,
|
||||||
|
'load_pretrain': args['load_pretrain']
|
||||||
}
|
}
|
||||||
|
|
||||||
if not os.path.isdir(ckpt_dir):
|
if not os.path.isdir(ckpt_dir):
|
||||||
os.makedirs(ckpt_dir)
|
os.makedirs(ckpt_dir)
|
||||||
config_path = os.path.join(ckpt_dir, 'config.pkl')
|
config_path = os.path.join(ckpt_dir, 'config.pkl')
|
||||||
expr_name = ckpt_dir.split('/')[-1]
|
expr_name = ckpt_dir.split('/')[-1]
|
||||||
wandb.init(project="mobile-aloha", reinit=True, entity="mobile-aloha", name=expr_name)
|
if not is_eval:
|
||||||
wandb.config.update(config)
|
wandb.init(project="mobile-aloha2", reinit=True, entity="mobile-aloha2", name=expr_name)
|
||||||
|
wandb.config.update(config)
|
||||||
with open(config_path, 'wb') as f:
|
with open(config_path, 'wb') as f:
|
||||||
pickle.dump(config, 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, num_rollouts=50)
|
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})
|
# 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:
|
||||||
@ -127,7 +142,7 @@ def main(args):
|
|||||||
print()
|
print()
|
||||||
exit()
|
exit()
|
||||||
|
|
||||||
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'])
|
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'], policy_class)
|
||||||
|
|
||||||
# save dataset stats
|
# save dataset stats
|
||||||
stats_path = os.path.join(ckpt_dir, f'dataset_stats.pkl')
|
stats_path = os.path.join(ckpt_dir, f'dataset_stats.pkl')
|
||||||
@ -149,6 +164,8 @@ def make_policy(policy_class, policy_config):
|
|||||||
policy = ACTPolicy(policy_config)
|
policy = ACTPolicy(policy_config)
|
||||||
elif policy_class == 'CNNMLP':
|
elif policy_class == 'CNNMLP':
|
||||||
policy = CNNMLPPolicy(policy_config)
|
policy = CNNMLPPolicy(policy_config)
|
||||||
|
elif policy_class == 'Diffusion':
|
||||||
|
policy = DiffusionPolicy(policy_config)
|
||||||
else:
|
else:
|
||||||
raise NotImplementedError
|
raise NotImplementedError
|
||||||
return policy
|
return policy
|
||||||
@ -159,6 +176,8 @@ def make_optimizer(policy_class, policy):
|
|||||||
optimizer = policy.configure_optimizers()
|
optimizer = policy.configure_optimizers()
|
||||||
elif policy_class == 'CNNMLP':
|
elif policy_class == 'CNNMLP':
|
||||||
optimizer = policy.configure_optimizers()
|
optimizer = policy.configure_optimizers()
|
||||||
|
elif policy_class == 'Diffusion':
|
||||||
|
optimizer = policy.configure_optimizers()
|
||||||
else:
|
else:
|
||||||
raise NotImplementedError
|
raise NotImplementedError
|
||||||
return optimizer
|
return optimizer
|
||||||
@ -192,7 +211,7 @@ def eval_bc(config, ckpt_name, save_episode=True, num_rollouts=50):
|
|||||||
# load policy and stats
|
# load policy and stats
|
||||||
ckpt_path = os.path.join(ckpt_dir, ckpt_name)
|
ckpt_path = os.path.join(ckpt_dir, ckpt_name)
|
||||||
policy = make_policy(policy_class, policy_config)
|
policy = make_policy(policy_class, policy_config)
|
||||||
loading_status = policy.load_state_dict(torch.load(ckpt_path))
|
loading_status = policy.deserialize(torch.load(ckpt_path))
|
||||||
print(loading_status)
|
print(loading_status)
|
||||||
policy.cuda()
|
policy.cuda()
|
||||||
policy.eval()
|
policy.eval()
|
||||||
@ -201,7 +220,7 @@ def eval_bc(config, ckpt_name, save_episode=True, num_rollouts=50):
|
|||||||
vq_class = config['policy_config']['vq_class']
|
vq_class = config['policy_config']['vq_class']
|
||||||
latent_model = Latent_Model_Transformer(vq_dim, vq_dim, vq_class)
|
latent_model = Latent_Model_Transformer(vq_dim, vq_dim, vq_class)
|
||||||
latent_model_ckpt_path = os.path.join(ckpt_dir, 'latent_model_last.ckpt')
|
latent_model_ckpt_path = os.path.join(ckpt_dir, 'latent_model_last.ckpt')
|
||||||
latent_model.load_state_dict(torch.load(latent_model_ckpt_path))
|
latent_model.deserialize(torch.load(latent_model_ckpt_path))
|
||||||
latent_model.eval()
|
latent_model.eval()
|
||||||
latent_model.cuda()
|
latent_model.cuda()
|
||||||
print(f'Loaded policy from: {ckpt_path}, latent model from: {latent_model_ckpt_path}')
|
print(f'Loaded policy from: {ckpt_path}, latent model from: {latent_model_ckpt_path}')
|
||||||
@ -212,13 +231,16 @@ def eval_bc(config, ckpt_name, save_episode=True, num_rollouts=50):
|
|||||||
stats = pickle.load(f)
|
stats = pickle.load(f)
|
||||||
|
|
||||||
pre_process = lambda s_qpos: (s_qpos - stats['qpos_mean']) / stats['qpos_std']
|
pre_process = lambda s_qpos: (s_qpos - stats['qpos_mean']) / stats['qpos_std']
|
||||||
post_process = lambda a: a * stats['action_std'] + stats['action_mean']
|
if policy_class == 'Diffusion':
|
||||||
|
post_process = lambda a: ((a + 1) / 2) * (stats['action_max'] - stats['action_min']) + stats['action_min']
|
||||||
|
else:
|
||||||
|
post_process = lambda a: a * stats['action_std'] + stats['action_mean']
|
||||||
|
|
||||||
# load environment
|
# load environment
|
||||||
if real_robot:
|
if real_robot:
|
||||||
from aloha_scripts.robot_utils import move_grippers # requires aloha
|
from aloha_scripts.robot_utils import move_grippers # requires aloha
|
||||||
from aloha_scripts.real_env import make_real_env # requires aloha
|
from aloha_scripts.real_env import make_real_env # requires aloha
|
||||||
env = make_real_env(init_node=True, setup_base=True)
|
env = make_real_env(init_node=True, setup_robots=True, setup_base=True)
|
||||||
env_max_reward = 0
|
env_max_reward = 0
|
||||||
else:
|
else:
|
||||||
from sim_env import make_sim_env
|
from sim_env import make_sim_env
|
||||||
@ -252,7 +274,7 @@ def eval_bc(config, ckpt_name, save_episode=True, num_rollouts=50):
|
|||||||
|
|
||||||
### evaluation loop
|
### evaluation loop
|
||||||
if temporal_agg:
|
if temporal_agg:
|
||||||
all_time_actions = torch.zeros([max_timesteps, max_timesteps+num_queries, state_dim]).cuda()
|
all_time_actions = torch.zeros([max_timesteps, max_timesteps+num_queries, 16]).cuda()
|
||||||
|
|
||||||
qpos_history = torch.zeros((1, max_timesteps, state_dim)).cuda()
|
qpos_history = torch.zeros((1, max_timesteps, state_dim)).cuda()
|
||||||
image_list = [] # for visualization
|
image_list = [] # for visualization
|
||||||
@ -290,6 +312,7 @@ def eval_bc(config, ckpt_name, save_episode=True, num_rollouts=50):
|
|||||||
vq_sample = latent_model.generate(1, temperature=1, x=None)
|
vq_sample = latent_model.generate(1, temperature=1, x=None)
|
||||||
all_actions = policy(qpos, curr_image, vq_sample=vq_sample)
|
all_actions = policy(qpos, curr_image, vq_sample=vq_sample)
|
||||||
else:
|
else:
|
||||||
|
# e()
|
||||||
all_actions = policy(qpos, curr_image)
|
all_actions = policy(qpos, curr_image)
|
||||||
if temporal_agg:
|
if temporal_agg:
|
||||||
all_time_actions[[t], t:t+num_queries] = all_actions
|
all_time_actions[[t], t:t+num_queries] = all_actions
|
||||||
@ -303,6 +326,10 @@ def eval_bc(config, ckpt_name, save_episode=True, num_rollouts=50):
|
|||||||
raw_action = (actions_for_curr_step * exp_weights).sum(dim=0, keepdim=True)
|
raw_action = (actions_for_curr_step * exp_weights).sum(dim=0, keepdim=True)
|
||||||
else:
|
else:
|
||||||
raw_action = all_actions[:, t % query_frequency]
|
raw_action = all_actions[:, t % query_frequency]
|
||||||
|
elif config['policy_class'] == "Diffusion":
|
||||||
|
if t % query_frequency == 0:
|
||||||
|
all_actions = policy(qpos, curr_image)
|
||||||
|
raw_action = all_actions[:, t % query_frequency]
|
||||||
elif config['policy_class'] == "CNNMLP":
|
elif config['policy_class'] == "CNNMLP":
|
||||||
raw_action = policy(qpos, curr_image)
|
raw_action = policy(qpos, curr_image)
|
||||||
else:
|
else:
|
||||||
@ -313,6 +340,8 @@ def eval_bc(config, ckpt_name, save_episode=True, num_rollouts=50):
|
|||||||
action = post_process(raw_action)
|
action = post_process(raw_action)
|
||||||
target_qpos = action[:-2]
|
target_qpos = action[:-2]
|
||||||
base_action = action[-2:]
|
base_action = action[-2:]
|
||||||
|
base_action = calibrate_linear_vel(base_action, c=0.19)
|
||||||
|
# base_action = postprocess_base_action(base_action)
|
||||||
|
|
||||||
### step the environment
|
### step the environment
|
||||||
if real_robot:
|
if real_robot:
|
||||||
@ -380,8 +409,11 @@ def train_bc(train_dataloader, val_dataloader, config):
|
|||||||
set_seed(seed)
|
set_seed(seed)
|
||||||
|
|
||||||
policy = make_policy(policy_class, policy_config)
|
policy = make_policy(policy_class, policy_config)
|
||||||
|
if config['load_pretrain']:
|
||||||
|
loading_status = policy.deserialize(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}')
|
||||||
if config['resume_ckpt_path'] is not None:
|
if config['resume_ckpt_path'] is not None:
|
||||||
loading_status = policy.load_state_dict(torch.load(config['resume_ckpt_path']))
|
loading_status = policy.deserialize(torch.load(config['resume_ckpt_path']))
|
||||||
print(f'Resume policy from: {config["resume_ckpt_path"]}, Status: {loading_status}')
|
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)
|
||||||
@ -407,8 +439,8 @@ def train_bc(train_dataloader, val_dataloader, config):
|
|||||||
epoch_val_loss = validation_summary['loss']
|
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 = (step, min_val_loss, deepcopy(policy.state_dict()))
|
best_ckpt_info = (step, min_val_loss, deepcopy(policy.serialize()))
|
||||||
for k in validation_summary.keys():
|
for k in list(validation_summary.keys()):
|
||||||
validation_summary[f'val_{k}'] = validation_summary.pop(k)
|
validation_summary[f'val_{k}'] = validation_summary.pop(k)
|
||||||
wandb.log(validation_summary, step=step)
|
wandb.log(validation_summary, step=step)
|
||||||
print(f'Val loss: {epoch_val_loss:.5f}')
|
print(f'Val loss: {epoch_val_loss:.5f}')
|
||||||
@ -422,8 +454,8 @@ def train_bc(train_dataloader, val_dataloader, config):
|
|||||||
# first save then eval
|
# first save then eval
|
||||||
ckpt_name = f'policy_step_{step}_seed_{seed}.ckpt'
|
ckpt_name = f'policy_step_{step}_seed_{seed}.ckpt'
|
||||||
ckpt_path = os.path.join(ckpt_dir, ckpt_name)
|
ckpt_path = os.path.join(ckpt_dir, ckpt_name)
|
||||||
torch.save(policy.state_dict(), ckpt_path)
|
torch.save(policy.serialize(), ckpt_path)
|
||||||
success, _ = eval_bc(config, ckpt_name, save_episode=True, num_rollouts=20)
|
success, _ = eval_bc(config, ckpt_name, save_episode=True, num_rollouts=10)
|
||||||
wandb.log({'success': success}, step=step)
|
wandb.log({'success': success}, step=step)
|
||||||
|
|
||||||
# training
|
# training
|
||||||
@ -439,10 +471,10 @@ def train_bc(train_dataloader, val_dataloader, config):
|
|||||||
|
|
||||||
if step % save_every == 0:
|
if step % save_every == 0:
|
||||||
ckpt_path = os.path.join(ckpt_dir, f'policy_step_{step}_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.serialize(), ckpt_path)
|
||||||
|
|
||||||
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.serialize(), ckpt_path)
|
||||||
|
|
||||||
best_step, 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_step_{best_step}_seed_{seed}.ckpt')
|
ckpt_path = os.path.join(ckpt_dir, f'policy_step_{best_step}_seed_{seed}.ckpt')
|
||||||
@ -471,6 +503,7 @@ if __name__ == '__main__':
|
|||||||
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_steps', action='store', type=int, help='num_steps', 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('--eval_every', action='store', type=int, default=500, help='eval_every', 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('--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('--save_every', action='store', type=int, default=500, help='save_every', required=False)
|
||||||
|
|||||||
194
policy.py
194
policy.py
@ -2,11 +2,199 @@ import torch.nn as nn
|
|||||||
from torch.nn import functional as F
|
from torch.nn import functional as F
|
||||||
import torchvision.transforms as transforms
|
import torchvision.transforms as transforms
|
||||||
import torch
|
import torch
|
||||||
|
import numpy as np
|
||||||
from detr.main import build_ACT_model_and_optimizer, build_CNNMLP_model_and_optimizer
|
from detr.main import build_ACT_model_and_optimizer, build_CNNMLP_model_and_optimizer
|
||||||
import IPython
|
import IPython
|
||||||
e = IPython.embed
|
e = IPython.embed
|
||||||
|
|
||||||
|
from collections import OrderedDict
|
||||||
|
from robomimic.models.base_nets import ResNet18Conv, SpatialSoftmax
|
||||||
|
from robomimic.algo.diffusion_policy import replace_bn_with_gn, ConditionalUnet1D
|
||||||
|
|
||||||
|
|
||||||
|
from diffusers.schedulers.scheduling_ddpm import DDPMScheduler
|
||||||
|
from diffusers.schedulers.scheduling_ddim import DDIMScheduler
|
||||||
|
from diffusers.training_utils import EMAModel
|
||||||
|
|
||||||
|
|
||||||
|
class DiffusionPolicy(nn.Module):
|
||||||
|
def __init__(self, args_override):
|
||||||
|
super().__init__()
|
||||||
|
|
||||||
|
self.camera_names = args_override['camera_names']
|
||||||
|
|
||||||
|
self.observation_horizon = args_override['observation_horizon'] ### TODO TODO TODO DO THIS
|
||||||
|
self.action_horizon = args_override['action_horizon'] # apply chunk size
|
||||||
|
self.prediction_horizon = args_override['prediction_horizon'] # chunk size
|
||||||
|
self.num_inference_timesteps = args_override['num_inference_timesteps']
|
||||||
|
self.ema_power = args_override['ema_power']
|
||||||
|
self.lr = args_override['lr']
|
||||||
|
self.weight_decay = 0
|
||||||
|
|
||||||
|
self.num_kp = 32
|
||||||
|
self.feature_dimension = 64
|
||||||
|
self.ac_dim = args_override['action_dim'] # 14 + 2
|
||||||
|
self.obs_dim = self.feature_dimension * len(self.camera_names) + 14 # camera features and proprio
|
||||||
|
|
||||||
|
backbones = []
|
||||||
|
pools = []
|
||||||
|
linears = []
|
||||||
|
for _ in self.camera_names:
|
||||||
|
backbones.append(ResNet18Conv(**{'input_channel': 3, 'pretrained': False, 'input_coord_conv': False}))
|
||||||
|
pools.append(SpatialSoftmax(**{'input_shape': [512, 15, 20], 'num_kp': self.num_kp, 'temperature': 1.0, 'learnable_temperature': False, 'noise_std': 0.0}))
|
||||||
|
linears.append(torch.nn.Linear(int(np.prod([self.num_kp, 2])), self.feature_dimension))
|
||||||
|
backbones = nn.ModuleList(backbones)
|
||||||
|
pools = nn.ModuleList(pools)
|
||||||
|
linears = nn.ModuleList(linears)
|
||||||
|
|
||||||
|
backbones = replace_bn_with_gn(backbones) # TODO
|
||||||
|
|
||||||
|
|
||||||
|
noise_pred_net = ConditionalUnet1D(
|
||||||
|
input_dim=self.ac_dim,
|
||||||
|
global_cond_dim=self.obs_dim*self.observation_horizon
|
||||||
|
)
|
||||||
|
|
||||||
|
nets = nn.ModuleDict({
|
||||||
|
'policy': nn.ModuleDict({
|
||||||
|
'backbones': backbones,
|
||||||
|
'pools': pools,
|
||||||
|
'linears': linears,
|
||||||
|
'noise_pred_net': noise_pred_net
|
||||||
|
})
|
||||||
|
})
|
||||||
|
|
||||||
|
nets = nets.float().cuda()
|
||||||
|
ENABLE_EMA = True
|
||||||
|
if ENABLE_EMA:
|
||||||
|
ema = EMAModel(model=nets, power=self.ema_power)
|
||||||
|
else:
|
||||||
|
ema = None
|
||||||
|
self.nets = nets
|
||||||
|
self.ema = ema
|
||||||
|
|
||||||
|
# setup noise scheduler
|
||||||
|
self.noise_scheduler = DDIMScheduler(
|
||||||
|
num_train_timesteps=50,
|
||||||
|
beta_schedule='squaredcos_cap_v2',
|
||||||
|
clip_sample=True,
|
||||||
|
set_alpha_to_one=True,
|
||||||
|
steps_offset=0,
|
||||||
|
prediction_type='epsilon'
|
||||||
|
)
|
||||||
|
|
||||||
|
n_parameters = sum(p.numel() for p in self.parameters())
|
||||||
|
print("number of parameters: %.2fM" % (n_parameters/1e6,))
|
||||||
|
|
||||||
|
|
||||||
|
def configure_optimizers(self):
|
||||||
|
optimizer = torch.optim.AdamW(self.nets.parameters(), lr=self.lr, weight_decay=self.weight_decay)
|
||||||
|
return optimizer
|
||||||
|
|
||||||
|
|
||||||
|
def __call__(self, qpos, image, actions=None, is_pad=None):
|
||||||
|
B = qpos.shape[0]
|
||||||
|
if actions is not None: # training time
|
||||||
|
nets = self.nets
|
||||||
|
all_features = []
|
||||||
|
for cam_id in range(len(self.camera_names)):
|
||||||
|
cam_image = image[:, cam_id]
|
||||||
|
cam_features = nets['policy']['backbones'][cam_id](cam_image)
|
||||||
|
pool_features = nets['policy']['pools'][cam_id](cam_features)
|
||||||
|
pool_features = torch.flatten(pool_features, start_dim=1)
|
||||||
|
out_features = nets['policy']['linears'][cam_id](pool_features)
|
||||||
|
all_features.append(out_features)
|
||||||
|
|
||||||
|
obs_cond = torch.cat(all_features + [qpos], dim=1)
|
||||||
|
|
||||||
|
# sample noise to add to actions
|
||||||
|
noise = torch.randn(actions.shape, device=obs_cond.device)
|
||||||
|
|
||||||
|
# sample a diffusion iteration for each data point
|
||||||
|
timesteps = torch.randint(
|
||||||
|
0, self.noise_scheduler.config.num_train_timesteps,
|
||||||
|
(B,), device=obs_cond.device
|
||||||
|
).long()
|
||||||
|
|
||||||
|
# add noise to the clean actions according to the noise magnitude at each diffusion iteration
|
||||||
|
# (this is the forward diffusion process)
|
||||||
|
noisy_actions = self.noise_scheduler.add_noise(
|
||||||
|
actions, noise, timesteps)
|
||||||
|
|
||||||
|
# predict the noise residual
|
||||||
|
noise_pred = nets['policy']['noise_pred_net'](noisy_actions, timesteps, global_cond=obs_cond)
|
||||||
|
|
||||||
|
# L2 loss
|
||||||
|
loss = F.mse_loss(noise_pred, noise)
|
||||||
|
|
||||||
|
loss_dict = {}
|
||||||
|
loss_dict['l2_loss'] = loss
|
||||||
|
loss_dict['loss'] = loss
|
||||||
|
|
||||||
|
if self.training and self.ema is not None:
|
||||||
|
self.ema.step(nets)
|
||||||
|
return loss_dict
|
||||||
|
else: # inference time
|
||||||
|
To = self.observation_horizon
|
||||||
|
Ta = self.action_horizon
|
||||||
|
Tp = self.prediction_horizon
|
||||||
|
action_dim = self.ac_dim
|
||||||
|
|
||||||
|
nets = self.nets
|
||||||
|
if self.ema is not None:
|
||||||
|
nets = self.ema.averaged_model
|
||||||
|
|
||||||
|
all_features = []
|
||||||
|
for cam_id in range(len(self.camera_names)):
|
||||||
|
cam_image = image[:, cam_id]
|
||||||
|
cam_features = nets['policy']['backbones'][cam_id](cam_image)
|
||||||
|
pool_features = nets['policy']['pools'][cam_id](cam_features)
|
||||||
|
pool_features = torch.flatten(pool_features, start_dim=1)
|
||||||
|
out_features = nets['policy']['linears'][cam_id](pool_features)
|
||||||
|
all_features.append(out_features)
|
||||||
|
|
||||||
|
obs_cond = torch.cat(all_features + [qpos], dim=1)
|
||||||
|
|
||||||
|
# initialize action from Guassian noise
|
||||||
|
noisy_action = torch.randn(
|
||||||
|
(B, Tp, action_dim), device=obs_cond.device)
|
||||||
|
naction = noisy_action
|
||||||
|
|
||||||
|
# init scheduler
|
||||||
|
self.noise_scheduler.set_timesteps(self.num_inference_timesteps)
|
||||||
|
|
||||||
|
for k in self.noise_scheduler.timesteps:
|
||||||
|
# predict noise
|
||||||
|
noise_pred = nets['policy']['noise_pred_net'](
|
||||||
|
sample=naction,
|
||||||
|
timestep=k,
|
||||||
|
global_cond=obs_cond
|
||||||
|
)
|
||||||
|
|
||||||
|
# inverse diffusion step (remove noise)
|
||||||
|
naction = self.noise_scheduler.step(
|
||||||
|
model_output=noise_pred,
|
||||||
|
timestep=k,
|
||||||
|
sample=naction
|
||||||
|
).prev_sample
|
||||||
|
|
||||||
|
return naction
|
||||||
|
|
||||||
|
def serialize(self):
|
||||||
|
return {
|
||||||
|
"nets": self.nets.state_dict(),
|
||||||
|
"ema": self.ema.averaged_model.state_dict() if self.ema is not None else None,
|
||||||
|
}
|
||||||
|
|
||||||
|
def deserialize(self, model_dict):
|
||||||
|
status = self.nets.load_state_dict(model_dict["nets"])
|
||||||
|
print('Loaded model')
|
||||||
|
if model_dict.get("ema", None) is not None:
|
||||||
|
print('Loaded EMA')
|
||||||
|
status_ema = self.ema.averaged_model.load_state_dict(model_dict["ema"])
|
||||||
|
status = [status, status_ema]
|
||||||
|
return status
|
||||||
|
|
||||||
class ACTPolicy(nn.Module):
|
class ACTPolicy(nn.Module):
|
||||||
def __init__(self, args_override):
|
def __init__(self, args_override):
|
||||||
super().__init__()
|
super().__init__()
|
||||||
@ -56,7 +244,11 @@ class ACTPolicy(nn.Module):
|
|||||||
|
|
||||||
return binaries
|
return binaries
|
||||||
|
|
||||||
|
def serialize(self):
|
||||||
|
return self.state_dict()
|
||||||
|
|
||||||
|
def deserialize(self, model_dict):
|
||||||
|
return self.load_state_dict(model_dict)
|
||||||
|
|
||||||
|
|
||||||
class CNNMLPPolicy(nn.Module):
|
class CNNMLPPolicy(nn.Module):
|
||||||
|
|||||||
@ -26,6 +26,7 @@ def load_hdf5(dataset_dir, dataset_name):
|
|||||||
|
|
||||||
with h5py.File(dataset_path, 'r') as root:
|
with h5py.File(dataset_path, 'r') as root:
|
||||||
is_sim = root.attrs['sim']
|
is_sim = root.attrs['sim']
|
||||||
|
compressed = root.attrs.get('compress', False)
|
||||||
qpos = root['/observations/qpos'][()]
|
qpos = root['/observations/qpos'][()]
|
||||||
qvel = root['/observations/qvel'][()]
|
qvel = root['/observations/qvel'][()]
|
||||||
action = root['/action'][()]
|
action = root['/action'][()]
|
||||||
@ -37,17 +38,30 @@ def load_hdf5(dataset_dir, dataset_name):
|
|||||||
base_action = root['/base_action'][()]
|
base_action = root['/base_action'][()]
|
||||||
else:
|
else:
|
||||||
base_action = None
|
base_action = None
|
||||||
|
if compressed:
|
||||||
|
compress_len = root['/compress_len'][()]
|
||||||
|
|
||||||
return qpos, qvel, action, base_action, image_dict
|
if compressed:
|
||||||
|
for cam_id, cam_name in enumerate(image_dict.keys()):
|
||||||
|
# un-pad and uncompress
|
||||||
|
padded_compressed_image_list = image_dict[cam_name]
|
||||||
|
image_list = []
|
||||||
|
for padded_compressed_image in padded_compressed_image_list: # [:1000] to save memory
|
||||||
|
image = cv2.imdecode(padded_compressed_image, 1)
|
||||||
|
image_list.append(image)
|
||||||
|
image_dict[cam_name] = np.array(image_list)
|
||||||
|
|
||||||
|
return qpos, qvel, action, base_action, image_dict, is_sim
|
||||||
|
|
||||||
def main(args):
|
def main(args):
|
||||||
dataset_dir = args['dataset_dir']
|
dataset_dir = args['dataset_dir']
|
||||||
num_episodes = args['num_episodes']
|
num_episodes = args['num_episodes']
|
||||||
|
|
||||||
for episode_idx in range(num_episodes):
|
start_idx = 0
|
||||||
|
for episode_idx in range(start_idx, start_idx + num_episodes):
|
||||||
dataset_name = f'episode_{episode_idx}'
|
dataset_name = f'episode_{episode_idx}'
|
||||||
|
|
||||||
qpos, qvel, action, base_action, image_dict = load_hdf5(dataset_dir, dataset_name)
|
qpos, qvel, action, base_action, image_dict, is_sim = load_hdf5(dataset_dir, dataset_name)
|
||||||
|
|
||||||
# process proprioception
|
# process proprioception
|
||||||
qpos = np.concatenate([qpos[:, 7:] * MIRROR_STATE_MULTIPLY, qpos[:, :7] * MIRROR_STATE_MULTIPLY], axis=1)
|
qpos = np.concatenate([qpos[:, 7:] * MIRROR_STATE_MULTIPLY, qpos[:, :7] * MIRROR_STATE_MULTIPLY], axis=1)
|
||||||
@ -59,7 +73,7 @@ def main(args):
|
|||||||
# mirror image obs
|
# mirror image obs
|
||||||
if 'left_wrist' in image_dict.keys():
|
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]
|
image_dict['left_wrist'], image_dict['right_wrist'] = image_dict['right_wrist'][:, :, ::-1], image_dict['left_wrist'][:, :, ::-1]
|
||||||
elif 'cam_left_wrist':
|
elif 'cam_left_wrist' in image_dict.keys():
|
||||||
image_dict['cam_left_wrist'], image_dict['cam_right_wrist'] = image_dict['cam_right_wrist'][:, :, ::-1], image_dict['cam_left_wrist'][:, :, ::-1]
|
image_dict['cam_left_wrist'], image_dict['cam_right_wrist'] = image_dict['cam_right_wrist'][:, :, ::-1], image_dict['cam_left_wrist'][:, :, ::-1]
|
||||||
else:
|
else:
|
||||||
raise Exception('No left_wrist or cam_left_wrist in image_dict')
|
raise Exception('No left_wrist or cam_left_wrist in image_dict')
|
||||||
@ -86,18 +100,54 @@ def main(args):
|
|||||||
data_dict[f'/observations/images/{cam_name}'] = image_dict[cam_name]
|
data_dict[f'/observations/images/{cam_name}'] = image_dict[cam_name]
|
||||||
max_timesteps = len(qpos)
|
max_timesteps = len(qpos)
|
||||||
|
|
||||||
|
COMPRESS = True
|
||||||
|
|
||||||
|
if COMPRESS:
|
||||||
|
# JPEG compression
|
||||||
|
t0 = time.time()
|
||||||
|
encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 50] # tried as low as 20, seems fine
|
||||||
|
compressed_len = []
|
||||||
|
for cam_name in image_dict.keys():
|
||||||
|
image_list = data_dict[f'/observations/images/{cam_name}']
|
||||||
|
compressed_list = []
|
||||||
|
compressed_len.append([])
|
||||||
|
for image in image_list:
|
||||||
|
result, encoded_image = cv2.imencode('.jpg', image, encode_param) # 0.02 sec # cv2.imdecode(encoded_image, 1)
|
||||||
|
compressed_list.append(encoded_image)
|
||||||
|
compressed_len[-1].append(len(encoded_image))
|
||||||
|
data_dict[f'/observations/images/{cam_name}'] = compressed_list
|
||||||
|
print(f'compression: {time.time() - t0:.2f}s')
|
||||||
|
|
||||||
|
# pad so it has same length
|
||||||
|
t0 = time.time()
|
||||||
|
compressed_len = np.array(compressed_len)
|
||||||
|
padded_size = compressed_len.max()
|
||||||
|
for cam_name in image_dict.keys():
|
||||||
|
compressed_image_list = data_dict[f'/observations/images/{cam_name}']
|
||||||
|
padded_compressed_image_list = []
|
||||||
|
for compressed_image in compressed_image_list:
|
||||||
|
padded_compressed_image = np.zeros(padded_size, dtype='uint8')
|
||||||
|
image_len = len(compressed_image)
|
||||||
|
padded_compressed_image[:image_len] = compressed_image
|
||||||
|
padded_compressed_image_list.append(padded_compressed_image)
|
||||||
|
data_dict[f'/observations/images/{cam_name}'] = padded_compressed_image_list
|
||||||
|
print(f'padding: {time.time() - t0:.2f}s')
|
||||||
|
|
||||||
# HDF5
|
# HDF5
|
||||||
t0 = time.time()
|
t0 = time.time()
|
||||||
dataset_path = os.path.join(dataset_dir, f'mirror_episode_{episode_idx}')
|
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:
|
with h5py.File(dataset_path + '.hdf5', 'w', rdcc_nbytes=1024 ** 2 * 2) as root:
|
||||||
root.attrs['sim'] = True
|
root.attrs['sim'] = is_sim
|
||||||
|
root.attrs['compress'] = COMPRESS
|
||||||
obs = root.create_group('observations')
|
obs = root.create_group('observations')
|
||||||
image = obs.create_group('images')
|
image = obs.create_group('images')
|
||||||
for cam_name in image_dict.keys():
|
for cam_name in image_dict.keys():
|
||||||
_ = image.create_dataset(cam_name, (max_timesteps, 480, 640, 3), dtype='uint8',
|
if COMPRESS:
|
||||||
|
_ = image.create_dataset(cam_name, (max_timesteps, padded_size), dtype='uint8',
|
||||||
|
chunks=(1, padded_size), )
|
||||||
|
else:
|
||||||
|
_ = image.create_dataset(cam_name, (max_timesteps, 480, 640, 3), dtype='uint8',
|
||||||
chunks=(1, 480, 640, 3), )
|
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))
|
qpos = obs.create_dataset('qpos', (max_timesteps, 14))
|
||||||
qvel = obs.create_dataset('qvel', (max_timesteps, 14))
|
qvel = obs.create_dataset('qvel', (max_timesteps, 14))
|
||||||
action = root.create_dataset('action', (max_timesteps, 14))
|
action = root.create_dataset('action', (max_timesteps, 14))
|
||||||
@ -106,11 +156,17 @@ def main(args):
|
|||||||
|
|
||||||
for name, array in data_dict.items():
|
for name, array in data_dict.items():
|
||||||
root[name][...] = array
|
root[name][...] = array
|
||||||
|
|
||||||
|
if COMPRESS:
|
||||||
|
_ = root.create_dataset('compress_len', (len(image_dict.keys()), max_timesteps))
|
||||||
|
root['/compress_len'][...] = compressed_len
|
||||||
|
|
||||||
print(f'Saving {dataset_path}: {time.time() - t0:.1f} secs\n')
|
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'))
|
if episode_idx == start_idx:
|
||||||
# visualize_joints(qpos, action, plot_path=os.path.join(dataset_dir, dataset_name + '_mirror_qpos.png'))
|
save_videos(image_dict, DT, video_path=os.path.join(dataset_dir, dataset_name + '_mirror_video.mp4'))
|
||||||
# visualize_timestamp(t_list, dataset_path) # TODO addn timestamp back
|
# 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__':
|
if __name__ == '__main__':
|
||||||
parser = argparse.ArgumentParser()
|
parser = argparse.ArgumentParser()
|
||||||
|
|||||||
58
utils.py
58
utils.py
@ -2,14 +2,16 @@ import numpy as np
|
|||||||
import torch
|
import torch
|
||||||
import os
|
import os
|
||||||
import h5py
|
import h5py
|
||||||
|
import pickle
|
||||||
import fnmatch
|
import fnmatch
|
||||||
|
import cv2
|
||||||
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, dataset_path_list, camera_names, norm_stats, episode_ids, episode_len, chunk_size):
|
def __init__(self, dataset_path_list, camera_names, norm_stats, episode_ids, episode_len, chunk_size, policy_class):
|
||||||
super(EpisodicDataset).__init__()
|
super(EpisodicDataset).__init__()
|
||||||
self.episode_ids = episode_ids
|
self.episode_ids = episode_ids
|
||||||
self.dataset_path_list = dataset_path_list
|
self.dataset_path_list = dataset_path_list
|
||||||
@ -19,6 +21,7 @@ class EpisodicDataset(torch.utils.data.Dataset):
|
|||||||
self.chunk_size = chunk_size
|
self.chunk_size = chunk_size
|
||||||
self.cumulative_len = np.cumsum(self.episode_len)
|
self.cumulative_len = np.cumsum(self.episode_len)
|
||||||
self.max_episode_len = max(episode_len)
|
self.max_episode_len = max(episode_len)
|
||||||
|
self.policy_class = policy_class
|
||||||
self.__getitem__(0) # initialize self.is_sim
|
self.__getitem__(0) # initialize self.is_sim
|
||||||
self.is_sim = False
|
self.is_sim = False
|
||||||
|
|
||||||
@ -42,6 +45,7 @@ class EpisodicDataset(torch.utils.data.Dataset):
|
|||||||
is_sim = root.attrs['sim']
|
is_sim = root.attrs['sim']
|
||||||
except:
|
except:
|
||||||
is_sim = False
|
is_sim = False
|
||||||
|
compressed = root.attrs.get('compress', 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)
|
||||||
@ -58,6 +62,12 @@ class EpisodicDataset(torch.utils.data.Dataset):
|
|||||||
image_dict = dict()
|
image_dict = dict()
|
||||||
for cam_name in self.camera_names:
|
for cam_name in self.camera_names:
|
||||||
image_dict[cam_name] = root[f'/observations/images/{cam_name}'][start_ts]
|
image_dict[cam_name] = root[f'/observations/images/{cam_name}'][start_ts]
|
||||||
|
|
||||||
|
if compressed:
|
||||||
|
for cam_name in image_dict.keys():
|
||||||
|
decompressed_image = cv2.imdecode(image_dict[cam_name], 1)
|
||||||
|
image_dict[cam_name] = np.array(decompressed_image)
|
||||||
|
|
||||||
# get all actions after and including start_ts
|
# get all actions after and including start_ts
|
||||||
if is_sim:
|
if is_sim:
|
||||||
action = action[start_ts:]
|
action = action[start_ts:]
|
||||||
@ -92,7 +102,14 @@ class EpisodicDataset(torch.utils.data.Dataset):
|
|||||||
|
|
||||||
# normalize image and change dtype to float
|
# normalize image and change dtype to float
|
||||||
image_data = image_data / 255.0
|
image_data = image_data / 255.0
|
||||||
action_data = (action_data - self.norm_stats["action_mean"]) / self.norm_stats["action_std"]
|
|
||||||
|
if self.policy_class == 'Diffusion':
|
||||||
|
# normalize to [-1, 1]
|
||||||
|
action_data = ((action_data - self.norm_stats["action_min"]) / (self.norm_stats["action_max"] - self.norm_stats["action_min"])) * 2 - 1
|
||||||
|
else:
|
||||||
|
# normalize to mean 0 std 1
|
||||||
|
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:
|
except:
|
||||||
@ -141,7 +158,12 @@ def get_norm_stats(dataset_path_list):
|
|||||||
qpos_std = all_qpos_data.std(dim=[0]).float()
|
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
|
||||||
|
|
||||||
|
action_min = all_action_data.min(dim=0).values.float()
|
||||||
|
action_max = all_action_data.max(dim=0).values.float()
|
||||||
|
|
||||||
|
eps = 0.0001
|
||||||
stats = {"action_mean": action_mean.numpy(), "action_std": action_std.numpy(),
|
stats = {"action_mean": action_mean.numpy(), "action_std": action_std.numpy(),
|
||||||
|
"action_min": action_min.numpy() - eps,"action_max": action_max.numpy() + eps,
|
||||||
"qpos_mean": qpos_mean.numpy(), "qpos_std": qpos_std.numpy(),
|
"qpos_mean": qpos_mean.numpy(), "qpos_std": qpos_std.numpy(),
|
||||||
"example_qpos": qpos}
|
"example_qpos": qpos}
|
||||||
|
|
||||||
@ -158,7 +180,7 @@ def find_all_hdf5(dataset_dir, skip_mirrored_data):
|
|||||||
return hdf5_files
|
return hdf5_files
|
||||||
|
|
||||||
|
|
||||||
def load_data(dataset_dir, name_filter, camera_names, batch_size_train, batch_size_val, chunk_size, skip_mirrored_data=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, policy_class=None):
|
||||||
dataset_path_list = find_all_hdf5(dataset_dir, skip_mirrored_data)
|
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)]
|
dataset_path_list = [n for n in dataset_path_list if name_filter(n)]
|
||||||
num_episodes = len(dataset_path_list)
|
num_episodes = len(dataset_path_list)
|
||||||
@ -171,37 +193,47 @@ def load_data(dataset_dir, name_filter, camera_names, batch_size_train, batch_si
|
|||||||
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')
|
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:
|
||||||
|
# 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)
|
||||||
|
# print('Loaded pretrain dataset stats')
|
||||||
norm_stats, all_episode_len = get_norm_stats(dataset_path_list)
|
norm_stats, all_episode_len = get_norm_stats(dataset_path_list)
|
||||||
train_episode_len = [all_episode_len[i] for i in train_episode_ids]
|
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]
|
val_episode_len = [all_episode_len[i] for i in val_episode_ids]
|
||||||
|
|
||||||
# construct dataset and dataloader
|
# construct dataset and dataloader
|
||||||
train_dataset = EpisodicDataset(dataset_path_list, camera_names, norm_stats, train_episode_ids, train_episode_len, chunk_size)
|
train_dataset = EpisodicDataset(dataset_path_list, camera_names, norm_stats, train_episode_ids, train_episode_len, chunk_size, policy_class)
|
||||||
val_dataset = EpisodicDataset(dataset_path_list, camera_names, norm_stats, val_episode_ids, val_episode_len, chunk_size)
|
val_dataset = EpisodicDataset(dataset_path_list, camera_names, norm_stats, val_episode_ids, val_episode_len, chunk_size, policy_class)
|
||||||
train_dataloader = DataLoader(train_dataset, batch_size=batch_size_train, shuffle=True, pin_memory=True, num_workers=1, prefetch_factor=1)
|
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)
|
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):
|
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[:, 0] = v - c * w
|
base_action = base_action.copy()
|
||||||
|
base_action[..., 0] = v - c * w
|
||||||
return base_action
|
return base_action
|
||||||
|
|
||||||
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).astype(np.float32)
|
], 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)
|
base_action = smooth_base_action(base_action)
|
||||||
|
|
||||||
return base_action
|
return base_action
|
||||||
|
|
||||||
|
def postprocess_base_action(self, base_action):
|
||||||
|
linear_vel, angular_vel = base_action
|
||||||
|
angular_vel *= 0.9
|
||||||
|
return np.array([linear_vel, angular_vel])
|
||||||
|
|
||||||
### env utils
|
### env utils
|
||||||
|
|
||||||
def sample_box_pose():
|
def sample_box_pose():
|
||||||
|
|||||||
在新工单中引用
屏蔽一个用户