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
