8 次代码提交

作者 SHA1 备注 提交日期
637d4f9a93 ema fixed 2023-11-23 18:19:45 -08:00
71c46d8649 fix compress_data.py 2023-11-14 17:13:33 -08:00
b7e387a9b9 Merge branch 'main' of github.com:MarkFzp/act-plus-plus into main 2023-11-14 14:43:05 -08:00
8f66f3bc88 use mobile-aloha2 2023-11-14 14:38:11 -08:00
79e5032002 Diffusion policy 2023-11-14 11:02:33 -08:00
61decb1e13 add compress to postprocess_episodes.py 2023-11-11 19:06:55 -08:00
5376392e66 dataloader __getitem__ supported compressed 2023-11-11 18:16:15 -05:00
329a237290 fix video viz bgr 2023-11-10 21:12:11 -08:00
共有 9 个文件被更改,包括 411 次插入 和 111 次删除

查看文件

@ -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,26 +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 --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
## Nov 10 history
conda activate mobile conda activate mobile
export MUJOCO_GL=egl export MUJOCO_GL=egl
cd /home/tonyzhao/Research/act-plus-plus cd /home/tonyzhao/Research/act-plus-plus
CUDA_VISIBLE_DEVICES=0 python3 imitate_episodes.py \ CUDA_VISIBLE_DEVICES=0 python3 imitate_episodes.py \
--task_name sim_insertion_scripted_mirror \ --task_name sim_transfer_cube_scripted \
--ckpt_dir /scr/tonyzhao/train_logs/cube_scripted_test_history \ --ckpt_dir /scr/tonyzhao/train_logs/cube_scripted_diffusion_sweep_0 \
--policy_class ACT --kl_weight 10 --chunk_size 50 \ --policy_class Diffusion --chunk_size 32 \
--hidden_dim 512 --batch_size 12 --dim_feedforward 3200 --lr 1e-5 --seed 0 \ --batch_size 32 --lr 1e-5 --seed 0 \
--num_steps 100000 --eval_every 100000 --validate_every 5000 --save_every 2000 \ --num_steps 100000 --eval_every 2000 --validate_every 2000 --save_every 2000
--skip_mirrored_data --no_encoder --history 100 --eval
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

查看文件

@ -26,7 +26,10 @@ def compress_dataset(input_dataset_path, output_dataset_path):
# Create the compressed dataset # Create the compressed dataset
with h5py.File(output_dataset_path, 'w') as outfile: with h5py.File(output_dataset_path, 'w') as outfile:
outfile.attrs['sim'] = infile.attrs['sim'] if 'sim' in infile.attrs:
outfile.attrs['sim'] = infile.attrs['sim']
else:
outfile.attrs['sim'] = False
outfile.attrs['compress'] = True outfile.attrs['compress'] = True
# Copy non-image data directly # Copy non-image data directly
@ -99,7 +102,7 @@ def save_videos(video, dt, video_path=None):
images = [] images = []
for cam_name in cam_names: for cam_name in cam_names:
image = image_dict[cam_name] image = image_dict[cam_name]
# image = image[:, :, [2, 1, 0]] # swap B and R channel image = image[:, :, [2, 1, 0]] # swap B and R channel
images.append(image) images.append(image)
images = np.concatenate(images, axis=1) images = np.concatenate(images, axis=1)
out.write(images) out.write(images)
@ -119,7 +122,7 @@ def save_videos(video, dt, video_path=None):
out = cv2.VideoWriter(video_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h)) out = cv2.VideoWriter(video_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))
for t in range(n_frames): for t in range(n_frames):
image = all_cam_videos[t] image = all_cam_videos[t]
# image = image[:, :, [2, 1, 0]] # swap B and R channel image = image[:, :, [2, 1, 0]] # swap B and R channel
out.write(image) out.write(image)
out.release() out.release()
print(f'Saved video to: {video_path}') print(f'Saved video to: {video_path}')

查看文件

