add prediction_len to train_actuator_network.py
这个提交包含在:
@ -25,9 +25,10 @@ def main():
|
|||||||
# at test time, input desired speed profile and convert that to command
|
# at test time, input desired speed profile and convert that to command
|
||||||
|
|
||||||
#########################################################
|
#########################################################
|
||||||
history_len = 20
|
history_len = 50
|
||||||
future_len = 20
|
future_len = 50
|
||||||
batch_size_train = 8
|
prediction_len = 50
|
||||||
|
batch_size_train = 16
|
||||||
batch_size_val = 16
|
batch_size_val = 16
|
||||||
lr = 1e-5
|
lr = 1e-5
|
||||||
weight_decay = 1e-4
|
weight_decay = 1e-4
|
||||||
@ -36,10 +37,11 @@ def main():
|
|||||||
validate_every = 2000
|
validate_every = 2000
|
||||||
save_every = 2000
|
save_every = 2000
|
||||||
|
|
||||||
expr_name = f'actuator_network_test_{history_len}_{future_len}'
|
expr_name = f'actuator_network_test_{history_len}_{future_len}_{prediction_len}'
|
||||||
ckpt_dir = f'/scr/tonyzhao/train_logs/{expr_name}'
|
ckpt_dir = f'/scr/tonyzhao/train_logs/{expr_name}' if os.getlogin() == 'tonyzhao' else f'./ckpts/{expr_name}'
|
||||||
dataset_dir = '/scr/tonyzhao/compressed_datasets/aloha_mobile_fork/'
|
dataset_dir = '/scr/tonyzhao/compressed_datasets/aloha_mobile_fork/' if os.getlogin() == 'tonyzhao' else '/home/zfu/data/aloha_mobile_fork/'
|
||||||
#########################################################
|
#########################################################
|
||||||
|
assert(history_len + future_len >= prediction_len)
|
||||||
|
|
||||||
wandb.init(project="mobile-aloha2", reinit=True, entity="mobile-aloha2", name=expr_name) # mode='disabled',
|
wandb.init(project="mobile-aloha2", reinit=True, entity="mobile-aloha2", name=expr_name) # mode='disabled',
|
||||||
|
|
||||||
@ -65,6 +67,7 @@ def main():
|
|||||||
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]
|
||||||
|
assert(all_episode_len[0] % prediction_len == 0)
|
||||||
|
|
||||||
# save dataset stats
|
# save dataset stats
|
||||||
stats_path = os.path.join(ckpt_dir, f'actuator_net_stats.pkl')
|
stats_path = os.path.join(ckpt_dir, f'actuator_net_stats.pkl')
|
||||||
@ -72,12 +75,12 @@ def main():
|
|||||||
pickle.dump(norm_stats, f)
|
pickle.dump(norm_stats, f)
|
||||||
|
|
||||||
# construct dataset and dataloader
|
# construct dataset and dataloader
|
||||||
train_dataset = EpisodicDataset(dataset_path_list, norm_stats, train_episode_ids, train_episode_len, history_len, future_len)
|
train_dataset = EpisodicDataset(dataset_path_list, norm_stats, train_episode_ids, train_episode_len, history_len, future_len, prediction_len)
|
||||||
val_dataset = EpisodicDataset(dataset_path_list, norm_stats, val_episode_ids, val_episode_len, history_len, future_len)
|
val_dataset = EpisodicDataset(dataset_path_list, norm_stats, val_episode_ids, val_episode_len, history_len, future_len, prediction_len)
|
||||||
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)
|
||||||
|
|
||||||
policy = ActuatorNetwork().cuda()
|
policy = ActuatorNetwork(prediction_len).cuda()
|
||||||
optimizer = torch.optim.AdamW(policy.parameters(), lr=lr, weight_decay=weight_decay)
|
optimizer = torch.optim.AdamW(policy.parameters(), lr=lr, weight_decay=weight_decay)
|
||||||
|
|
||||||
n_parameters = sum(p.numel() for p in policy.parameters() if p.requires_grad)
|
n_parameters = sum(p.numel() for p in policy.parameters() if p.requires_grad)
|
||||||
@ -114,8 +117,8 @@ def main():
|
|||||||
summary_string += f'{k}: {v.item():.3f} '
|
summary_string += f'{k}: {v.item():.3f} '
|
||||||
print(summary_string)
|
print(summary_string)
|
||||||
|
|
||||||
visualize_prediction(dataset_path_list, val_episode_ids, policy, norm_stats, history_len, future_len, ckpt_dir, step, 'val')
|
visualize_prediction(dataset_path_list, val_episode_ids, policy, norm_stats, history_len, future_len, prediction_len, ckpt_dir, step, 'val')
|
||||||
visualize_prediction(dataset_path_list, train_episode_ids, policy, norm_stats, history_len, future_len, ckpt_dir, step, 'train')
|
visualize_prediction(dataset_path_list, train_episode_ids, policy, norm_stats, history_len, future_len, prediction_len, ckpt_dir, step, 'train')
|
||||||
|
|
||||||
|
|
||||||
# training
|
# training
|
||||||
@ -143,7 +146,7 @@ def main():
|
|||||||
print(f'Training finished:\nval loss {min_val_loss:.6f} at step {best_step}')
|
print(f'Training finished:\nval loss {min_val_loss:.6f} at step {best_step}')
|
||||||
|
|
||||||
|
|
||||||
def visualize_prediction(dataset_path_list, episode_ids, policy, norm_stats, history_len, future_len, ckpt_dir, step, name):
|
def visualize_prediction(dataset_path_list, episode_ids, policy, norm_stats, history_len, future_len, prediction_len, ckpt_dir, step, name):
|
||||||
num_vis = 2
|
num_vis = 2
|
||||||
episode_ids = episode_ids[:num_vis]
|
episode_ids = episode_ids[:num_vis]
|
||||||
vis_path = [dataset_path_list[i] for i in episode_ids]
|
vis_path = [dataset_path_list[i] for i in episode_ids]
|
||||||
@ -169,13 +172,13 @@ def visualize_prediction(dataset_path_list, episode_ids, policy, norm_stats, his
|
|||||||
episode_len = commanded_speed.shape[0]
|
episode_len = commanded_speed.shape[0]
|
||||||
|
|
||||||
all_pred = []
|
all_pred = []
|
||||||
for t in range(episode_len):
|
for t in range(0, episode_len, prediction_len):
|
||||||
offset_start_ts = t + history_len
|
offset_start_ts = t + history_len
|
||||||
policy_input = norm_observed_speed[offset_start_ts-history_len: offset_start_ts+future_len]
|
policy_input = norm_observed_speed[offset_start_ts-history_len: offset_start_ts+future_len]
|
||||||
policy_input = torch.from_numpy(policy_input).float().unsqueeze(dim=0).cuda()
|
policy_input = torch.from_numpy(policy_input).float().unsqueeze(dim=0).cuda()
|
||||||
pred = policy(policy_input)
|
pred = policy(policy_input)
|
||||||
pred = pred.detach().cpu().numpy()[0]
|
pred = pred.detach().cpu().numpy()[0]
|
||||||
all_pred.append(out_unnorm_fn(pred))
|
all_pred += out_unnorm_fn(pred).tolist()
|
||||||
all_pred = np.array(all_pred)
|
all_pred = np.array(all_pred)
|
||||||
|
|
||||||
plot_path = os.path.join(ckpt_dir, f'{name}{i}_step{step}_linear')
|
plot_path = os.path.join(ckpt_dir, f'{name}{i}_step{step}_linear')
|
||||||
@ -183,6 +186,9 @@ def visualize_prediction(dataset_path_list, episode_ids, policy, norm_stats, his
|
|||||||
plt.plot(commanded_speed[:, 0], label='commanded_speed_linear')
|
plt.plot(commanded_speed[:, 0], label='commanded_speed_linear')
|
||||||
plt.plot(observed_speed[:, 0], label='observed_speed_linear')
|
plt.plot(observed_speed[:, 0], label='observed_speed_linear')
|
||||||
plt.plot(all_pred[:, 0], label='pred_commanded_speed_linear')
|
plt.plot(all_pred[:, 0], label='pred_commanded_speed_linear')
|
||||||
|
# plot vertical grey dotted lines every prediction_len
|
||||||
|
for t in range(0, episode_len, prediction_len):
|
||||||
|
plt.axvline(t, linestyle='--', color='grey')
|
||||||
plt.legend()
|
plt.legend()
|
||||||
plt.savefig(plot_path)
|
plt.savefig(plot_path)
|
||||||
plt.close()
|
plt.close()
|
||||||
@ -192,6 +198,9 @@ def visualize_prediction(dataset_path_list, episode_ids, policy, norm_stats, his
|
|||||||
plt.plot(commanded_speed[:, 1], label='commanded_speed_angular')
|
plt.plot(commanded_speed[:, 1], label='commanded_speed_angular')
|
||||||
plt.plot(observed_speed[:, 1], label='observed_speed_angular')
|
plt.plot(observed_speed[:, 1], label='observed_speed_angular')
|
||||||
plt.plot(all_pred[:, 1], label='pred_commanded_speed_angular')
|
plt.plot(all_pred[:, 1], label='pred_commanded_speed_angular')
|
||||||
|
# plot vertical dotted lines every prediction_len
|
||||||
|
for t in range(0, episode_len, prediction_len):
|
||||||
|
plt.axvline(t, linestyle='--', color='grey')
|
||||||
plt.legend()
|
plt.legend()
|
||||||
plt.savefig(plot_path)
|
plt.savefig(plot_path)
|
||||||
plt.close()
|
plt.close()
|
||||||
@ -200,7 +209,7 @@ def visualize_prediction(dataset_path_list, episode_ids, policy, norm_stats, his
|
|||||||
|
|
||||||
class ActuatorNetwork(nn.Module):
|
class ActuatorNetwork(nn.Module):
|
||||||
|
|
||||||
def __init__(self):
|
def __init__(self, prediction_len):
|
||||||
super().__init__()
|
super().__init__()
|
||||||
d_model = 256
|
d_model = 256
|
||||||
encoder_layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=8)
|
encoder_layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=8)
|
||||||
@ -208,6 +217,7 @@ class ActuatorNetwork(nn.Module):
|
|||||||
self.pe = PositionalEncoding(d_model)
|
self.pe = PositionalEncoding(d_model)
|
||||||
self.in_proj = nn.Linear(2, d_model)
|
self.in_proj = nn.Linear(2, d_model)
|
||||||
self.out_proj = nn.Linear(d_model, 2)
|
self.out_proj = nn.Linear(d_model, 2)
|
||||||
|
self.prediction_len = prediction_len
|
||||||
|
|
||||||
def forward(self, src, tgt=None):
|
def forward(self, src, tgt=None):
|
||||||
if tgt is not None: # training time
|
if tgt is not None: # training time
|
||||||
@ -216,19 +226,24 @@ class ActuatorNetwork(nn.Module):
|
|||||||
src = torch.einsum('b s d -> s b d', src)
|
src = torch.einsum('b s d -> s b d', src)
|
||||||
src = self.pe(src)
|
src = self.pe(src)
|
||||||
out = self.transformer(src)
|
out = self.transformer(src)
|
||||||
out = out[0] # take first token only
|
|
||||||
|
tgt = torch.einsum('b s d -> s b d', tgt)
|
||||||
|
assert(self.prediction_len == tgt.shape[0])
|
||||||
|
out = out[0: self.prediction_len] # take first few tokens only for prediction
|
||||||
out = self.out_proj(out)
|
out = self.out_proj(out)
|
||||||
|
|
||||||
l2_loss = loss = F.mse_loss(out, tgt)
|
l2_loss = loss = F.mse_loss(out, tgt)
|
||||||
loss_dict = {'loss': l2_loss}
|
loss_dict = {'loss': l2_loss}
|
||||||
|
out = torch.einsum('s b d -> b s d', out)
|
||||||
return out, loss_dict
|
return out, loss_dict
|
||||||
else:
|
else:
|
||||||
src = self.in_proj(src)
|
src = self.in_proj(src)
|
||||||
src = torch.einsum('b s d -> s b d', src)
|
src = torch.einsum('b s d -> s b d', src)
|
||||||
src = self.pe(src)
|
src = self.pe(src)
|
||||||
out = self.transformer(src)
|
out = self.transformer(src)
|
||||||
out = out[0] # take first token only
|
out = out[0: self.prediction_len] # take first few tokens only for prediction
|
||||||
out = self.out_proj(out)
|
out = self.out_proj(out)
|
||||||
|
out = torch.einsum('s b d -> b s d', out)
|
||||||
return out
|
return out
|
||||||
|
|
||||||
|
|
||||||
@ -288,7 +303,7 @@ def get_norm_stats(dataset_path_list):
|
|||||||
|
|
||||||
|
|
||||||
class EpisodicDataset(torch.utils.data.Dataset):
|
class EpisodicDataset(torch.utils.data.Dataset):
|
||||||
def __init__(self, dataset_path_list, norm_stats, episode_ids, episode_len, history_len, future_len):
|
def __init__(self, dataset_path_list, norm_stats, episode_ids, episode_len, history_len, future_len, prediction_len):
|
||||||
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
|
||||||
@ -298,9 +313,11 @@ class EpisodicDataset(torch.utils.data.Dataset):
|
|||||||
self.max_episode_len = max(episode_len)
|
self.max_episode_len = max(episode_len)
|
||||||
self.history_len = history_len
|
self.history_len = history_len
|
||||||
self.future_len = future_len
|
self.future_len = future_len
|
||||||
|
self.prediction_len = prediction_len
|
||||||
self.is_sim = False
|
self.is_sim = False
|
||||||
self.history_pad = np.zeros((self.history_len, 2))
|
self.history_pad = np.zeros((self.history_len, 2))
|
||||||
self.future_pad = np.zeros((self.future_len, 2))
|
self.future_pad = np.zeros((self.future_len, 2))
|
||||||
|
self.prediction_pad = np.zeros((self.prediction_len, 2))
|
||||||
self.__getitem__(0) # initialize self.is_sim
|
self.__getitem__(0) # initialize self.is_sim
|
||||||
|
|
||||||
def __len__(self):
|
def __len__(self):
|
||||||
@ -322,9 +339,10 @@ class EpisodicDataset(torch.utils.data.Dataset):
|
|||||||
commanded_speed = root['/base_action'][()]
|
commanded_speed = root['/base_action'][()]
|
||||||
observed_speed = root['/obs_tracer'][()]
|
observed_speed = root['/obs_tracer'][()]
|
||||||
observed_speed = np.concatenate([self.history_pad, observed_speed, self.future_pad], axis=0)
|
observed_speed = np.concatenate([self.history_pad, observed_speed, self.future_pad], axis=0)
|
||||||
|
commanded_speed = np.concatenate([commanded_speed, self.prediction_pad], axis=0)
|
||||||
|
|
||||||
offset_start_ts = start_ts + self.history_len
|
offset_start_ts = start_ts + self.history_len
|
||||||
commanded_speed = commanded_speed[start_ts]
|
commanded_speed = commanded_speed[start_ts: start_ts+self.prediction_len]
|
||||||
observed_speed = observed_speed[offset_start_ts-self.history_len: offset_start_ts+self.future_len]
|
observed_speed = observed_speed[offset_start_ts-self.history_len: offset_start_ts+self.future_len]
|
||||||
|
|
||||||
commanded_speed = torch.from_numpy(commanded_speed).float()
|
commanded_speed = torch.from_numpy(commanded_speed).float()
|
||||||
|
|||||||
在新工单中引用
屏蔽一个用户