class YOLOv3Test(object): def __init__(self, configer): self.configer = configer self.blob_helper = BlobHelper(configer) self.det_visualizer = DetVisualizer(configer) self.det_parser = DetParser(configer) self.det_model_manager = ModelManager(configer) self.det_data_loader = DataLoader(configer) self.yolo_target_generator = YOLOTargetGenerator(configer) self.yolo_detection_layer = YOLODetectionLayer(configer) self.device = torch.device( 'cpu' if self.configer.get('gpu') is None else 'cuda') self.det_net = None self._init_model() def _init_model(self): self.det_net = self.det_model_manager.object_detector() self.det_net = RunnerHelper.load_net(self, self.det_net) self.det_net.eval() def __test_img(self, image_path, json_path, raw_path, vis_path): Log.info('Image Path: {}'.format(image_path)) img = ImageHelper.read_image( image_path, tool=self.configer.get('data', 'image_tool'), mode=self.configer.get('data', 'input_mode')) ori_img_bgr = ImageHelper.get_cv2_bgr(img, mode=self.configer.get( 'data', 'input_mode')) inputs = self.blob_helper.make_input(img, input_size=self.configer.get( 'data', 'input_size'), scale=1.0) with torch.no_grad(): inputs = inputs.unsqueeze(0).to(self.device) _, _, detections = self.det_net(inputs) batch_detections = self.decode(detections, self.configer) json_dict = self.__get_info_tree(batch_detections[0], ori_img_bgr) image_canvas = self.det_parser.draw_bboxes( ori_img_bgr.copy(), json_dict, conf_threshold=self.configer.get('res', 'vis_conf_thre')) ImageHelper.save(ori_img_bgr, raw_path) ImageHelper.save(image_canvas, vis_path) Log.info('Json Path: {}'.format(json_path)) JsonHelper.save_file(json_dict, json_path) return json_dict @staticmethod def decode(batch_pred_bboxes, configer, input_size): box_corner = batch_pred_bboxes.new(batch_pred_bboxes.shape) box_corner[:, :, 0] = batch_pred_bboxes[:, :, 0] - batch_pred_bboxes[:, :, 2] / 2 box_corner[:, :, 1] = batch_pred_bboxes[:, :, 1] - batch_pred_bboxes[:, :, 3] / 2 box_corner[:, :, 2] = batch_pred_bboxes[:, :, 0] + batch_pred_bboxes[:, :, 2] / 2 box_corner[:, :, 3] = batch_pred_bboxes[:, :, 1] + batch_pred_bboxes[:, :, 3] / 2 # clip bounding box box_corner[:, :, 0::2] = box_corner[:, :, 0::2].clamp(min=0, max=1.0) box_corner[:, :, 1::2] = box_corner[:, :, 1::2].clamp(min=0, max=1.0) batch_pred_bboxes[:, :, :4] = box_corner[:, :, :4] batch_pred_bboxes[:, :, 0::2] *= input_size[0] batch_pred_bboxes[:, :, 1::2] *= input_size[1] output = [None for _ in range(len(batch_pred_bboxes))] for image_i, image_pred in enumerate(batch_pred_bboxes): # Filter out confidence scores below threshold conf_mask = (image_pred[:, 4] > configer.get( 'res', 'val_conf_thre')).squeeze() image_pred = image_pred[conf_mask] # If none are remaining => process next image if image_pred.numel() == 0: continue # Get score and class with highest confidence class_conf, class_pred = torch.max( image_pred[:, 5:5 + configer.get('data', 'num_classes')], 1, keepdim=True) # Detections ordered as (x1, y1, x2, y2, obj_conf, class_conf, class_pred) detections = torch.cat( (image_pred[:, :5], class_conf.float(), class_pred.float()), 1) output[image_i] = DetHelper.cls_nms(detections, labels=class_pred.squeeze(1), max_threshold=configer.get( 'nms', 'max_threshold')) return output def __get_info_tree(self, detections, image_raw, input_size): height, width, _ = image_raw.shape json_dict = dict() object_list = list() if detections is not None: for x1, y1, x2, y2, conf, cls_conf, cls_pred in detections: object_dict = dict() xmin = x1.cpu().item() / input_size[0] * width ymin = y1.cpu().item() / input_size[1] * height xmax = x2.cpu().item() / input_size[0] * width ymax = y2.cpu().item() / input_size[1] * height object_dict['bbox'] = [xmin, ymin, xmax, ymax] object_dict['label'] = int(cls_pred.cpu().item()) object_dict['score'] = float('%.2f' % conf.cpu().item()) object_list.append(object_dict) json_dict['objects'] = object_list return json_dict def debug(self, vis_dir): count = 0 for i, data_dict in enumerate(self.det_data_loader.get_trainloader()): inputs = data_dict['img'] batch_gt_bboxes = data_dict['bboxes'] batch_gt_labels = data_dict['labels'] input_size = [inputs.size(3), inputs.size(2)] feat_list = list() for stride in self.configer.get('network', 'stride_list'): feat_list.append( torch.zeros((inputs.size(0), 1, input_size[1] // stride, input_size[0] // stride))) targets, _, _ = self.yolo_target_generator(feat_list, batch_gt_bboxes, batch_gt_labels, input_size) targets = targets.to(self.device) anchors_list = self.configer.get('gt', 'anchors_list') output_list = list() be_c = 0 for f_index, anchors in enumerate(anchors_list): feat_stride = self.configer.get('network', 'stride_list')[f_index] fm_size = [ int(round(border / feat_stride)) for border in input_size ] num_c = len(anchors) * fm_size[0] * fm_size[1] output_list.append( targets[:, be_c:be_c + num_c].contiguous().view( targets.size(0), len(anchors), fm_size[1], fm_size[0], -1).permute(0, 1, 4, 2, 3).contiguous().view( targets.size(0), -1, fm_size[1], fm_size[0])) be_c += num_c batch_detections = self.decode( self.yolo_detection_layer(output_list)[2], self.configer, input_size) for j in range(inputs.size(0)): count = count + 1 if count > 20: exit(1) ori_img_bgr = self.blob_helper.tensor2bgr(inputs[j]) json_dict = self.__get_info_tree(batch_detections[j], ori_img_bgr, input_size) image_canvas = self.det_parser.draw_bboxes( ori_img_bgr.copy(), json_dict, conf_threshold=self.configer.get('vis', 'obj_threshold')) cv2.imwrite( os.path.join(vis_dir, '{}_{}_vis.png'.format(i, j)), image_canvas) cv2.imshow('main', image_canvas) cv2.waitKey()
class SingleShotDetector(object): """ The class for Single Shot Detector. Include train, val, test & predict. """ def __init__(self, configer): self.configer = configer self.batch_time = AverageMeter() self.data_time = AverageMeter() self.train_losses = AverageMeter() self.val_losses = AverageMeter() self.det_visualizer = DetVisualizer(configer) self.det_model_manager = ModelManager(configer) self.det_data_loader = DataLoader(configer) self.det_running_score = DetRunningScore(configer) self.det_net = None self.train_loader = None self.val_loader = None self.optimizer = None self.scheduler = None self.runner_state = dict() self._init_model() def _init_model(self): # torch.multiprocessing.set_sharing_strategy('file_system') self.det_net = self.det_model_manager.object_detector() self.det_net = RunnerHelper.load_net(self, self.det_net) self.optimizer, self.scheduler = Trainer.init( self._get_parameters(), self.configer.get('solver')) self.train_loader = self.det_data_loader.get_trainloader() self.val_loader = self.det_data_loader.get_valloader() self.det_loss = self.det_model_manager.get_det_loss() def _get_parameters(self): lr_1 = [] lr_10 = [] params_dict = dict(self.det_net.named_parameters()) for key, value in params_dict.items(): if 'backbone' not in key: lr_10.append(value) else: lr_1.append(value) params = [{ 'params': lr_1, 'lr': self.configer.get('solver', 'lr')['base_lr'] }, { 'params': lr_10, 'lr': self.configer.get('solver', 'lr')['base_lr'] * 1.0 }] return params def train(self): """ Train function of every epoch during train phase. """ self.det_net.train() start_time = time.time() # Adjust the learning rate after every epoch. self.runner_state['epoch'] += 1 # data_tuple: (inputs, heatmap, maskmap, vecmap) for i, data_dict in enumerate(self.train_loader): Trainer.update(self, warm_list=(0, ), warm_lr_list=(self.configer.get('solver', 'lr')['base_lr'], ), solver_dict=self.configer.get('solver')) self.data_time.update(time.time() - start_time) # Forward pass. data_dict = RunnerHelper.to_device(self, data_dict) out = self.det_net(data_dict) loss_dict = self.det_loss(out) loss = loss_dict['loss'] self.train_losses.update(loss.item(), len(DCHelper.tolist(data_dict['meta']))) self.optimizer.zero_grad() loss.backward() RunnerHelper.clip_grad(self.det_net, 10.) self.optimizer.step() # Update the vars of the train phase. self.batch_time.update(time.time() - start_time) start_time = time.time() self.runner_state['iters'] += 1 # Print the log info & reset the states. if self.runner_state['iters'] % self.configer.get( 'solver', 'display_iter') == 0: Log.info( 'Train Epoch: {0}\tTrain Iteration: {1}\t' 'Time {batch_time.sum:.3f}s / {2}iters, ({batch_time.avg:.3f})\t' 'Data load {data_time.sum:.3f}s / {2}iters, ({data_time.avg:3f})\n' 'Learning rate = {3}\tLoss = {loss.val:.8f} (ave = {loss.avg:.8f})\n' .format(self.runner_state['epoch'], self.runner_state['iters'], self.configer.get('solver', 'display_iter'), RunnerHelper.get_lr(self.optimizer), batch_time=self.batch_time, data_time=self.data_time, loss=self.train_losses)) self.batch_time.reset() self.data_time.reset() self.train_losses.reset() if self.configer.get('solver', 'lr')['metric'] == 'iters' \ and self.runner_state['iters'] == self.configer.get('solver', 'max_iters'): break # Check to val the current model. if self.runner_state['iters'] % self.configer.get( 'solver', 'test_interval') == 0: self.val() def val(self): """ Validation function during the train phase. """ self.det_net.eval() start_time = time.time() with torch.no_grad(): for j, data_dict in enumerate(self.val_loader): # Forward pass. data_dict = RunnerHelper.to_device(self, data_dict) out = self.det_net(data_dict) loss_dict = self.det_loss(out) loss = loss_dict['loss'] out_dict, _ = RunnerHelper.gather(self, out) # Compute the loss of the val batch. self.val_losses.update(loss.item(), len(DCHelper.tolist(data_dict['meta']))) batch_detections = SingleShotDetectorTest.decode( out_dict['loc'], out_dict['conf'], self.configer, DCHelper.tolist(data_dict['meta'])) batch_pred_bboxes = self.__get_object_list(batch_detections) # batch_pred_bboxes = self._get_gt_object_list(batch_gt_bboxes, batch_gt_labels) self.det_running_score.update(batch_pred_bboxes, [ item['ori_bboxes'] for item in DCHelper.tolist(data_dict['meta']) ], [ item['ori_labels'] for item in DCHelper.tolist(data_dict['meta']) ]) # Update the vars of the val phase. self.batch_time.update(time.time() - start_time) start_time = time.time() RunnerHelper.save_net(self, self.det_net, iters=self.runner_state['iters']) # Print the log info & reset the states. Log.info( 'Test Time {batch_time.sum:.3f}s, ({batch_time.avg:.3f})\t' 'Loss {loss.avg:.8f}\n'.format(batch_time=self.batch_time, loss=self.val_losses)) Log.info('Val mAP: {}'.format(self.det_running_score.get_mAP())) self.det_running_score.reset() self.batch_time.reset() self.val_losses.reset() self.det_net.train() def __get_object_list(self, batch_detections): batch_pred_bboxes = list() for idx, detections in enumerate(batch_detections): object_list = list() if detections is not None: for x1, y1, x2, y2, conf, cls_pred in detections: cf = float('%.2f' % conf.item()) cls_pred = int(cls_pred.cpu().item() - 1) object_list.append([ x1.item(), y1.item(), x2.item(), y2.item(), cls_pred, cf ]) batch_pred_bboxes.append(object_list) return batch_pred_bboxes
class YOLOv3(object): """ The class for YOLO v3. Include train, val, test & predict. """ def __init__(self, configer): self.configer = configer self.batch_time = AverageMeter() self.data_time = AverageMeter() self.train_losses = AverageMeter() self.val_losses = AverageMeter() self.det_visualizer = DetVisualizer(configer) self.det_model_manager = ModelManager(configer) self.det_data_loader = DataLoader(configer) self.yolo_detection_layer = YOLODetectionLayer(configer) self.yolo_target_generator = YOLOTargetGenerator(configer) self.det_running_score = DetRunningScore(configer) self.det_net = None self.train_loader = None self.val_loader = None self.optimizer = None self.scheduler = None self.runner_state = dict() self._init_model() def _init_model(self): self.det_net = self.det_model_manager.object_detector() self.det_net = RunnerHelper.load_net(self, self.det_net) self.optimizer, self.scheduler = Trainer.init( self._get_parameters(), self.configer.get('solver')) self.train_loader = self.det_data_loader.get_trainloader() self.val_loader = self.det_data_loader.get_valloader() self.det_loss = self.det_model_manager.get_det_loss() def _get_parameters(self): lr_1 = [] lr_10 = [] params_dict = dict(self.det_net.named_parameters()) for key, value in params_dict.items(): if 'backbone' not in key: lr_10.append(value) else: lr_1.append(value) params = [{ 'params': lr_1, 'lr': self.configer.get('solver', 'lr')['base_lr'] }, { 'params': lr_10, 'lr': self.configer.get('solver', 'lr')['base_lr'] * 10. }] return params def train(self): """ Train function of every epoch during train phase. """ self.det_net.train() start_time = time.time() # Adjust the learning rate after every epoch. self.runner_state['epoch'] += 1 # data_tuple: (inputs, heatmap, maskmap, vecmap) for i, data_dict in enumerate(self.train_loader): Trainer.update(self, backbone_list=(0, ), solver_dict=self.configer.get('solver')) inputs = data_dict['img'] batch_gt_bboxes = data_dict['bboxes'] batch_gt_labels = data_dict['labels'] input_size = [inputs.size(3), inputs.size(2)] self.data_time.update(time.time() - start_time) # Change the data type. inputs = RunnerHelper.to_device(self, inputs) # Forward pass. feat_list, predictions, _ = self.det_net(inputs) targets, objmask, noobjmask = self.yolo_target_generator( feat_list, batch_gt_bboxes, batch_gt_labels, input_size) targets, objmask, noobjmask = RunnerHelper.to_device( self, targets, objmask, noobjmask) # Compute the loss of the train batch & backward. loss = self.det_loss(predictions, targets, objmask, noobjmask) self.train_losses.update(loss.item(), inputs.size(0)) self.optimizer.zero_grad() loss.backward() self.optimizer.step() # Update the vars of the train phase. self.batch_time.update(time.time() - start_time) start_time = time.time() self.runner_state['iters'] += 1 # Print the log info & reset the states. if self.runner_state['iters'] % self.configer.get( 'solver', 'display_iter') == 0: Log.info( 'Train Epoch: {0}\tTrain Iteration: {1}\t' 'Time {batch_time.sum:.3f}s / {2}iters, ({batch_time.avg:.3f})\t' 'Data load {data_time.sum:.3f}s / {2}iters, ({data_time.avg:3f})\n' 'Learning rate = {3}\tLoss = {loss.val:.8f} (ave = {loss.avg:.8f})\n' .format(self.runner_state['epoch'], self.runner_state['iters'], self.configer.get('solver', 'display_iter'), RunnerHelper.get_lr(self.optimizer), batch_time=self.batch_time, data_time=self.data_time, loss=self.train_losses)) self.batch_time.reset() self.data_time.reset() self.train_losses.reset() if self.configer.get('solver', 'lr')['metric'] == 'iters' \ and self.runner_state['iters'] == self.configer.get('solver', 'max_iters'): break # Check to val the current model. if self.runner_state['iters'] % self.configer.get( 'solver', 'test_interval') == 0: self.val() def val(self): """ Validation function during the train phase. """ self.det_net.eval() start_time = time.time() with torch.no_grad(): for i, data_dict in enumerate(self.val_loader): inputs = data_dict['img'] batch_gt_bboxes = data_dict['bboxes'] batch_gt_labels = data_dict['labels'] input_size = [inputs.size(3), inputs.size(2)] # Forward pass. inputs = RunnerHelper.to_device(self, inputs) feat_list, predictions, detections = self.det_net(inputs) targets, objmask, noobjmask = self.yolo_target_generator( feat_list, batch_gt_bboxes, batch_gt_labels, input_size) targets, objmask, noobjmask = RunnerHelper.to_device( self, targets, objmask, noobjmask) # Compute the loss of the val batch. loss = self.det_loss(predictions, targets, objmask, noobjmask) self.val_losses.update(loss.item(), inputs.size(0)) batch_detections = YOLOv3Test.decode(detections, self.configer, input_size) batch_pred_bboxes = self.__get_object_list( batch_detections, input_size) self.det_running_score.update(batch_pred_bboxes, batch_gt_bboxes, batch_gt_labels) # Update the vars of the val phase. self.batch_time.update(time.time() - start_time) start_time = time.time() RunnerHelper.save_net(self, self.det_net, iters=self.runner_state['iters']) # Print the log info & reset the states. Log.info( 'Test Time {batch_time.sum:.3f}s, ({batch_time.avg:.3f})\t' 'Loss {loss.avg:.8f}\n'.format(batch_time=self.batch_time, loss=self.val_losses)) Log.info('Val mAP: {}'.format(self.det_running_score.get_mAP())) self.det_running_score.reset() self.batch_time.reset() self.val_losses.reset() self.det_net.train() def __get_object_list(self, batch_detections, input_size): batch_pred_bboxes = list() for idx, detections in enumerate(batch_detections): object_list = list() if detections is not None: for x1, y1, x2, y2, conf, cls_conf, cls_pred in detections: xmin = x1.cpu().item() ymin = y1.cpu().item() xmax = x2.cpu().item() ymax = y2.cpu().item() cf = conf.cpu().item() cls_pred = cls_pred.cpu().item() object_list.append([ xmin, ymin, xmax, ymax, int(cls_pred), float('%.2f' % cf) ]) batch_pred_bboxes.append(object_list) return batch_pred_bboxes
class FasterRCNN(object): """ The class for Single Shot Detector. Include train, val, test & predict. """ def __init__(self, configer): self.configer = configer self.batch_time = AverageMeter() self.data_time = AverageMeter() self.train_losses = AverageMeter() self.val_losses = AverageMeter() self.det_visualizer = DetVisualizer(configer) self.det_loss_manager = LossManager(configer) self.det_model_manager = DetModelManager(configer) self.det_data_loader = DataLoader(configer) self.fr_priorbox_layer = FRPriorBoxLayer(configer) self.det_running_score = DetRunningScore(configer) self.det_net = None self.train_loader = None self.val_loader = None self.optimizer = None self.scheduler = None self.runner_state = dict() self._init_model() def _init_model(self): self.det_net = self.det_model_manager.object_detector() self.det_net = RunnerHelper.load_net(self, self.det_net) self.optimizer, self.scheduler = Trainer.init(self, self._get_parameters()) self.train_loader = self.det_data_loader.get_trainloader() self.val_loader = self.det_data_loader.get_valloader() def _get_parameters(self): lr_1 = [] lr_2 = [] params_dict = dict(self.det_net.named_parameters()) for key, value in params_dict.items(): if value.requires_grad: if 'bias' in key: lr_2.append(value) else: lr_1.append(value) params = [{'params': lr_1, 'lr': self.configer.get('lr', 'base_lr')}, {'params': lr_2, 'lr': self.configer.get('lr', 'base_lr') * 2., 'weight_decay': 0}] return params def train(self): """ Train function of every epoch during train phase. """ self.det_net.train() start_time = time.time() # Adjust the learning rate after every epoch. self.runner_state['epoch'] += 1 for i, data_dict in enumerate(self.train_loader): Trainer.update(self) self.data_time.update(time.time() - start_time) # Forward pass. loss = self.det_net(data_dict) loss = loss.mean() self.train_losses.update(loss.item(), len(DCHelper.tolist(data_dict['meta']))) self.optimizer.zero_grad() loss.backward() RunnerHelper.clip_grad(self.det_net, 10.) self.optimizer.step() # Update the vars of the train phase. self.batch_time.update(time.time() - start_time) start_time = time.time() self.runner_state['iters'] += 1 # Print the log info & reset the states. if self.runner_state['iters'] % self.configer.get('solver', 'display_iter') == 0: Log.info('Train Epoch: {0}\tTrain Iteration: {1}\t' 'Time {batch_time.sum:.3f}s / {2}iters, ({batch_time.avg:.3f})\t' 'Data load {data_time.sum:.3f}s / {2}iters, ({data_time.avg:3f})\n' 'Learning rate = {3}\tLoss = {loss.val:.8f} (ave = {loss.avg:.8f})\n'.format( self.runner_state['epoch'], self.runner_state['iters'], self.configer.get('solver', 'display_iter'), RunnerHelper.get_lr(self.optimizer), batch_time=self.batch_time, data_time=self.data_time, loss=self.train_losses)) self.batch_time.reset() self.data_time.reset() self.train_losses.reset() if self.configer.get('lr', 'metric') == 'iters' \ and self.runner_state['iters'] == self.configer.get('solver', 'max_iters'): break # Check to val the current model. if self.runner_state['iters'] % self.configer.get('solver', 'test_interval') == 0: self.val() def val(self): """ Validation function during the train phase. """ self.det_net.eval() start_time = time.time() with torch.no_grad(): for j, data_dict in enumerate(self.val_loader): batch_gt_bboxes = DCHelper.tolist(data_dict['bboxes']) batch_gt_labels = DCHelper.tolist(data_dict['labels']) metas = DCHelper.tolist(data_dict['meta']) # Forward pass. loss, test_group = self.det_net(data_dict) # Compute the loss of the train batch & backward. loss = loss.mean() self.val_losses.update(loss.item(), len(metas)) test_indices_and_rois, test_roi_locs, test_roi_scores, test_rois_num = test_group batch_detections = FastRCNNTest.decode(test_roi_locs, test_roi_scores, test_indices_and_rois, test_rois_num, self.configer, metas) batch_pred_bboxes = self.__get_object_list(batch_detections) self.det_running_score.update(batch_pred_bboxes, batch_gt_bboxes, batch_gt_labels) # Update the vars of the val phase. self.batch_time.update(time.time() - start_time) start_time = time.time() RunnerHelper.save_net(self, self.det_net, iters=self.runner_state['iters']) # Print the log info & reset the states. Log.info( 'Test Time {batch_time.sum:.3f}s, ({batch_time.avg:.3f})\t' 'Loss {loss.avg:.8f}\n'.format( batch_time=self.batch_time, loss=self.val_losses)) Log.info('Val mAP: {}\n'.format(self.det_running_score.get_mAP())) self.det_running_score.reset() self.batch_time.reset() self.val_losses.reset() self.det_net.train() def __get_object_list(self, batch_detections): batch_pred_bboxes = list() for idx, detections in enumerate(batch_detections): object_list = list() if detections is not None: for x1, y1, x2, y2, conf, cls_pred in detections: xmin = x1.cpu().item() ymin = y1.cpu().item() xmax = x2.cpu().item() ymax = y2.cpu().item() cf = conf.cpu().item() cls_pred = int(cls_pred.cpu().item()) - 1 object_list.append([xmin, ymin, xmax, ymax, cls_pred, float('%.2f' % cf)]) batch_pred_bboxes.append(object_list) return batch_pred_bboxes