def eval_one(net, loss_fn, config, loader, image_id, device, plot=False, verbose=False): input, label_map, image_id = loader.dataset[image_id] input = input.to(device) label_map, label_list = loader.dataset.get_label(image_id) loader.dataset.reg_target_transform(label_map) label_map = torch.from_numpy(label_map).permute(2, 0, 1).unsqueeze_(0).to(device) # Forward Pass t_start = time.time() pred = net(input.unsqueeze(0)) t_forward = time.time() - t_start loss, cls_loss, loc_loss = loss_fn(pred, label_map) pred.squeeze_(0) cls_pred = pred[0, ...] if verbose: print("Forward pass time", t_forward) # Filter Predictions t_start = time.time() corners, scores = filter_pred(config, pred) t_post = time.time() - t_start if verbose: print("Non max suppression time:", t_post) gt_boxes = np.array(label_list) gt_match, pred_match, overlaps = compute_matches(gt_boxes, corners, scores, iou_threshold=0.5) num_gt = len(label_list) num_pred = len(scores) input_np = input.cpu().permute(1, 2, 0).numpy() pred_image = get_bev(input_np, corners) if plot == True: # Visualization plot_bev(input_np, label_list, window_name='GT') plot_bev(input_np, corners, window_name='Prediction') plot_label_map(cls_pred.numpy()) return num_gt, num_pred, scores, pred_image, pred_match, loss.item( ), t_forward, t_post
def __call__(self, velo, path): t_start = time.time() bev = self.preprocess(velo, path) t_pre = time.time() with torch.no_grad(): pred = self.net(bev.unsqueeze(0)).squeeze_(0) t_m = time.time() corners, scores = filter_pred(self.config, pred) input_np = bev.permute(1, 2, 0).cpu().numpy() t_post = time.time() pred_bev = get_bev(input_np, corners) t_s = [t_pre - t_start, t_m - t_pre, t_post - t_m] return t_s, corners, scores, pred_bev
def eval_batch(config, net, loss_fn, loader, device, eval_range='all'): net.eval() if config['mGPUs']: net.module.set_decode(True) else: net.set_decode(True) cls_loss = 0 loc_loss = 0 all_scores = [] all_matches = [] log_images = [] gts = 0 preds = 0 t_fwd = 0 t_nms = 0 log_img_list = random.sample(range(len(loader.dataset)), 10) with torch.no_grad(): for i, data in enumerate(loader): tic = time.time() input, label_map, image_id = data input = input.to(device) label_map = label_map.to(device) tac = time.time() predictions = net(input) t_fwd += time.time() - tac loss, cls, loc = loss_fn(predictions, label_map) cls_loss += cls loc_loss += loc t_fwd += (time.time() - tic) toc = time.time() # Parallel post-processing predictions = list(torch.split(predictions.cpu(), 1, dim=0)) batch_size = len(predictions) with Pool(processes=1) as pool: preds_filtered = pool.starmap(filter_pred, [(config, pred) for pred in predictions]) t_nms += (time.time() - toc) args = [] for j in range(batch_size): _, label_list = loader.dataset.get_label(image_id[j].item()) corners, scores = preds_filtered[j] gts += len(label_list) preds += len(scores) all_scores.extend(list(scores)) if image_id[j] in log_img_list: input_np = input[j].cpu().permute(1, 2, 0).numpy() pred_image = get_bev(input_np, corners) log_images.append(pred_image) arg = (np.array(label_list), corners, scores) args.append(arg) # Parallel compute matchesi with Pool(processes=1) as pool: matches = pool.starmap(compute_matches, args) for j in range(batch_size): all_matches.extend(list(matches[j][1])) #print(time.time() -tic) all_scores = np.array(all_scores) all_matches = np.array(all_matches) sort_ids = np.argsort(all_scores) all_matches = all_matches[sort_ids[::-1]] metrics = {} AP, precisions, recalls, precision, recall = compute_ap( all_matches, gts, preds) metrics['AP'] = AP metrics['Precision'] = precision metrics['Recall'] = recall metrics['Forward Pass Time'] = t_fwd / len(loader.dataset) metrics['Postprocess Time'] = t_nms / len(loader.dataset) cls_loss = cls_loss / len(loader) loc_loss = loc_loss / len(loader) metrics['loss'] = cls_loss + loc_loss return metrics, precisions, recalls, log_images