def converter_csv_to_argo(input_path: str, output_path: str):
afl = ArgoverseForecastingLoader(input_path)
output_all = {}
counter = 1
for data in afl:
print('\r' + str(counter) + '/' + str(len(afl)), end="")
seq_id = int(data.current_seq.name[:-4])
output_all[seq_id] = np.expand_dims(data.agent_traj[20:, :], 0)
counter += 1
generate_forecasting_h5(output_all, output_path) # this might take awhile
def run(self, global_step, global_epoch, example, results, write=False):
"""
Helper function to generate the result h5 file for argoverse forecasting challenge
Args:
data: a dictionary of trajectory, with the key being the sequence ID. For each sequence, the
trajectory should be stored in a (9,30,2) np.ndarray
output_path: path to the output directory to store the output h5 file
filename: to be used as the name of the file
probabilities (optional) : normalized probability for each trajectory
Returns:
"""
batch_features = example
preds = np.concatenate(
[x[0:1].detach().cpu().numpy() for x in results["reg"]], axis=0)
cls = np.concatenate(
[x[0:1].detach().cpu().numpy() for x in results["cls"]], axis=0)
for i, file_id in enumerate(batch_features['file_id']):
seq_id = int(file_id.stem)
pred_trajs = preds[i]
agent_cls = cls[i]
_, idx = np.unique(pred_trajs, axis=0, return_index=True)
pred_trajs = pred_trajs[np.sort(idx)][:6]
agent_cls = agent_cls[np.sort(idx)][:6]
self._traj_all[seq_id] = pred_trajs
self._cls_all[seq_id] = agent_cls
if write: # each process write a pickle
output_pkl_path = Path(
self._output_dir) / f'res_{self.args.local_rank}.pkl'
with output_pkl_path.open('wb') as f:
pickle.dump({'traj': self._traj_all, 'cls': self._cls_all}, f)
dist.barrier(
) # make sure that ever process has finished file writing
if self.args.main_process:
trajs = {}
cls = {}
for i in range(self.args.world_size):
source_pkl_path = Path(self._output_dir) / f'res_{i}.pkl'
with source_pkl_path.open('rb') as f2:
res = pickle.load(f2)
trajs.update(res['traj'])
cls.update(res['cls'])
generate_forecasting_h5(trajs,
self._output_dir,
filename='res_mgpu',
probabilities=cls)
print(f'------dump finish, num of samples:{len(cls)}--------')
if cfg.add_mlp_agent > 0:
agents = data["normal_agents_history"].to(device)
agents_availabilty = data["agents_availabilty"].to(device)
entery = [[
*model_args, history, agents, agents_availabilty, {}, True
], history]
else:
entery = [[*model_args, history, None, None, {}, True], history]
output, conf = model(entery)
output = output.reshape(
(data["history_positions"].shape[0], 1, 30, 2)).cpu()
for i in range(output.shape[0]):
saved = []
for j in range(output.shape[1]):
rot_output = transform_points(
output[i][j], yaw_as_rotation33(ego_yaw[i])) + centroids[i]
saved.append(rot_output)
forecasted_trajectories[seq_id[i]] = saved
print("here")
output_path = "/work/vita/ayromlou/argo_code/new_multi_modal_code_sadegh/results1"
if os.path.exists(output_path):
os.rmdir(output_path)
os.mkdir(output_path)
generate_forecasting_h5(forecasted_trajectories,
output_path) #this might take awhile
for i in range(out.size(0)):
seq_id = int(norm_centers_ls[seq_index][0])
norm_center = norm_centers_ls[seq_index][1]
pred_y = out[i].view((-1, 2)).cumsum(axis=0).cpu().numpy()
pred_y += norm_center.reshape(-1, 2)
pred_y = np.array([pred_y])
assert (pred_y.shape == (1, 30, 2))
# y = gt[i].view((-1, 2)).cumsum(axis=0).cpu().numpy()
forecasted_trajectories[seq_id] = pred_y
seq_index += 1
from argoverse.evaluation.competition_util import generate_forecasting_h5
generate_forecasting_h5(forecasted_trajectories,
output_path,
filename=FILENAME)
#%%
#this might take awhile
# metric_results = get_displacement_errors_and_miss_rate(
# forecasted_trajectories, gt_trajectories, max_n_guesses, horizon, miss_threshold
# )
# return metric_results
# overfit the small dataset
# model.train()
# for epoch in range(epochs):
# print(f"start training at epoch:{epoch}")
# acc_loss = .0
# num_samples = 1
def save_trajectory(self,output_dict,save_path):
generate_forecasting_h5(output_dict, save_path)
print("done")
def main():
# Import all settings for experiment.
args = parser.parse_args()
model = import_module(args.model)
config, _, collate_fn, net, loss, post_process, opt = model.get_model()
# load pretrain model
ckpt_path = args.weight
if not os.path.isabs(ckpt_path):
ckpt_path = os.path.join(config["save_dir"], ckpt_path)
ckpt = torch.load(ckpt_path, map_location=lambda storage, loc: storage)
load_pretrain(net, ckpt["state_dict"])
net.eval()
# Data loader for evaluation
dataset = ArgoTestDataset(args.split, config, train=False)
data_loader = DataLoader(
dataset,
batch_size=config["val_batch_size"],
num_workers=config["val_workers"],
collate_fn=collate_fn,
shuffle=True,
pin_memory=True,
)
# begin inference
preds = {}
gts = {}
cities = {}
for ii, data in tqdm(enumerate(data_loader)):
data = dict(data)
with torch.no_grad():
output = net(data)
results = [x[0:1].detach().cpu().numpy() for x in output["reg"]]
for i, (argo_idx, pred_traj) in enumerate(zip(data["argo_id"],
results)):
preds[argo_idx] = pred_traj.squeeze()
cities[argo_idx] = data["city"][i]
gts[argo_idx] = data["gt_preds"][i][
0] if "gt_preds" in data else None
# save for further visualization
res = dict(
preds=preds,
gts=gts,
cities=cities,
)
# torch.save(res,f"{config['save_dir']}/results.pkl")
# evaluate or submit
if args.split == "val":
# for val set: compute metric
from argoverse.evaluation.eval_forecasting import (
compute_forecasting_metrics, )
# Max #guesses (K): 6
_ = compute_forecasting_metrics(preds, gts, cities, 6, 30, 20)
# Max #guesses (K): 1
_ = compute_forecasting_metrics(preds, gts, cities, 1, 30, 20)
else:
# for test set: save as h5 for submission in evaluation server
from argoverse.evaluation.competition_util import generate_forecasting_h5
generate_forecasting_h5(
preds, f"{config['save_dir']}/submit.h5") # this might take awhile
import ipdb
ipdb.set_trace()