def __call__(self):
# the 30th layer of features is relu of conv5_3
model = vgg16(pretrained=False)
if self.configer.get('network', 'pretrained') is not None:
Log.info('Loading pretrained model: {}'.format(
self.configer.get('network', 'pretrained')))
model.load_state_dict(
torch.load(self.configer.get('network', 'pretrained')))
features = list(model.features)[:30]
classifier = model.classifier
classifier = list(classifier)
del classifier[6]
if not self.configer.get('network', 'use_drop'):
del classifier[5]
del classifier[2]
classifier = nn.Sequential(*classifier)
# freeze top4 conv
for layer in features[:10]:
for p in layer.parameters():
p.requires_grad = False
return nn.Sequential(*features), classifier
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.
out_dict = self.det_net(data_dict)
# Compute the loss of the train batch & backward.
loss = out_dict['loss'].mean()
self.train_losses.update(loss.item(),
len(DCHelper.tolist(data_dict['meta'])))
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 test(self, test_dir, out_dir):
for _, data_dict in enumerate(
self.test_loader.get_testloader(test_dir=test_dir)):
data_dict['testing'] = True
data_dict = RunnerHelper.to_device(self, data_dict)
out_dict = self.det_net(data_dict)
meta_list = DCHelper.tolist(data_dict['meta'])
test_indices_and_rois, test_roi_locs, test_roi_scores, test_rois_num = out_dict[
'test_group']
batch_detections = self.decode(test_roi_locs, test_roi_scores,
test_indices_and_rois,
test_rois_num, self.configer,
meta_list)
for i in range(len(meta_list)):
ori_img_bgr = ImageHelper.read_image(meta_list[i]['img_path'],
tool='cv2',
mode='BGR')
json_dict = self.__get_info_tree(batch_detections[i])
image_canvas = self.det_parser.draw_bboxes(
ori_img_bgr.copy(),
json_dict,
conf_threshold=self.configer.get('res', 'vis_conf_thre'))
ImageHelper.save(image_canvas,
save_path=os.path.join(
out_dir, 'vis/{}.png'.format(
meta_list[i]['filename'])))
Log.info('Json Path: {}'.format(
os.path.join(
out_dir,
'json/{}.json'.format(meta_list[i]['filename']))))
JsonHelper.save_file(json_dict,
save_path=os.path.join(
out_dir, 'json/{}.json'.format(
meta_list[i]['filename'])))
def train(runner):
Log.info('Training start...')
if runner.configer.get('network',
'resume') is not None and runner.configer.get(
'network', 'resume_val'):
runner.val()
if runner.configer.get('solver', 'lr')['metric'] == 'epoch':
while runner.runner_state['epoch'] < runner.configer.get(
'solver', 'max_epoch'):
if runner.configer.get('network.distributed'):
runner.train_loader.sampler.set_epoch(
runner.runner_state['epoch'])
runner.train()
if runner.runner_state['epoch'] == runner.configer.get(
'solver', 'max_epoch'):
runner.val()
break
else:
while runner.runner_state['iters'] < runner.configer.get(
'solver', 'max_iters'):
if runner.configer.get('network.distributed'):
runner.train_loader.sampler.set_epoch(
runner.runner_state['epoch'])
runner.train()
if runner.runner_state['iters'] == runner.configer.get(
'solver', 'max_iters'):
runner.val()
break
Log.info('Training end...')
def _make_parallel(runner, net):
if runner.configer.get('network.distributed', default=False):
#print('n1')
from apex.parallel import DistributedDataParallel
#print('n2')
if runner.configer.get('network.syncbn', default=False):
Log.info('Converting syncbn model...')
from apex.parallel import convert_syncbn_model
net = convert_syncbn_model(net)
torch.cuda.set_device(runner.configer.get('local_rank'))
torch.distributed.init_process_group(backend='nccl',
init_method='env://')
net = DistributedDataParallel(net.cuda(), delay_allreduce=True)
return net
net = net.to(
torch.device(
'cpu' if runner.configer.get('gpu') is None else 'cuda'))
if len(runner.configer.get('gpu')) > 1:
from exts.tools.parallel.data_parallel import ParallelModel
return ParallelModel(net,
gather_=runner.configer.get(
'network', 'gather'))
return net
def __test_img(self, image_path, save_path):
Log.info('Image Path: {}'.format(image_path))
ori_image = ImageHelper.read_image(image_path,
tool=self.configer.get('data', 'image_tool'),
mode=self.configer.get('data', 'input_mode'))
ori_width, ori_height = ImageHelper.get_size(ori_image)
ori_img_bgr = ImageHelper.get_cv2_bgr(ori_image, mode=self.configer.get('data', 'input_mode'))
heatmap_avg = np.zeros((ori_height, ori_width, self.configer.get('network', 'heatmap_out')))
for i, scale in enumerate(self.configer.get('test', 'scale_search')):
image = self.blob_helper.make_input(ori_image,
input_size=self.configer.get('test', 'input_size'),
scale=scale)
with torch.no_grad():
heatmap_out_list = self.pose_net(image)
heatmap_out = heatmap_out_list[-1]
# extract outputs, resize, and remove padding
heatmap = heatmap_out.squeeze(0).cpu().numpy().transpose(1, 2, 0)
heatmap = cv2.resize(heatmap, (ori_width, ori_height), interpolation=cv2.INTER_CUBIC)
heatmap_avg = heatmap_avg + heatmap / len(self.configer.get('test', 'scale_search'))
all_peaks = self.__extract_heatmap_info(heatmap_avg)
image_canvas = self.__draw_key_point(all_peaks, ori_img_bgr)
ImageHelper.save(image_canvas, save_path)
def val(self):
"""
Validation function during the train phase.
"""
self.pose_net.eval()
start_time = time.time()
with torch.no_grad():
for i, data_dict in enumerate(self.val_loader):
# Forward pass.
out_dict = self.pose_net(data_dict)
# Compute the loss of the val batch.
loss_dict = self.mse_loss(out_dict, data_dict, gathered=self.configer.get('network', 'gathered'))
self.val_losses.update(loss_dict['loss'].mean().item(), len(DCHelper.tolist(data_dict['meta'])))
# Update the vars of the val phase.
self.batch_time.update(time.time() - start_time)
start_time = time.time()
self.runner_state['val_loss'] = self.val_losses.avg
RunnerHelper.save_net(self, self.pose_net, val_loss=self.val_losses.avg)
# 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))
self.batch_time.reset()
self.val_losses.reset()
self.val_loss_heatmap.reset()
self.val_loss_associate.reset()
self.pose_net.train()
def load_net(runner, net, model_path=None, map_location='cpu'):
if model_path is not None or runner.configer.get('network', 'resume') is not None:
resume_path = runner.configer.get('network', 'resume')
resume_path = model_path if model_path is not None else resume_path
Log.info('Resuming from {}'.format(resume_path))
resume_dict = torch.load(resume_path, map_location=map_location)
if 'state_dict' in resume_dict:
checkpoint_dict = resume_dict['state_dict']
elif 'model' in resume_dict:
checkpoint_dict = resume_dict['model']
elif isinstance(resume_dict, OrderedDict):
checkpoint_dict = resume_dict
else:
raise RuntimeError(
'No state_dict found in checkpoint file {}'.format(runner.configer.get('network', 'resume')))
# load state_dict
if hasattr(net, 'module'):
RunnerHelper.load_state_dict(net.module, checkpoint_dict,
runner.configer.get('network', 'resume_strict'))
else:
RunnerHelper.load_state_dict(net, checkpoint_dict, runner.configer.get('network', 'resume_strict'))
if runner.configer.get('network', 'resume_continue'):
# runner.configer.resume(resume_dict['config_dict'])
runner.runner_state = resume_dict['runner_state']
net = RunnerHelper._make_parallel(runner, net)
return net
def val(self):
"""
Validation function during the train phase.
"""
self.gan_net.eval()
start_time = time.time()
for j, data_dict in enumerate(self.val_loader):
with torch.no_grad():
# Forward pass.
out_dict = self.gan_net(data_dict)
# Compute the loss of the val batch.
self.val_losses.update(
out_dict['loss_G'].mean().item() +
out_dict['loss_D'].mean().item(),
len(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.gan_net, val_loss=self.val_losses.avg)
# 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))
self.batch_time.reset()
self.val_losses.reset()
self.gan_net.train()
def load_model(model, pretrained=None, all_match=True, map_location='cpu'):
if pretrained is None:
return model
if not os.path.exists(pretrained):
Log.warn('{} not exists.'.format(pretrained))
return model
Log.info('Loading pretrained model:{}'.format(pretrained))
if all_match:
pretrained_dict = torch.load(pretrained, map_location=map_location)
model_dict = model.state_dict()
load_dict = dict()
for k, v in pretrained_dict.items():
if 'prefix.{}'.format(k) in model_dict:
load_dict['prefix.{}'.format(k)] = v
else:
load_dict[k] = v
model.load_state_dict(load_dict)
else:
pretrained_dict = torch.load(pretrained)
model_dict = model.state_dict()
load_dict = {
k: v
for k, v in pretrained_dict.items() if k in model_dict
}
Log.info('Matched Keys: {}'.format(load_dict.keys()))
model_dict.update(load_dict)
model.load_state_dict(model_dict)
return model
def val(self):
"""
Validation function during the train phase.
"""
self.cls_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.cls_net(data_dict)
loss_dict = self.loss(out)
out_dict, label_dict, _ = RunnerHelper.gather(self, out)
self.running_score.update(out_dict, label_dict)
self.val_losses.update({key: loss.item() for key, loss in loss_dict.items()}, data_dict['img'].size(0))
# Update the vars of the val phase.
self.batch_time.update(time.time() - start_time)
start_time = time.time()
RunnerHelper.save_net(self, self.cls_net)
# Print the log info & reset the states.
Log.info('Test Time {batch_time.sum:.3f}s'.format(batch_time=self.batch_time))
Log.info('TestLoss = {}'.format(self.val_losses.info()))
Log.info('Top1 ACC = {}'.format(RunnerHelper.dist_avg(self, self.running_score.get_top1_acc())))
Log.info('Top3 ACC = {}'.format(RunnerHelper.dist_avg(self, self.running_score.get_top3_acc())))
Log.info('Top5 ACC = {}'.format(RunnerHelper.dist_avg(self, self.running_score.get_top5_acc())))
self.batch_time.reset()
self.batch_time.reset()
self.val_losses.reset()
self.running_score.reset()
self.cls_net.train()
def val(self):
"""
Validation function during the train phase.
"""
self.pose_net.eval()
start_time = time.time()
with torch.no_grad():
for i, data_dict in enumerate(self.val_loader):
# Forward pass.
out = self.pose_net(data_dict)
# Compute the loss of the val batch.
loss_dict = self.pose_loss(out)
self.val_losses.update({key: loss.item() for key, loss in loss_dict.items()}, data_dict['img'].size(0))
# Update the vars of the val phase.
self.batch_time.update(time.time() - start_time)
start_time = time.time()
self.runner_state['val_loss'] = self.val_losses.avg['loss']
RunnerHelper.save_net(self, self.pose_net, val_loss=self.val_losses.avg['loss'])
# Print the log info & reset the states.
Log.info(
'Test Time {batch_time.sum:.3f}s, ({batch_time.avg:.3f})\t'
'Loss {0}\n'.format(self.val_losses.info(), batch_time=self.batch_time))
self.batch_time.reset()
self.val_losses.reset()
self.pose_net.train()
def _make_parallel(runner, net):
if runner.configer.get('network.distributed', default=False):
local_rank = runner.configer.get('local_rank')
torch.cuda.set_device(local_rank)
torch.distributed.init_process_group(backend='nccl',
init_method='env://')
if runner.configer.get('network.syncbn', default=False):
Log.info('Converting syncbn model...')
net = nn.SyncBatchNorm.convert_sync_batchnorm(net)
net = nn.parallel.DistributedDataParallel(
net.cuda(),
find_unused_parameters=True,
device_ids=[local_rank],
output_device=local_rank)
# if runner.configer.get('network.syncbn', default=False):
# Log.info('Converting syncbn model...')
# from apex.parallel import convert_syncbn_model
# net = convert_syncbn_model(net)
# from apex.parallel import DistributedDataParallel
# net = DistributedDataParallel(net.cuda(), delay_allreduce=True)
return net
net = net.to(
torch.device(
'cpu' if runner.configer.get('gpu') is None else 'cuda'))
from exts.tools.parallel.data_parallel import ParallelModel
return ParallelModel(net,
gather_=runner.configer.get('network', 'gather'))
def parse_dir_pose(self, image_dir, json_dir, mask_dir=None):
if image_dir is None or not os.path.exists(image_dir):
Log.error('Image Dir: {} not existed.'.format(image_dir))
return
if json_dir is None or not os.path.exists(json_dir):
Log.error('Json Dir: {} not existed.'.format(json_dir))
return
for image_file in os.listdir(image_dir):
shotname, extension = os.path.splitext(image_file)
Log.info(image_file)
image_canvas = cv2.imread(os.path.join(image_dir, image_file)) # B, G, R order.
with open(os.path.join(json_dir, '{}.json'.format(shotname)), 'r') as json_stream:
info_tree = json.load(json_stream)
image_canvas = self.draw_points(image_canvas, info_tree)
if self.configer.exists('details', 'limb_seq'):
image_canvas = self.link_points(image_canvas, info_tree)
if mask_dir is not None:
mask_file = os.path.join(mask_dir, '{}_vis.png'.format(shotname))
mask_canvas = cv2.imread(mask_file)
image_canvas = cv2.addWeighted(image_canvas, 0.6, mask_canvas, 0.4, 0)
cv2.imshow('main', image_canvas)
cv2.waitKey()
def init_weights(net, init_type='normal', init_gain=0.02):
"""Initialize network weights.
Parameters:
net (network) -- network to be initialized
init_type (str) -- the name of an initialization method: normal | xavier | kaiming | orthogonal
init_gain (float) -- scaling factor for normal, xavier and orthogonal.
We use 'normal' in the original pix2pix and CycleGAN paper. But xavier and kaiming might
work better for some applications. Feel free to try yourself.
"""
def init_func(m): # define the initialization function
classname = m.__class__.__name__
if hasattr(m, 'weight') and (classname.find('Conv') != -1
or classname.find('Linear') != -1):
if init_type == 'normal':
init.normal_(m.weight.data, 0.0, init_gain)
elif init_type == 'xavier':
init.xavier_normal_(m.weight.data, gain=init_gain)
elif init_type == 'kaiming':
init.kaiming_normal_(m.weight.data, a=0, mode='fan_in')
elif init_type == 'orthogonal':
init.orthogonal_(m.weight.data, gain=init_gain)
else:
raise NotImplementedError(
'initialization method [%s] is not implemented' %
init_type)
if hasattr(m, 'bias') and m.bias is not None:
init.constant_(m.bias.data, 0.0)
elif classname.find(
'BatchNorm2d'
) != -1: # BatchNorm Layer's weight is not a matrix; only normal distribution applies.
init.normal_(m.weight.data, 1.0, init_gain)
init.constant_(m.bias.data, 0.0)
Log.info('initialize network with {}'.format(init_type))
net.apply(init_func) # apply the initialization function <init_func>
def save_file(json_dict, save_path):
dir_name = os.path.dirname(save_path)
if not os.path.exists(dir_name):
Log.info('Json Dir: {} not exists.'.format(dir_name))
os.makedirs(dir_name)
with open(save_path, 'w') as write_stream:
write_stream.write(json.dumps(json_dict))
def train(self):
"""
Train function of every epoch during train phase.
"""
self.cls_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, warm_list=(0, 1),
warm_lr_list=(self.solver_dict['lr']['base_lr']*self.configer.get('solver.lr.bb_lr_scale'),
self.solver_dict['lr']['base_lr']),
solver_dict=self.solver_dict)
self.data_time.update(time.time() - start_time)
data_dict = RunnerHelper.to_device(self, data_dict)
# Forward pass.
out = self.cls_net(data_dict)
loss_dict = self.loss(out)
# Compute the loss of the train batch & backward.
loss = loss_dict['loss']
self.train_losses.update({key: loss.item() for key, loss in loss_dict.items()}, data_dict['img'].size(0))
self.optimizer.zero_grad()
loss.backward()
if self.configer.get('network', 'clip_grad', default=False):
RunnerHelper.clip_grad(self.cls_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.solver_dict['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 = {4}\tLoss = {3}\n'.format(
self.runner_state['epoch'], self.runner_state['iters'],
self.solver_dict['display_iter'], self.train_losses.info(),
RunnerHelper.get_lr(self.optimizer), batch_time=self.batch_time,
data_time=self.data_time))
self.batch_time.reset()
self.data_time.reset()
self.train_losses.reset()
if self.solver_dict['lr']['metric'] == 'iters' and self.runner_state['iters'] == self.solver_dict['max_iters']:
break
if self.runner_state['iters'] % self.solver_dict['save_iters'] == 0 and self.configer.get('local_rank') == 0:
RunnerHelper.save_net(self, self.cls_net)
# Check to val the current model.
if self.runner_state['iters'] % self.solver_dict['test_interval'] == 0:
self.val()
def xml2json(xml_file, json_file):
if not os.path.exists(xml_file):
Log.error('Xml file: {} not exists.'.format(xml_file))
exit(1)
json_dir_name = os.path.dirname(json_file)
if not os.path.exists(json_dir_name):
Log.info('Json Dir: {} not exists.'.format(json_dir_name))
os.makedirs(json_dir_name)
def json2xml(json_file, xml_file):
if not os.path.exists(json_file):
Log.error('Json file: {} not exists.'.format(json_file))
exit(1)
xml_dir_name = os.path.dirname(xml_file)
if not os.path.exists(xml_dir_name):
Log.info('Xml Dir: {} not exists.'.format(xml_dir_name))
os.makedirs(xml_dir_name)
def test(self, test_dir, out_dir):
for _, data_dict in enumerate(
self.test_loader.get_testloader(test_dir=test_dir)):
total_logits = None
if self.configer.get('test', 'mode') == 'ss_test':
total_logits = self.ss_test(data_dict)
elif self.configer.get('test', 'mode') == 'sscrop_test':
total_logits = self.sscrop_test(data_dict,
params_dict=self.configer.get(
'test', 'sscrop_test'))
elif self.configer.get('test', 'mode') == 'ms_test':
total_logits = self.ms_test(data_dict,
params_dict=self.configer.get(
'test', 'ms_test'))
elif self.configer.get('test', 'mode') == 'mscrop_test':
total_logits = self.mscrop_test(data_dict,
params_dict=self.configer.get(
'test', 'mscrop_test'))
else:
Log.error('Invalid test mode:{}'.format(
self.configer.get('test', 'mode')))
exit(1)
meta_list = DCHelper.tolist(data_dict['meta'])
for i in range(len(meta_list)):
label_map = np.argmax(total_logits[i], axis=-1)
label_img = np.array(label_map, dtype=np.uint8)
ori_img_bgr = ImageHelper.read_image(meta_list[i]['img_path'],
tool='cv2',
mode='BGR')
image_canvas = self.seg_parser.colorize(
label_img, image_canvas=ori_img_bgr)
ImageHelper.save(image_canvas,
save_path=os.path.join(
out_dir, 'vis/{}.png'.format(
meta_list[i]['filename'])))
if self.configer.get('data.label_list',
default=None) is not None:
label_img = self.__relabel(label_img)
if self.configer.get('data.reduce_zero_label', default=False):
label_img = label_img + 1
label_img = label_img.astype(np.uint8)
label_img = Image.fromarray(label_img, 'P')
label_path = os.path.join(
out_dir, 'label/{}.png'.format(meta_list[i]['filename']))
Log.info('Label Path: {}'.format(label_path))
ImageHelper.save(label_img, label_path)
def debug(runner):
Log.info('Debugging start..')
base_dir = os.path.join(runner.configer.get('project_dir'), 'out/vis',
runner.configer.get('task'),
runner.configer.get('network', 'model_name'))
if not os.path.exists(base_dir):
os.makedirs(base_dir)
runner.debug(base_dir)
Log.info('Debugging end...')
def __read_json(self, root_dir, json_path):
item_list = []
for item in JsonHelper.load_file(json_path):
img_path = os.path.join(root_dir, item['image_path'])
if not os.path.exists(img_path) or not ImageHelper.is_img(img_path):
Log.error('Image Path: {} is Invalid.'.format(img_path))
exit(1)
item_list.append((img_path, '.'.join(item['image_path'].split('.')[:-1])))
Log.info('There are {} images..'.format(len(item_list)))
return item_list
def debug(self, vis_dir):
for i, data_dict in enumerate(self.pose_data_loader.get_trainloader()):
inputs = data_dict['img']
maskmap = data_dict['maskmap']
heatmap = data_dict['heatmap']
vecmap = data_dict['vecmap']
for j in range(inputs.size(0)):
count = count + 1
if count > 10:
exit(1)
Log.info(heatmap.size())
image_bgr = self.blob_helper.tensor2bgr(inputs[j])
mask_canvas = maskmap[j].repeat(3, 1,
1).numpy().transpose(1, 2, 0)
mask_canvas = (mask_canvas * 255).astype(np.uint8)
mask_canvas = cv2.resize(
mask_canvas, (0, 0),
fx=self.configer.get('network', 'stride'),
fy=self.configer.get('network', 'stride'),
interpolation=cv2.INTER_CUBIC)
image_bgr = cv2.addWeighted(image_bgr, 0.6, mask_canvas, 0.4,
0)
heatmap_avg = heatmap[j].numpy().transpose(1, 2, 0)
heatmap_avg = cv2.resize(
heatmap_avg, (0, 0),
fx=self.configer.get('network', 'stride'),
fy=self.configer.get('network', 'stride'),
interpolation=cv2.INTER_CUBIC)
paf_avg = vecmap[j].numpy().transpose(1, 2, 0)
paf_avg = cv2.resize(paf_avg, (0, 0),
fx=self.configer.get('network', 'stride'),
fy=self.configer.get('network', 'stride'),
interpolation=cv2.INTER_CUBIC)
self.pose_visualizer.vis_peaks(heatmap_avg, image_bgr)
self.pose_visualizer.vis_paf(paf_avg, image_bgr)
all_peaks = self.__extract_heatmap_info(heatmap_avg)
special_k, connection_all = self.__extract_paf_info(
image_bgr, paf_avg, all_peaks)
subset, candidate = self.__get_subsets(connection_all,
special_k, all_peaks)
json_dict = self.__get_info_tree(image_bgr, subset, candidate)
image_canvas = self.pose_parser.draw_points(
image_bgr, json_dict)
image_canvas = self.pose_parser.link_points(
image_canvas, json_dict)
cv2.imwrite(
os.path.join(vis_dir, '{}_{}_vis.png'.format(i, j)),
image_canvas)
cv2.imshow('main', image_canvas)
cv2.waitKey()
def load_url(url, map_location=None):
model_dir = os.path.join('~', '.TorchCV', 'model')
if not os.path.exists(model_dir):
os.makedirs(model_dir)
filename = url.split('/')[-1]
cached_file = os.path.join(model_dir, filename)
if not os.path.exists(cached_file):
Log.info('Downloading: "{}" to {}\n'.format(url, cached_file))
urlretrieve(url, cached_file)
Log.info('Loading pretrained model:{}'.format(cached_file))
return torch.load(cached_file, map_location=map_location)
def get_trainloader(self):
if self.configer.get('train.loader',
default=None) in [None, 'default']:
Log.info('Get train dataloader start')
dataset = DefaultLoader(root_dir=self.configer.get(
'data', 'data_dir'),
dataset='train',
aug_transform=self.aug_train_transform,
img_transform=self.img_transform,
label_transform=self.label_transform,
configer=self.configer)
sampler = None
Log.info('Get sampler')
if self.configer.get('network.distributed'):
sampler = torch.utils.data.distributed.DistributedSampler(
dataset)
Log.info('Get dataloader')
trainloader = data.DataLoader(
dataset,
sampler=sampler,
batch_size=self.configer.get('train', 'batch_size'),
shuffle=(sampler is None),
num_workers=self.configer.get('data', 'workers'),
pin_memory=False,
drop_last=self.configer.get('data', 'drop_last'),
collate_fn=lambda *args: collate(
*args,
trans_dict=self.configer.get('train', 'data_transformer')))
Log.info('Get train dataloader end')
return trainloader
else:
Log.error('{} train loader is invalid.'.format(
self.configer.get('train', 'loader')))
exit(1)
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)
# Compute the loss of the train batch & backward.
loss = loss_dict['loss'].mean()
out_dict, _ = RunnerHelper.gather(self, out)
self.val_losses.update(loss.item(),
len(DCHelper.tolist(data_dict['meta'])))
test_indices_and_rois, test_roi_locs, test_roi_scores, test_rois_num = out_dict[
'test_group']
batch_detections = FastRCNNTest.decode(
test_roi_locs, test_roi_scores, test_indices_and_rois,
test_rois_num, self.configer,
DCHelper.tolist(data_dict['meta']))
batch_pred_bboxes = self.__get_object_list(batch_detections)
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: {}\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 __test_img(self, image_path, json_path, raw_path, vis_path):
Log.info('Image Path: {}'.format(image_path))
ori_image = ImageHelper.read_image(image_path,
tool=self.configer.get('data', 'image_tool'),
mode=self.configer.get('data', 'input_mode'))
ori_width, ori_height = ImageHelper.get_size(ori_image)
ori_img_bgr = ImageHelper.get_cv2_bgr(ori_image, mode=self.configer.get('data', 'input_mode'))
heatmap_avg = np.zeros((ori_height, ori_width, self.configer.get('network', 'heatmap_out')))
paf_avg = np.zeros((ori_height, ori_width, self.configer.get('network', 'paf_out')))
multiplier = [scale * self.configer.get('test', 'input_size')[1] / ori_height
for scale in self.configer.get('test', 'scale_search')]
stride = self.configer.get('network', 'stride')
for i, scale in enumerate(multiplier):
image, border_hw = self._get_blob(ori_image, scale=scale)
with torch.no_grad():
paf_out_list, heatmap_out_list = self.pose_net(image)
paf_out = paf_out_list[-1]
heatmap_out = heatmap_out_list[-1]
# extract outputs, resize, and remove padding
heatmap = heatmap_out.squeeze(0).cpu().numpy().transpose(1, 2, 0)
heatmap = cv2.resize(heatmap, None, fx=stride, fy=stride, interpolation=cv2.INTER_CUBIC)
heatmap = cv2.resize(heatmap[:border_hw[0], :border_hw[1]],
(ori_width, ori_height), interpolation=cv2.INTER_CUBIC)
paf = paf_out.squeeze(0).cpu().numpy().transpose(1, 2, 0)
paf = cv2.resize(paf, None, fx=stride, fy=stride, interpolation=cv2.INTER_CUBIC)
paf = cv2.resize(paf[:border_hw[0], :border_hw[1]],
(ori_width, ori_height), interpolation=cv2.INTER_CUBIC)
heatmap_avg = heatmap_avg + heatmap / len(multiplier)
paf_avg = paf_avg + paf / len(multiplier)
all_peaks = self.__extract_heatmap_info(heatmap_avg)
special_k, connection_all = self.__extract_paf_info(ori_img_bgr, paf_avg, all_peaks)
subset, candidate = self.__get_subsets(connection_all, special_k, all_peaks)
json_dict = self.__get_info_tree(ori_img_bgr, subset, candidate)
image_canvas = self.pose_parser.draw_points(ori_img_bgr.copy(), json_dict)
image_canvas = self.pose_parser.link_points(image_canvas, json_dict)
ImageHelper.save(image_canvas, vis_path)
ImageHelper.save(ori_img_bgr, raw_path)
Log.info('Json Save Path: {}'.format(json_path))
JsonHelper.save_file(json_dict, json_path)
def relabel(self, json_dir, method='mask_rcnn'):
submission_file = os.path.join(
json_dir,
'person_instances_val2017_{}_results.json'.format(method))
img_id_list = list()
object_list = list()
for json_file in os.listdir(json_dir):
json_path = os.path.join(json_dir, json_file)
shotname, extensions = os.path.splitext(json_file)
try:
img_id = int(shotname)
except ValueError:
Log.info('Invalid Json file: {}'.format(json_file))
continue
img_id_list.append(img_id)
with open(json_path, 'r') as json_stream:
info_tree = json.load(json_stream)
for object in info_tree['objects']:
object_dict = dict()
object_dict['image_id'] = img_id
object_dict['category_id'] = int(
self.configer.get('data',
'coco_cat_seq')[object['label']])
object_dict['score'] = object['score']
object_dict['bbox'] = [
object['bbox'][0], object['bbox'][1],
object['bbox'][2] - object['bbox'][0],
object['bbox'][3] - object['bbox'][1]
]
if isinstance(object['segm'], dict):
object_dict['segmentation'] = object['segm']
else:
object_dict['segmentation'] = maskUtils.encode(
np.asfortranarray(
MaskHelper.polys2mask(object['segm'],
info_tree['height'],
info_tree['width'])))
object_list.append(object_dict)
with open(submission_file, 'w') as write_stream:
write_stream.write(json.dumps(object_list))
Log.info('Evaluate {} images...'.format(len(img_id_list)))
return submission_file, img_id_list
def relabel(self, json_dir):
submission_dir = os.path.join(json_dir, self.configer.get('method'))
if not os.path.exists(submission_dir):
assert os.path.exists(json_dir)
os.makedirs(submission_dir)
img_shotname_list = list()
object_list = list()
for json_file in os.listdir(json_dir):
if 'json' not in json_file:
continue
json_path = os.path.join(json_dir, json_file)
shotname, extensions = os.path.splitext(json_file)
img_shotname_list.append(shotname)
with open(json_path, 'r') as json_stream:
info_tree = json.load(json_stream)
for object in info_tree['objects']:
# 0-indexing
object_list.append([
shotname, object['label'], object['score'],
int(object['bbox'][0]) + 1,
int(object['bbox'][1]) + 1,
int(object['bbox'][2]) + 1,
int(object['bbox'][3]) + 1
])
file_header_list = list()
for i in range(len(self.configer.get('details', 'name_seq'))):
cls = self.configer.get('details', 'name_seq')[i]
Log.info('Writing {:s} VOC results file'.format(cls))
filename = self.get_voc_results_file_template(submission_dir, cls)
file_header = open(filename, 'wt')
file_header_list.append(file_header)
for object in object_list:
file_header_list[object[1]].write(
'{:s} {:.3f} {:.1f} {:.1f} {:.1f} {:.1f}\n'.format(
object[0], object[2], object[3], object[4], object[5],
object[6]))
for file_header in file_header_list:
file_header.close()
Log.info('Evaluate {} images...'.format(len(img_shotname_list)))
return submission_dir
def __init__(self,
root_dir,
dataset=None,
aug_transform=None,
img_transform=None,
label_transform=None,
configer=None):
self.configer = configer
if self.configer.get('use_zipreader'):
ImageHelper.use_zipreader = True
self.aug_transform = aug_transform
self.img_transform = img_transform
self.label_transform = label_transform
self.img_list, self.label_list = self.__list_dirs(root_dir, dataset)
Log.info("{}/{} img count {}".format(root_dir, dataset,
len(self.img_list)))
