refactor co-training data loading pipeline

这个提交包含在:
Zipeng Fu
2023-11-25 16:16:32 -08:00
父节点 4228c61cd9
当前提交 265dad7cba
共有 2 个文件被更改,包括 103 次插入 和 50 次删除

查看文件

@ -495,7 +495,7 @@ def train_bc(train_dataloader, val_dataloader, config):
for batch_idx, data in enumerate(val_dataloader): for batch_idx, data in enumerate(val_dataloader):
forward_dict = forward_pass(data, policy) forward_dict = forward_pass(data, policy)
validation_dicts.append(forward_dict) validation_dicts.append(forward_dict)
if batch_idx > 20: if batch_idx > 50:
break break
validation_summary = compute_dict_mean(validation_dicts) validation_summary = compute_dict_mean(validation_dicts)

151
utils.py
查看文件

@ -14,38 +14,33 @@ def flatten_list(l):
return [item for sublist in l for item in sublist] return [item for sublist in l for item in sublist]
class EpisodicDataset(torch.utils.data.Dataset): class EpisodicDataset(torch.utils.data.Dataset):
def __init__(self, dataset_path_l, camera_names, norm_stats, episode_id_l, episode_len_l, chunk_size, policy_class, sample_weights=None): 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_id_l = episode_id_l self.episode_ids = episode_ids
self.dataset_path_l = dataset_path_l self.dataset_path_list = dataset_path_list
self.camera_names = camera_names self.camera_names = camera_names
self.norm_stats = norm_stats self.norm_stats = norm_stats
self.episode_len_l = episode_len_l self.episode_len = episode_len
self.sum_episode_len_l = [sum(episode_len) for episode_len in episode_len_l]
self.chunk_size = chunk_size self.chunk_size = chunk_size
self.cumulative_len_l = [np.cumsum(episode_len) for episode_len in episode_len_l] self.cumulative_len = np.cumsum(self.episode_len)
self.max_episode_len = max([max(episode_len) for episode_len in episode_len_l]) self.max_episode_len = max(episode_len)
self.policy_class = policy_class self.policy_class = policy_class
self.sample_weights = np.array(sample_weights) / np.sum(sample_weights) if sample_weights is not None else None # None is uniform sampling
self.__getitem__(0) # initialize self.is_sim self.__getitem__(0) # initialize self.is_sim
self.is_sim = False self.is_sim = False
# dummy # def __len__(self):
def __len__(self): # return sum(self.episode_len)
return sum(self.episode_len_l[0])
def _locate_transition(self): def _locate_transition(self, index):
dataset_idx = np.random.choice(len(self.dataset_path_l), p=self.sample_weights) assert index < self.cumulative_len[-1]
step_idx = np.random.randint(self.sum_episode_len_l[dataset_idx]) episode_index = np.argmax(self.cumulative_len > index) # argmax returns first True index
start_ts = index - (self.cumulative_len[episode_index] - self.episode_len[episode_index])
episode_idx = np.argmax(self.cumulative_len_l[dataset_idx] > step_idx) # argmax returns first True index episode_id = self.episode_ids[episode_index]
start_ts = step_idx - (self.cumulative_len_l[dataset_idx][episode_idx] - self.episode_len_l[dataset_idx][episode_idx]) return episode_id, start_ts
episode_id = self.episode_id_l[dataset_idx][episode_idx]
return dataset_idx, episode_id, start_ts
def __getitem__(self, _): def __getitem__(self, index):
dataset_idx, episode_id, start_ts = self._locate_transition() episode_id, start_ts = self._locate_transition(index)
dataset_path = self.dataset_path_l[dataset_idx][episode_id] dataset_path = self.dataset_path_list[episode_id]
try: try:
# print(dataset_path) # print(dataset_path)
with h5py.File(dataset_path, 'r') as root: with h5py.File(dataset_path, 'r') as root:
@ -186,51 +181,109 @@ def find_all_hdf5(dataset_dir, skip_mirrored_data):
print(f'Found {len(hdf5_files)} hdf5 files') print(f'Found {len(hdf5_files)} hdf5 files')
return hdf5_files return hdf5_files
def BatchSampler(batch_size, episode_len_l, sample_weights):
sample_probs = np.array(sample_weights) / np.sum(sample_weights) if sample_weights is not None else None
sum_dataset_len_l = np.cumsum([0] + [np.sum(episode_len) for episode_len in episode_len_l])
while True:
batch = []
for _ in range(batch_size):
episode_idx = np.random.choice(len(episode_len_l), p=sample_probs)
step_idx = np.random.randint(sum_dataset_len_l[episode_idx], sum_dataset_len_l[episode_idx + 1])
batch.append(step_idx)
yield batch
# def load_data(dataset_dir_l, name_filter, camera_names, batch_size_train, batch_size_val, chunk_size, skip_mirrored_data=False, load_pretrain=False, policy_class=None, stats_dir_l=None, sample_weights=None, train_ratio=0.99):
# if type(dataset_dir_l) == str:
# dataset_dir_l = [dataset_dir_l]
# train_dataset_path_l = [find_all_hdf5(dataset_dir, skip_mirrored_data) for dataset_dir in dataset_dir_l]
# # val only on dataset_dir_l[0]
# val_dataset_path_l = [train_dataset_path_l[0]]
# # train_dataset_path_l = [n for n in train_dataset_path_l if name_filter(n)]
# num_episodes = [len(dataset_path_list) for dataset_path_list in train_dataset_path_l]
# # obtain train val split for dataset_dir_l[0]
# num_episodes_0 = num_episodes[0]
# shuffled_episode_id_0 = np.random.permutation(num_episodes_0)
# train_episode_id_0 = shuffled_episode_id_0[:int(train_ratio * num_episodes_0)]
# val_episode_id_0 = shuffled_episode_id_0[int(train_ratio * num_episodes_0):]
# train_episode_id_l = [train_episode_id_0]
# val_episode_id_l = [val_episode_id_0]
# for num_episode in num_episodes[1:]:
# train_episode_id_l.append(np.arange(num_episode, dtype=np.int))
# print(f'\n\nData from: {dataset_dir_l}\n- Train on {[len(train_episode_id) for train_episode_id in train_episode_id_l]} episodes\n- Test on {[len(val_episode_id) for val_episode_id in val_episode_id_l]} episodes\n\n')
# # 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')
# train_episode_len_l = []
# val_episode_len_l = []
# for idx, (train_dataset_path, train_episode_id) in enumerate(zip(train_dataset_path_l, train_episode_id_l)):
# _, all_episode_len = get_norm_stats(train_dataset_path)
# train_episode_len_l.append([all_episode_len[i] for i in train_episode_id])
# if idx == 0:
# val_episode_len_l.append([all_episode_len[i] for i in val_episode_id_0])
# if stats_dir_l is None:
# stats_dir_l = dataset_dir_l
# elif type(stats_dir_l) == str:
# stats_dir_l = [stats_dir_l]
# norm_stats, _ = get_norm_stats(flatten_list([find_all_hdf5(stats_dir, skip_mirrored_data) for stats_dir in stats_dir_l]))
# # construct dataset and dataloader
# train_dataset = EpisodicDataset(train_dataset_path_l, camera_names, norm_stats, train_episode_id_l, train_episode_len_l, chunk_size, policy_class, sample_weights=sample_weights)
# val_dataset = EpisodicDataset(val_dataset_path_l, camera_names, norm_stats, val_episode_id_l, val_episode_len_l, chunk_size, policy_class, sample_weights=None)
# train_dataloader = DataLoader(train_dataset, batch_size=batch_size_train, shuffle=True, pin_memory=True, num_workers=2, prefetch_factor=2)
# val_dataloader = DataLoader(val_dataset, batch_size=batch_size_val, shuffle=True, pin_memory=True, num_workers=2, prefetch_factor=2)
#
# return train_dataloader, val_dataloader, norm_stats, train_dataset.is_sim
def load_data(dataset_dir_l, name_filter, camera_names, batch_size_train, batch_size_val, chunk_size, skip_mirrored_data=False, load_pretrain=False, policy_class=None, stats_dir_l=None, sample_weights=None, train_ratio=0.99): def load_data(dataset_dir_l, name_filter, camera_names, batch_size_train, batch_size_val, chunk_size, skip_mirrored_data=False, load_pretrain=False, policy_class=None, stats_dir_l=None, sample_weights=None, train_ratio=0.99):
if type(dataset_dir_l) == str: if type(dataset_dir_l) == str:
dataset_dir_l = [dataset_dir_l] dataset_dir_l = [dataset_dir_l]
train_dataset_path_l = [find_all_hdf5(dataset_dir, skip_mirrored_data) for dataset_dir in dataset_dir_l] dataset_path_list_list = [find_all_hdf5(dataset_dir, skip_mirrored_data) for dataset_dir in dataset_dir_l]
# val only on dataset_dir_l[0] num_episodes_0 = len(dataset_path_list_list[0])
val_dataset_path_l = [train_dataset_path_l[0]] dataset_path_list = flatten_list(dataset_path_list_list)
# train_dataset_path_l = [n for n in train_dataset_path_l if name_filter(n)] dataset_path_list = [n for n in dataset_path_list if name_filter(n)]
num_episodes_l = [len(dataset_path_list) for dataset_path_list in dataset_path_list_list]
num_episodes_cumsum = np.cumsum(num_episodes_l)
num_episodes = [len(dataset_path_list) for dataset_path_list in train_dataset_path_l] # obtain train test split on dataset_dir_l[0]
shuffled_episode_ids_0 = np.random.permutation(num_episodes_0)
# obtain train val split for dataset_dir_l[0] train_episode_ids_0 = shuffled_episode_ids_0[:int(train_ratio * num_episodes_0)]
num_episodes_0 = num_episodes[0] val_episode_ids_0 = shuffled_episode_ids_0[int(train_ratio * num_episodes_0):]
shuffled_episode_id_0 = np.random.permutation(num_episodes_0) train_episode_ids_l = [train_episode_ids_0] + [np.arange(num_episodes, dtype=np.int) + num_episodes_cumsum[idx] for idx, num_episodes in enumerate(num_episodes_l[1:])]
train_episode_id_0 = shuffled_episode_id_0[:int(train_ratio * num_episodes_0)] val_episode_ids_l = [val_episode_ids_0]
val_episode_id_0 = shuffled_episode_id_0[int(train_ratio * num_episodes_0):] train_episode_ids = np.concatenate(train_episode_ids_l)
train_episode_id_l = [train_episode_id_0] val_episode_ids = np.concatenate(val_episode_ids_l)
val_episode_id_l = [val_episode_id_0] print(f'\n\nData from: {dataset_dir_l}\n- Train on {[len(x) for x in train_episode_ids_l]} episodes\n- Test on {[len(x) for x in val_episode_ids_l]} episodes\n\n')
for num_episode in num_episodes[1:]:
train_episode_id_l.append(np.arange(num_episode, dtype=np.int))
print(f'\n\nData from: {dataset_dir_l}\n- Train on {[len(train_episode_id) for train_episode_id in train_episode_id_l]} episodes\n- Test on {[len(val_episode_id) for val_episode_id in val_episode_id_l]} episodes\n\n')
# obtain normalization stats for qpos and action # obtain normalization stats for qpos and action
# if load_pretrain: # if load_pretrain:
# with open(os.path.join('/home/zfu/interbotix_ws/src/act/ckpts/pretrain_all', 'dataset_stats.pkl'), 'rb') as f: # with open(os.path.join('/home/zfu/interbotix_ws/src/act/ckpts/pretrain_all', 'dataset_stats.pkl'), 'rb') as f:
# norm_stats = pickle.load(f) # norm_stats = pickle.load(f)
# print('Loaded pretrain dataset stats') # print('Loaded pretrain dataset stats')
train_episode_len_l = [] _, all_episode_len = get_norm_stats(dataset_path_list)
val_episode_len_l = [] train_episode_len_l = [[all_episode_len[i] for i in train_episode_ids] for train_episode_ids in train_episode_ids_l]
for idx, (train_dataset_path, train_episode_id) in enumerate(zip(train_dataset_path_l, train_episode_id_l)): val_episode_len_l = [[all_episode_len[i] for i in val_episode_ids] for val_episode_ids in val_episode_ids_l]
_, all_episode_len = get_norm_stats(train_dataset_path) train_episode_len = flatten_list(train_episode_len_l)
train_episode_len_l.append([all_episode_len[i] for i in train_episode_id]) val_episode_len = flatten_list(val_episode_len_l)
if idx == 0:
val_episode_len_l.append([all_episode_len[i] for i in val_episode_id_0])
if stats_dir_l is None: if stats_dir_l is None:
stats_dir_l = dataset_dir_l stats_dir_l = dataset_dir_l
elif type(stats_dir_l) == str: elif type(stats_dir_l) == str:
stats_dir_l = [stats_dir_l] stats_dir_l = [stats_dir_l]
norm_stats, _ = get_norm_stats(flatten_list([find_all_hdf5(stats_dir, skip_mirrored_data) for stats_dir in stats_dir_l])) norm_stats, _ = get_norm_stats(flatten_list([find_all_hdf5(stats_dir, skip_mirrored_data) for stats_dir in stats_dir_l]))
batch_sampler_train = BatchSampler(batch_size_train, train_episode_len_l, sample_weights)
batch_sampler_val = BatchSampler(batch_size_val, val_episode_len_l, None)
# construct dataset and dataloader # construct dataset and dataloader
train_dataset = EpisodicDataset(train_dataset_path_l, camera_names, norm_stats, train_episode_id_l, train_episode_len_l, chunk_size, policy_class, sample_weights=sample_weights) train_dataset = EpisodicDataset(dataset_path_list, camera_names, norm_stats, train_episode_ids, train_episode_len, chunk_size, policy_class)
val_dataset = EpisodicDataset(val_dataset_path_l, camera_names, norm_stats, val_episode_id_l, val_episode_len_l, chunk_size, policy_class, sample_weights=None) 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=2, prefetch_factor=2) train_dataloader = DataLoader(train_dataset, batch_sampler=batch_sampler_train, 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=2, prefetch_factor=2) val_dataloader = DataLoader(val_dataset, batch_sampler=batch_sampler_val, 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