@ -75,7 +75,6 @@ def get_args_parser():
parser.add_argument('--resume_ckpt_path', action='store', type=str, help='load_ckpt_path', 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('--no_encoder', action='store_true')
parser.add_argument('--skip_mirrored_data', action='store_true') parser.add_argument('--skip_mirrored_data', action='store_true')
parser.add_argument('--history', action='store', type=int, required=False, default=0) # default no history
return parser return parser

查看文件

@ -111,22 +111,6 @@ class Joiner(nn.Sequential):
return out, pos return out, pos
class JoinerChannelConcat(nn.Sequential):
def __init__(self, backbone, position_embedding, conv):
super().__init__(backbone, position_embedding, conv)
def forward(self, tensor_list: NestedTensor):
tensor_list = self[2](tensor_list) # 6 to 3 channels
xs = self[0](tensor_list)
out: List[NestedTensor] = []
pos = []
for name, x in xs.items():
out.append(x)
# position encoding
pos.append(self[1](x).to(x.dtype))
return out, pos
def build_backbone(args): def build_backbone(args):
position_embedding = build_position_encoding(args) position_embedding = build_position_encoding(args)
@ -136,15 +120,3 @@ def build_backbone(args):
model = Joiner(backbone, position_embedding) model = Joiner(backbone, position_embedding)
model.num_channels = backbone.num_channels model.num_channels = backbone.num_channels
return model return model
def build_backbone_channel_concat(args):
position_embedding = build_position_encoding(args)
train_backbone = args.lr_backbone > 0
return_interm_layers = args.masks
backbone = Backbone(args.backbone, train_backbone, return_interm_layers, args.dilation)
conv = nn.Conv2d(in_channels=6, out_channels=3, kernel_size=3, stride=1, padding=1)
model = JoinerChannelConcat(backbone, position_embedding, conv)
model.num_channels = backbone.num_channels
return model

查看文件

@ -6,7 +6,7 @@ import torch
from torch import nn from torch import nn
from torch.autograd import Variable from torch.autograd import Variable
import torch.nn.functional as F import torch.nn.functional as F
from .backbone import build_backbone, build_backbone_channel_concat from .backbone import build_backbone
from .transformer import build_transformer, TransformerEncoder, TransformerEncoderLayer from .transformer import build_transformer, TransformerEncoder, TransformerEncoderLayer
import numpy as np import numpy as np
@ -274,12 +274,8 @@ def build(args):
# From image # From image
backbones = [] backbones = []
for _ in args.camera_names: for _ in args.camera_names:
if args.history >= 1: backbone = build_backbone(args)
backbone = build_backbone_channel_concat(args) backbones.append(backbone)
backbones.append(backbone)
else:
backbone = build_backbone(args)
backbones.append(backbone)
transformer = build_transformer(args) transformer = build_transformer(args)

查看文件

@ -8,7 +8,6 @@ from copy import deepcopy
from itertools import repeat from itertools import repeat
from tqdm import tqdm from tqdm import tqdm
from einops import rearrange from einops import rearrange
from collections import deque
import wandb import wandb
from constants import DT from constants import DT
@ -16,7 +15,7 @@ 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, calibrate_linear_vel, postprocess_base_action # 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
@ -41,7 +40,6 @@ def main(args):
validate_every = args['validate_every'] validate_every = args['validate_every']
save_every = args['save_every'] save_every = args['save_every']
resume_ckpt_path = args['resume_ckpt_path'] resume_ckpt_path = args['resume_ckpt_path']
history = args['history']
# get task parameters # get task parameters
is_sim = task_name[:4] == 'sim_' is_sim = task_name[:4] == 'sim_'
@ -81,7 +79,19 @@ def main(args):
'vq_dim': args['vq_dim'], 'vq_dim': args['vq_dim'],
'action_dim': 16, 'action_dim': 16,
'no_encoder': args['no_encoder'], 'no_encoder': args['no_encoder'],
'history': history, }
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,
@ -107,8 +117,7 @@ def main(args):
'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'], 'load_pretrain': args['load_pretrain']
'history': history,
} }
if not os.path.isdir(ckpt_dir): if not os.path.isdir(ckpt_dir):
@ -116,7 +125,7 @@ def main(args):
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]
if not is_eval: if not is_eval:
wandb.init(project="mobile-aloha", reinit=True, entity="mobile-aloha", name=expr_name) wandb.init(project="mobile-aloha2", reinit=True, entity="mobile-aloha2", name=expr_name)
wandb.config.update(config) 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)
@ -133,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'], history, args['skip_mirrored_data'], 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'], 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')
@ -155,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
@ -165,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,15 +205,13 @@ def eval_bc(config, ckpt_name, save_episode=True, num_rollouts=50):
max_timesteps = config['episode_len'] max_timesteps = config['episode_len']
task_name = config['task_name'] task_name = config['task_name']
temporal_agg = config['temporal_agg'] temporal_agg = config['temporal_agg']
history = config['history']
onscreen_cam = 'angle' onscreen_cam = 'angle'
vq = config['policy_config']['vq'] vq = config['policy_config']['vq']
has_history = history >= 1
# 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()
@ -209,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}')
@ -220,7 +231,10 @@ 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:
@ -267,8 +281,6 @@ def eval_bc(config, ckpt_name, save_episode=True, num_rollouts=50):
qpos_list = [] qpos_list = []
target_qpos_list = [] target_qpos_list = []
rewards = [] rewards = []
if has_history:
image_obs_history = deque(maxlen=history+1)
with torch.inference_mode(): with torch.inference_mode():
for t in range(max_timesteps): for t in range(max_timesteps):
### update onscreen render and wait for DT ### update onscreen render and wait for DT
@ -289,9 +301,6 @@ def eval_bc(config, ckpt_name, save_episode=True, num_rollouts=50):
qpos_history[:, t] = qpos qpos_history[:, t] = qpos
curr_image = get_image(ts, camera_names) curr_image = get_image(ts, camera_names)
if has_history:
image_obs_history.append(curr_image)
### query policy ### query policy
if config['policy_class'] == "ACT": if config['policy_class'] == "ACT":
if t % query_frequency == 0: if t % query_frequency == 0:
@ -303,9 +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:
if has_history: # e()
history_image = image_obs_history[0]
curr_image = torch.cat([curr_image, history_image], dim=2)
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
@ -319,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:
@ -399,10 +410,10 @@ def train_bc(train_dataloader, val_dataloader, config):
policy = make_policy(policy_class, policy_config) policy = make_policy(policy_class, policy_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.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}') 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)
@ -428,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}')
@ -443,7 +454,7 @@ 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=10) success, _ = eval_bc(config, ckpt_name, save_episode=True, num_rollouts=10)
wandb.log({'success': success}, step=step) wandb.log({'success': success}, step=step)
@ -460,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')
@ -509,6 +520,5 @@ if __name__ == '__main__':
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') parser.add_argument('--no_encoder', action='store_true')
parser.add_argument('--history', action='store', type=int, required=False, default=0) # default no history
main(vars(parser.parse_args())) main(vars(parser.parse_args()))

