def get_detection_ts(detection, target): detection = detection[0] true_index = detection['scores'] > 0. detection = detection['boxes'][true_index].cpu() if len(detection) == 0: return 0. pred_detection = [] for i in range(len(detection)): min_x = detection[i][0].item() min_y = detection[i][1].item() max_x = detection[i][2].item() max_y = detection[i][3].item() pred_box = torch.tensor([[max_x, max_x, min_x, min_x], [max_y, min_y, max_y, min_y]]) pred_detection.append(pred_box) pred_detection = torch.stack(pred_detection).unsqueeze(0) pred_detection[:, :, 0, :] = pred_detection[:, :, 0, :] * 2 pred_detection[:, :, 1, :] = pred_detection[:, :, 1, :] * 2 ats_bounding_boxes = compute_ats_bounding_boxes(pred_detection[0], target[0]['boxes']) return ats_bounding_boxes
def validate(self, predictions, inputs, conf_thresh=0.5): """compute average threat score""" ats = 0 batch_size = predictions.shape[0] for element in range(batch_size): target = inputs[element]['bounding_box'] predict = self.decode(predictions[element], conf_thresh=conf_thresh) ats += compute_ats_bounding_boxes(target.cpu(), predict.cpu()) return ats
num_workers=0) model_loader = ModelLoader() total = 0 total_ats_bounding_boxes = 0 total_ts_road_map = 0 with torch.no_grad(): for i, data in enumerate(dataloader_task1): total += 1 sample, target, road_image = data sample = sample.cuda() predicted_bounding_boxes = model_loader.get_bounding_boxes( sample)[0].cpu() ats_bounding_boxes, iou_max = compute_ats_bounding_boxes( predicted_bounding_boxes, target['bounding_box'][0]) total_ats_bounding_boxes += ats_bounding_boxes if opt.verbose: print(f'{i} - Bounding Box Score: {ats_bounding_boxes:.4}') for i, data in enumerate(dataloader_task2): sample, target, road_image = data sample = sample.cuda() predicted_road_map = model_loader.get_binary_road_map(sample).cpu() ts_road_map = compute_ts_road_map(predicted_road_map, road_image) total_ts_road_map += ts_road_map if opt.verbose: print(f'{i} - Road Map Score: {ts_road_map:.4}')
def batched_coor_threat(anchor_boxes, gt_offsets, target, gt_classes, batch_sz, nms_threshold=0.1, plot=False): # predicted offsets, target_offests, coor_in_meter batch_coor = [] batched_threat_sum = 0 for i in range(batch_sz): anchor_boxes = anchor_boxes[i] gt_offsets = gt_offsets[i] #target = target[1]['bounding_box'] if i == 0: target = torch.from_numpy(target[0]) # print(target) # print(type(target[i])) #target = torch.from_numpy(target[i]) gt_classes = gt_classes[i] #2,25600000,4 # print(anchor_boxes.shape) # print(gt_offsets.shape) #2,2560000 # print(gt_classes) inds = (gt_classes != 0) #print(inds.shape) anchor_boxes = anchor_boxes[inds] gt_offsets = gt_offsets[inds] gt_classes = gt_classes[inds] # target offset delta_x = gt_offsets[:, 0] delta_y = gt_offsets[:, 1] delta_scaleX = gt_offsets[:, 2] delta_scaleY = gt_offsets[:, 3] gt_widths = anchor_boxes[:, 2] - anchor_boxes[:, 0] gt_heights = anchor_boxes[:, 3] - anchor_boxes[:, 1] gt_center_x = anchor_boxes[:, 0] + 0.5 * gt_widths gt_center_y = anchor_boxes[:, 1] + 0.5 * gt_heights ex_width = gt_widths / torch.exp(delta_scaleX) ex_height = gt_heights / torch.exp(delta_scaleY) ex_center_x = gt_center_x - delta_x * ex_width ex_center_y = gt_center_y - delta_y * ex_height ex1 = ex_center_x - 0.5 * ex_width ex2 = ex_center_x + 0.5 * ex_width ey1 = ex_center_y - 0.5 * ex_height ey2 = ex_center_y + 0.5 * ex_height #print(ex1.shape) pred_boxes = torch.cat([ ex1.unsqueeze(0), ey1.unsqueeze(0), ex2.unsqueeze(0), ey2.unsqueeze(0) ], dim=0).permute(1, 0) pred_boxes = pred_boxes.type(torch.float32) gt_classes = gt_classes.type(torch.float32) target = target.type(torch.float32) #749543,4 #print(pred_boxes.shape) #749543 #print(gt_classes.shape) # print(pred_boxes) # print(min(gt_classes)) # print(gt_classes) # print(gt_classes.shape) inds = nms(pred_boxes, gt_classes, nms_threshold) pred_boxes = pred_boxes[inds] coordinate_list = [] for box in pred_boxes: x1, y1, x2, y2 = box[0], box[1], box[2], box[3] width = abs(x1 - x2) height = abs(y1 - y2) coordinate_list.append( torch.tensor([x2, x2, x1, x1, y2, y1, y2, y1]).view(-1, 4)) coordinate_list = torch.stack(coordinate_list) batched_threat_sum += compute_ats_bounding_boxes( coordinate_list, target) #print(coordinate_list.shape) batch_coor.append(coordinate_list) #print(len(batch_coor)) #final_coor = torch.stack(batch_coor) # if plot: # fig,ax = plt.subplots(1) # a = torch.zeros(800,800) # ax.imshow(a) # for box in pred_boxes: # x1, y1, x2, y2 = box[0], box[1], box[2], box[3] # rect = patches.Rectangle((x1,y1),abs(x1 - x2),abs(y1 - y2),linewidth=1,edgecolor='r',facecolor='none') # ax.add_patch(rect) # plt.show() return batch_coor, batched_threat_sum
def batched_coor_threat_updated(ite, predicted_offsets, anchor_boxes, target, gt_classes, batch_sz, nms_threshold=0.1, plot=False): # predicted offsets, target_offests, coor_in_meter batch_coor = [] batched_threat_sum = 0 original_anchor = anchor_boxes.clone() original_predicted_offsets = predicted_offsets.clone() original_gt_classes = gt_classes.clone() for i in range(batch_sz): anchor_boxes = original_anchor predicted_offsets = original_predicted_offsets[i] if i == 0: cur_target = torch.from_numpy(target[0]) else: cur_target = torch.from_numpy(target[1]) gt_classes = original_gt_classes[i] inds = (gt_classes != 0) anchor_boxes = anchor_boxes[inds] predicted_offsets = predicted_offsets[inds] gt_classes = gt_classes[inds] delta_x = predicted_offsets[:, 0] delta_y = predicted_offsets[:, 1] delta_scaleX = predicted_offsets[:, 2] delta_scaleY = predicted_offsets[:, 3] gt_widths = anchor_boxes[:, 2] - anchor_boxes[:, 0] gt_heights = anchor_boxes[:, 3] - anchor_boxes[:, 1] gt_center_x = anchor_boxes[:, 0] + 0.5 * gt_widths gt_center_y = anchor_boxes[:, 1] + 0.5 * gt_heights ex_width = gt_widths / torch.exp(delta_scaleX) ex_height = gt_heights / torch.exp(delta_scaleY) ex_center_x = gt_center_x - delta_x * ex_width ex_center_y = gt_center_y - delta_y * ex_height ex1 = ex_center_x - 0.5 * ex_width ex2 = ex_center_x + 0.5 * ex_width ey1 = ex_center_y - 0.5 * ex_height ey2 = ex_center_y + 0.5 * ex_height pred_boxes = torch.cat([ ex1.unsqueeze(0), ey1.unsqueeze(0), ex2.unsqueeze(0), ey2.unsqueeze(0) ], dim=0).permute(1, 0) pred_boxes = pred_boxes.type(torch.float32) gt_classes = gt_classes.type(torch.float32) cur_target = cur_target.type(torch.float32) inds = nms(pred_boxes, gt_classes, nms_threshold) pred_boxes = pred_boxes[inds] coordinate_list = [] # fig,ax = plt.subplots(1) # a = torch.zeros(800,800) # ax.imshow(a) # for box in pred_boxes: # x1, y1, x2, y2 = box[0], box[1], box[2], box[3] # rect = patches.Rectangle((x1,y1),abs(x1 - x2),abs(y1 - y2),linewidth=1,edgecolor='r',facecolor='none') # ax.add_patch(rect) # plt.savefig('/content/drive/My Drive/self_dl/predict_{}_{}.png'.format(ite, i)) for box in pred_boxes: x1, y1, x2, y2 = box[0], box[1], box[2], box[3] x1 = (x1 - 400) / 10 x2 = (x2 - 400) / 10 y1 = (y1 - 400) / -10 y2 = (y2 - 400) / -10 width = abs(x1 - x2) height = abs(y1 - y2) coordinate_list.append( torch.tensor([x2, x2, x1, x1, y2, y1, y2, y1]).view(-1, 4)) coordinate_list = torch.stack(coordinate_list) batched_threat_sum += compute_ats_bounding_boxes( coordinate_list, cur_target) batch_coor.append(coordinate_list) #visActual(cur_target, ite,i) return batch_coor, batched_threat_sum
def evaluate(self, debug=False): """ Evaluation model on task. --------------------- Returns: Average validation loss """ # puts model in evaluation mode self.model.eval() avg_road_ts = 0 avg_box_ats = 0 pred_boxes = [] pred_roads = [] road_ts = [] box_ats = [] # stop gradient tracking with torch.no_grad(): for i, batch in enumerate( tqdm(self.val_dataloader, desc="Validation", mininterval=30)): inputs = self.pack_input(batch) # {"images": batch[0], # "box_targets": batch[1], # "road_targets": batch[2]} out = self.model(**inputs) # out[0] First element as loss # out[1] Second element as predicted bounding boxes( for evaluation.o.w.empty list) # out[2] Third element as road map # out[3] road_loss # out[4] box_loss(for train.o.w. 0) pred_boxes = out[1] pred_roads = out[2] for road_map1, road_map2 in zip(pred_roads, inputs['road_targets']): road_ts.append( helper.compute_ts_road_map(road_map1, road_map2).item()) for boxes1, boxes2 in zip(pred_boxes, inputs['box_targets']): box_ats.append( helper.compute_ats_bounding_boxes( boxes1, boxes2['bounding_box']).item()) if i == 0 and debug: log.info('Debug') break if debug: log.info(f"Predicted roads is {pred_roads}") log.info(f"True roads is {inputs['road_targets']}") log.info(f"Road ts array is {road_ts}") log.info(f"Predicted roads is {pred_boxes}") log.info(f"True roads is {inputs['box_targets']}") log.info(f"Box ats array is {box_ats}") if len(road_ts) > 0: avg_road_ts = mean(road_ts) if len(box_ats) > 0: avg_box_ats = mean(box_ats) return avg_road_ts, avg_box_ats
val_losses = [] threat_score = [] for i, (sample, target, road_img) in enumerate(valloader): sample = torch.stack(sample).to(device) with torch.no_grad(): pred_map, loss = model(sample.to(device), process_target(target).to(device)) predicted_bounding_boxes = model.get_bounding_boxes( sample.to(device)) val_losses.append(loss.item()) for j in range(batch_size): score = compute_ats_bounding_boxes( predicted_bounding_boxes[0][j].to(device), target[j]['bounding_box'].to(device)) threat_score.append(score.item()) if i % 50 == 0: print( 'Val Epoch: {} [{}/{} ({:.0f}%)]\tAverage Loss So Far: {:.6f}' .format(ep, i * len(sample), len(valloader.dataset), 5. * i / len(valloader), np.mean(val_losses))) print("Average Validation Epoch Loss: ", np.mean(val_losses)) print("Average Threat Score: {} ".format(np.mean(threat_score))) if np.mean(val_losses) < best_val_loss: best_val_loss = np.mean(val_losses) torch.save(model.state_dict(), 'test.pt')
def batched_coor_threat_updated_retina(ite, encoder, predicted_offsets, target, gt_classes, batch_sz, nms_threshold=0.1, plot=False): # predicted offsets, target_offests, coor_in_meter h = 256 w = 206 batch_coor = [] batched_threat_sum = 0 original_predicted_offsets = predicted_offsets.clone() original_gt_classes = gt_classes.clone() for i in range(batch_sz): predicted_offsets = original_predicted_offsets[i] if i == 0: cur_target = torch.from_numpy(target[0]) else: cur_target = torch.from_numpy(target[1]) gt_classes = original_gt_classes[i] # not filtered boxes, labels = encoder.decode(predicted_offsets.data.squeeze(), gt_classes.data.squeeze(), (w, h)) # filtered #ex1, ex2, ey1, ey2 ex1 = boxes[:, 0] ex2 = boxes[:, 1] ey1 = boxes[:, 2] ey2 = boxes[:, 3] pred_boxes = torch.cat([ ex1.unsqueeze(0), ey1.unsqueeze(0), ex2.unsqueeze(0), ey2.unsqueeze(0) ], dim=0).permute(1, 0) pred_boxes = pred_boxes.type(torch.float32) gt_classes = gt_classes.type(torch.float32) cur_target = cur_target.type(torch.float32) coordinate_list = [] for box in pred_boxes: x1, y1, x2, y2 = box[0], box[1], box[2], box[3] x1 = (x1 - 400) / 10 x2 = (x2 - 400) / 10 y1 = (y1 - 400) / -10 y2 = (y2 - 400) / -10 width = abs(x1 - x2) height = abs(y1 - y2) coordinate_list.append( torch.tensor([x2, x2, x1, x1, y2, y1, y2, y1]).view(-1, 4)) coordinate_list = torch.stack(coordinate_list) batched_threat_sum += compute_ats_bounding_boxes( coordinate_list, cur_target) batch_coor.append(coordinate_list) return batch_coor, batched_threat_sum