205
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__()
@ -19,15 +207,8 @@ class ACTPolicy(nn.Module):
def __call__(self, qpos, image, actions=None, is_pad=None, vq_sample=None): def __call__(self, qpos, image, actions=None, is_pad=None, vq_sample=None):
env_state = None env_state = None
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
if image.shape[2] == 6: std=[0.229, 0.224, 0.225])
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406] * 2,
std=[0.229, 0.224, 0.225] * 2)
else:
assert image.shape[2] == 3
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
image = normalize(image) image = normalize(image)
if actions is not None: # training time if actions is not None: # training time
actions = actions[:, :self.model.num_queries] actions = actions[:, :self.model.num_queries]
@ -63,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()

查看文件

@ -4,13 +4,14 @@ import os
import h5py import h5py
import pickle 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, history): 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
@ -18,9 +19,9 @@ class EpisodicDataset(torch.utils.data.Dataset):
self.norm_stats = norm_stats self.norm_stats = norm_stats
self.episode_len = episode_len self.episode_len = episode_len
self.chunk_size = chunk_size self.chunk_size = chunk_size
self.history = history
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
@ -44,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)
@ -59,13 +61,13 @@ class EpisodicDataset(torch.utils.data.Dataset):
qvel = root['/observations/qvel'][start_ts] qvel = root['/observations/qvel'][start_ts]
image_dict = dict() image_dict = dict()
for cam_name in self.camera_names: for cam_name in self.camera_names:
if self.history >= 1: image_dict[cam_name] = root[f'/observations/images/{cam_name}'][start_ts]
curr_frame = root[f'/observations/images/{cam_name}'][start_ts]
history_frame = root[f'/observations/images/{cam_name}'][max(0, start_ts - self.history)] if compressed:
concat_image = np.concatenate([curr_frame, history_frame], axis=2) for cam_name in image_dict.keys():
image_dict[cam_name] = concat_image decompressed_image = cv2.imdecode(image_dict[cam_name], 1)
else: image_dict[cam_name] = np.array(decompressed_image)
image_dict[cam_name] = root[f'/observations/images/{cam_name}'][start_ts]
# 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:]
@ -100,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:
@ -149,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}
@ -166,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, history, skip_mirrored_data=False, 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, 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)
@ -188,8 +202,8 @@ def load_data(dataset_dir, name_filter, camera_names, batch_size_train, batch_si
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, history) 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, history) 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)