def run_visualize():
from lib.networks import make_network
from lib.datasets import make_data_loader
from lib.utils.net_utils import load_network
import tqdm
import torch
from lib.visualizers import make_visualizer
network = make_network(cfg).cuda()
load_network(network,
cfg.model_dir,
resume=cfg.resume,
epoch=cfg.test.epoch)
network.eval()
data_loader = make_data_loader(cfg, is_train=False)
visualizer = make_visualizer(cfg)
if args.vis_out:
os.mkdir(args.vis_out)
idx = 0
#start = timeit.default_timer()
for batch in tqdm.tqdm(data_loader):
idx += 1
for k in batch:
if k != 'meta':
batch[k] = batch[k].cuda()
with torch.no_grad():
output = network(batch['inp'], batch)
if args.vis_out:
visualizer.visualize(
output, batch,
os.path.join(args.vis_out, "{:04d}_.png".format(idx)))
else:
visualizer.visualize(output, batch)
def run_demo():
from lib.datasets import make_data_loader
from lib.visualizers import make_visualizer
import tqdm
import torch
from lib.networks import make_network
from lib.utils.net_utils import load_network
import glob
from PIL import Image
torch.manual_seed(0)
meta = np.load(os.path.join(cfg.demo_path, 'meta.npy'),
allow_pickle=True).item()
demo_images = glob.glob(cfg.demo_path + '/*jpg')
network = make_network(cfg).cuda()
load_network(network, cfg.model_dir, epoch=cfg.test.epoch)
network.eval()
visualizer = make_visualizer(cfg)
mean, std = np.array([0.485, 0.456,
0.406]), np.array([0.229, 0.224, 0.225])
for demo_image in demo_images:
demo_image = np.array(Image.open(demo_image)).astype(np.float32)
inp = (((demo_image / 255.) - mean) / std).transpose(2, 0, 1).astype(
np.float32)
inp = torch.Tensor(inp[None]).cuda()
with torch.no_grad():
output = network(inp)
visualizer.visualize_demo(output, inp, meta)
def run_visualize():
from lib.networks import make_network
from lib.datasets import make_data_loader
from lib.utils.net_utils import load_network
import tqdm
import torch
from lib.visualizers import make_visualizer
network = make_network(cfg).cuda()
load_network(network, cfg.model_dir, resume=cfg.resume, epoch=cfg.test.epoch)
network.eval()
data_loader = make_data_loader(cfg, is_train=False)
visualizer = make_visualizer(cfg)
num = -1
for batch in tqdm.tqdm(data_loader):
num = num + 1
name = '%06d.jpg' % num
#high_resolution = '/mnt/SSD/jzwang/code/clean-pvnet/demo28/' + name
#high_resolution = Image.open(high_resolution)
for k in batch:
if k != 'meta':
batch[k] = batch[k].cuda()
with torch.no_grad():
output = network(batch['inp'], batch)
#visualizer.visualize(output, batch, name, high_resolution)
visualizer.visualize(output, batch, name)
def run_visualize():
from lib.networks import make_network
from lib.datasets import make_data_loader
from lib.utils.net_utils import load_network
import tqdm
import torch
from lib.visualizers import make_visualizer
if DEBUG:
print(
'===================================Visualizing================================='
)
import pprint
print('args:', args)
print('cfg:')
pprint.pprint(cfg)
network = make_network(cfg).cuda()
load_network(network,
cfg.model_dir,
resume=cfg.resume,
epoch=cfg.test.epoch)
network.eval()
data_loader = make_data_loader(cfg, is_train=False)
visualizer = make_visualizer(cfg)
for batch in tqdm.tqdm(data_loader):
for k in batch:
if k != 'meta':
batch[k] = batch[k].cuda()
with torch.no_grad():
output = network(batch['inp'], batch)
visualizer.visualize(output, batch)
def run_visualize():
from lib.networks import make_network
from lib.datasets import make_data_loader
from lib.utils.net_utils import load_network
from lib.utils import net_utils
import tqdm
import torch
from lib.visualizers import make_visualizer
from lib.networks.renderer import make_renderer
cfg.perturb = 0
network = make_network(cfg).cuda()
load_network(network,
cfg.trained_model_dir,
resume=cfg.resume,
epoch=cfg.test.epoch)
network.train()
data_loader = make_data_loader(cfg, is_train=False)
renderer = make_renderer(cfg, network)
visualizer = make_visualizer(cfg)
for batch in tqdm.tqdm(data_loader):
for k in batch:
if k != 'meta':
batch[k] = batch[k].cuda()
with torch.no_grad():
output = renderer.render(batch)
visualizer.visualize(output, batch)
def run_evaluate():
from lib.datasets import make_data_loader
from lib.evaluators import make_evaluator
import tqdm
import torch
from lib.networks import make_network
from lib.utils.net_utils import load_network
if DEBUG:
print(
'-------------------------------Evaluating---------------------------------'
)
network = make_network(cfg).cuda()
load_network(network, cfg.model_dir, epoch=cfg.test.epoch)
network.eval()
data_loader = make_data_loader(cfg, is_train=False)
evaluator = make_evaluator(cfg)
for batch in tqdm.tqdm(data_loader):
inp = batch['inp'].cuda()
with torch.no_grad():
output = network(inp)
evaluator.evaluate(output, batch)
evaluator.summarize()
def run_network():
from lib.networks import make_network
from lib.datasets import make_data_loader
from lib.utils.net_utils import load_network
import tqdm
import torch
import time
network = make_network(cfg).cuda()
load_network(network, cfg.model_dir, epoch=cfg.test.epoch)
network.eval()
data_loader = make_data_loader(cfg, is_train=False)
total_time = 0
for batch in tqdm.tqdm(data_loader):
for k in batch:
if k != 'meta':
batch[k] = batch[k].cuda()
with torch.no_grad():
torch.cuda.synchronize()
start = time.time()
network(batch['inp'])
torch.cuda.synchronize()
total_time += time.time() - start
print(total_time / len(data_loader))
def run_evaluate():
from lib.datasets import make_data_loader
from lib.evaluators import make_evaluator
import tqdm
import torch
from lib.networks import make_network
from lib.utils.net_utils import load_network
from lib.train import make_trainer
network = make_network(cfg).cuda()
load_network(network, cfg.model_dir, epoch=cfg.test.epoch)
trainer = make_trainer(cfg, network)
network.eval()
data_loader = make_data_loader(cfg, is_train=False)
if 'Coco' in cfg.train.dataset:
trainer.val_coco(data_loader)
else:
evaluator = make_evaluator(cfg)
for batch in tqdm.tqdm(data_loader):
inp = batch['inp'].cuda()
with torch.no_grad():
output = network(inp)
evaluator.evaluate(output, batch)
evaluator.summarize()
def run_visualize():
from lib.networks import make_network
from lib.datasets import make_data_loader
from lib.utils.net_utils import load_network
import tqdm
import torch
from lib.visualizers import make_visualizer
network = make_network(cfg).cuda()
load_network(network, cfg.model_dir, resume=cfg.resume, epoch=cfg.test.epoch)
network.eval()
data_loader = make_data_loader(cfg, is_train=False)
visualizer = make_visualizer(cfg)
index = 0
for batch in tqdm.tqdm(data_loader):
for k in batch:
if k != 'meta':
batch[k] = batch[k].cuda()
with torch.no_grad():
output = network(batch['inp'], batch)
# pdb.set_trace()
visualizer.visualize(output, batch, index)
index = index + 1
def __init__(self):
super(Network, self).__init__()
det_meta = cfg.det_meta
self.dla_ct = get_pose_net(det_meta.num_layers, det_meta.heads)
self.pvnet = get_res_pvnet(cfg.heads['vote_dim'], cfg.heads['seg_dim'])
net_utils.load_network(self.dla_ct, cfg.det_model)
net_utils.load_network(self.pvnet, cfg.kpt_model)
def run_visualize():
from lib.networks import make_network
from lib.datasets import make_data_loader
from lib.utils.net_utils import load_network
import tqdm
import torch
from lib.visualizers import make_visualizer
network = make_network(cfg).cuda()
print("model dir:{}".format(cfg.model_dir))
load_network(network,
cfg.model_dir,
resume=cfg.resume,
epoch=cfg.test.epoch)
network.eval()
data_loader = make_data_loader(cfg, is_train=False)
visualizer = make_visualizer(cfg)
ann_file = 'data/NICE1/NICE1/coco_int/test/annotations/NICE_test.json' # 这里是Test的json，因为这里使用的就是test的集合
coco = COCO(ann_file)
for batch in tqdm.tqdm(data_loader): #tqdm是个进度条
for k in batch:
if k != 'meta':
batch[k] = batch[k].cuda()
with torch.no_grad():
output = network(batch['inp'], batch)
# print("batch ->{}".format(batch)) #batch是对的，里面还有img_id等相关信息
# print("batch['meta'] ->{}".format(batch['meta'])) #batch['meta']是对的
img_info = batch['meta']
img_id = img_info['img_id'] #这个img_id用来根据id读取img名称从而确定输出图片名称的
img_scale = img_info['scale'] # 这个img_scale是用来读取尺寸从而改变图像尺寸的
# print("img id ->{}".format(img_id))
# print("img scale ->{}".format(img_scale))
img_name = coco.loadImgs(int(img_id))[0]['file_name']
img_name, _ = os.path.splitext(img_name)
# ann_ids = coco.getAnnIds(imgIds=img_id, iscrowd=0) #两种方法，一种获得anno，一种直接loadimg获得filename
# anno = coco.loadAnns(ann_ids)
visualizer.visualize(output, batch, img_name)
tmp_file = open(
'/home/tianhao.lu/code/Deep_snake/snake/Result/Contour/Output_check.log',
'w',
encoding='utf8')
tmp_file.writelines("Output -> ：" + str(output) + "\n")
tmp_file.writelines("batch -> ：" + str(batch) + "\n")
# for tmp_data in train_loader:
# tmp_file.writelines("one train_loader data type:" + str(type(tmp_data)) + "\n")
# for key in tmp_data:
# tmp_file.writelines("one train_loader data key:" + str(key) + "\n")
# tmp_file.writelines("one train_loader data len:" + str(len(tmp_data[key])) + "\n")
# # tmp_file.writelines("one train_loader data:" + str(tmp_data) + "\n")
# break
tmp_file.writelines(
str("*************************************************************** \n"
))
tmp_file.close()
def run_visualize():
from lib.networks import make_network
from lib.datasets import make_data_loader
from lib.utils.net_utils import load_network
from lib.utils import net_utils
import tqdm
import torch
from lib.visualizers import make_visualizer
from lib.networks.renderer import make_renderer
import os
cfg.perturb = 0
cfg.render_name = args.render_name
network = make_network(cfg)#.cuda()
load_network(network,
cfg.trained_model_dir,
resume=cfg.resume,
epoch=cfg.test.epoch)
network.train()
data_loader = make_data_loader(cfg, is_train=False)
n_devices = 2
expand_k = ['index', 'bounds', 'R', 'Th',
'center', 'rot', 'trans', 'i',
'cam_ind', 'feature', 'coord', 'out_sh']
renderer = torch.nn.DataParallel(make_renderer(cfg, network)).cuda()
#renderer.set_save_mem(True)
visualizer = make_visualizer(cfg)
for batch in tqdm.tqdm(data_loader):
batch_cuda = {}
for k in batch:
if k != 'meta':
# TODO: ugly hack...
if k not in expand_k:
sh = batch[k].shape
if sh[-1] == 3:
batch_cuda[k] = batch[k].view(-1, 3)
else:
batch_cuda[k] = batch[k].view(-1)
else:
sh = batch[k].shape
batch_cuda[k] = batch[k].expand(n_devices, *sh[1:])
batch_cuda[k] = batch_cuda[k].cuda()
else:
batch_cuda[k] = batch[k]
with torch.no_grad():
output = renderer(batch_cuda)
visualizer.visualize(output, batch)
def demo():
network = make_network(cfg).cuda()
load_network(network, cfg.model_dir, resume=cfg.resume, epoch=cfg.test.epoch)
network.eval()
dataset = Dataset()
visualizer = make_visualizer(cfg)
for batch in tqdm.tqdm(dataset):
batch['inp'] = torch.FloatTensor(batch['inp'])[None].cuda()
with torch.no_grad():
output = network(batch['inp'], batch)
# print('Output:{} /n Output.len:{}'.format(output, len(output))) #得到这个output是个tensor
visualizer.visualize(output, batch)
def __init__(self,
num_layers,
heads,
head_conv=256,
down_ratio=4,
det_dir=''):
super(Network, self).__init__()
self.dla = DLASeg('dla{}'.format(num_layers),
heads,
pretrained=True,
down_ratio=down_ratio,
final_kernel=1,
last_level=5,
head_conv=head_conv)
self.gcn = Evolution()
net_utils.load_network(self.dla, det_dir)
def test(cfg, network):
trainer = make_trainer(cfg, network)
val_loader = make_data_loader(cfg, is_train=False)
evaluator = make_evaluator(cfg)
epoch = load_network(network,
cfg.model_dir,
resume=cfg.resume,
epoch=cfg.test.epoch)
trainer.val(epoch, val_loader, evaluator)
def __init__(self,
num_layers,
heads,
head_conv=256,
down_ratio=4,
det_dir=''):
super(Network, self).__init__()
self.dla = DLASeg('dla{}'.format(num_layers),
heads,
pretrained=True,
down_ratio=down_ratio,
final_kernel=1,
last_level=5,
head_conv=head_conv)
self.cp = ComponentDetection()
self.gcn = Evolution()
det_dir = os.path.join(os.path.dirname(cfg.model_dir), cfg.det_model)
net_utils.load_network(self, det_dir, strict=False)
def run_evaluate():
from lib.datasets import make_data_loader
from lib.evaluators import make_evaluator
import tqdm
import torch
from lib.networks import make_network
from lib.utils.net_utils import load_network
import numpy as np
np.random.seed(1000)
torch.manual_seed(0)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
network = make_network(cfg).cuda()
load_network(network, cfg.model_dir, epoch=cfg.test.epoch)
network.eval()
data_loader = make_data_loader(cfg, is_train=False)
evaluator = make_evaluator(cfg)
count = 1200
i = 0
for batch in tqdm.tqdm(data_loader):
if i == count:
break
inp = batch['inp'].cuda()
# save input
# print(batch['img_id'])
# import pickle
# with open('/mbrdi/sqnap1_colomirror/gupansh/input_cat.pkl','wb') as fp:
# pickle.dump(batch['inp'], fp)
# input()
seg_gt = batch['mask'].cuda()
with torch.no_grad():
output = network(inp)
evaluator.evaluate(output, batch)
i += 1
evaluator.summarize()
def run_analyze():
from lib.networks import make_network
from lib.datasets import make_data_loader
from lib.utils.net_utils import load_network
import tqdm
import torch
from lib.analyzers import make_analyzer
network = make_network(cfg).cuda()
load_network(network, cfg.model_dir, epoch=cfg.test.epoch)
network.eval()
cfg.train.num_workers = 0
data_loader = make_data_loader(cfg, is_train=False)
analyzer = make_analyzer(cfg)
for batch in tqdm.tqdm(data_loader):
for k in batch:
if k != 'meta':
batch[k] = batch[k].cuda()
with torch.no_grad():
output = network(batch['inp'], batch)
analyzer.analyze(output, batch)
def run_evaluate():
from lib.datasets import make_data_loader
from lib.evaluators import make_evaluator
import tqdm
import torch
import pickle
import lzma
from lib.networks import make_network
from lib.utils.net_utils import load_network
from lib.evaluators.custom.monitor import MetricMonitor
from lib.visualizers import make_visualizer
torch.manual_seed(0)
monitor = MetricMonitor()
network = make_network(cfg).cuda()
epoch = load_network(network, cfg.model_dir, epoch=cfg.test.epoch)
network.eval()
print("Trainable parameters: {}".format(
sum(p.numel() for p in network.parameters())))
data_loader = make_data_loader(cfg, is_train=False)
evaluator = make_evaluator(cfg)
visualizer = make_visualizer(cfg)
idx = 0
if args.vis_out:
os.mkdir(args.vis_out)
for batch in tqdm.tqdm(data_loader):
idx += 1
inp = batch['inp'].cuda()
with torch.no_grad():
output = network(inp)
evaluator.evaluate(output, batch)
if args.vis_out:
err = evaluator.data["obj_drilltip_trans_3d"][-1]
visualizer.visualize(
output, batch,
os.path.join(
args.vis_out,
"tiperr{:.4f}_idx{:04d}.png".format(err.item(), idx)))
result = evaluator.summarize()
monitor.add('val', epoch, result)
monitor.save_metrics("metrics.pkl")
monitor.plot_histogram("evaluation.html", plotly=True)
def train(cfg, network):
trainer = make_trainer(cfg, network)
optimizer = make_optimizer(cfg, network)
scheduler = make_lr_scheduler(cfg, optimizer)
recorder = make_recorder(cfg)
#evaluator = make_evaluator(cfg)
if cfg.network_full_init:
begin_epoch = load_network(network,
cfg.model_dir,
resume=cfg.resume,
epoch=cfg.test.epoch)
begin_epoch = 0
else:
begin_epoch = load_model(network,
optimizer,
scheduler,
recorder,
cfg.model_dir,
resume=cfg.resume)
# set_lr_scheduler(cfg, scheduler)
if DEBUG:
print('------------------Loading training set-------------------')
train_loader = make_data_loader(cfg, is_train=True)
if DEBUG:
print('Loading training set done...')
print('---------------------------------------------------------')
#val_loader = make_data_loader(cfg, is_train=False)
for epoch in range(begin_epoch, cfg.train.epoch):
recorder.epoch = epoch
trainer.train(epoch, train_loader, optimizer, recorder)
scheduler.step()
if (epoch + 1) % cfg.save_ep == 0:
save_model(network, optimizer, scheduler, recorder, epoch,
cfg.model_dir)
#if (epoch + 1) % cfg.eval_ep == 0:
# trainer.val(epoch, val_loader, evaluator, recorder)
return network
def inference():
network = make_network(cfg).cuda()
load_network(network, cfg.model_dir, resume=cfg.resume, epoch=cfg.test.epoch)
network.eval()
with open(os.path.join(cfg.results_dir,'cfg.json'),'w') as fid:
json.dump(cfg,fid)
dataset = Dataset()
visualizer = make_visualizer(cfg)
infer_time_lst = []
for batch in tqdm.tqdm(dataset):
batch['inp'] = torch.FloatTensor(batch['inp'])[None].cuda()
net_time_s = time.time()
with torch.no_grad():
output = network(batch['inp'], batch)
net_used_time = time.time()-net_time_s
org_img = batch['org_img']
rz_img = batch['rz_img']
rz_ratio = batch['rz_ratio']
img_name = batch['image_name']
center = batch['meta']['center']
scale = batch['meta']['scale']
h, w = batch['inp'].size(2), batch['inp'].size(3)
if DEBUG:
print('------------------img_name={}-------------------------'.format(img_name))
print('org_img.shape:', org_img.shape)
print('rz_img.shape:', rz_img.shape)
print('input-size:({}, {})'.format(h,w))
if cfg.rescore_map_flag:
rs_thresh = 0.6
detections = output['detection'].detach().cpu().numpy()
polys = output['py'][-1].detach().cpu().numpy()
rs_hm = torch.sigmoid(output['rs_hm']).detach().cpu().numpy()
if 0:
print('output.keys:', output.keys())
rescores = rescoring_polygons(polys, rs_hm)
conf_keep = np.where(rescores > rs_thresh)[0]
detections = detections[conf_keep]
pys = [polys[k]* snake_config.down_ratio for k in conf_keep]
rescores = rescores[conf_keep]
rs_hm_path = os.path.join(cfg.vis_dir,(img_name[:-4]+'_rs.png'))
import matplotlib.pyplot as plt
plt.imshow(rs_hm[0,0,...])
plt.savefig(rs_hm_path)
if 0:
print('detections.shape:', detections.shape)
print('pys.num:', len(pys))
print('rs_hm.shape:', rs_hm.shape)
x = rs_hm[0,0,...]
import matplotlib.pyplot as plt
plt.imshow(x)
for k in range(len(pys)):
plt.plot(pys[k][:,0], pys[k][:, 1])
plt.savefig('{}.png'.format(img_name[:-4]))
plt.close()
np.save('rs_hm.npy', x)
np.save('pys.npy', np.array(pys))
exit()
else:
detections = output['detection'].detach().cpu().numpy()
detections[:,:4] = detections[:, :4] * snake_config.down_ratio
bboxes = detections[:, :4]
scores = detections[:, 4]
labels = detections[:, 5].astype(int)
ex_pts = output['ex'].detach().cpu().numpy()
ex_pts = ex_pts * snake_config.down_ratio
#pys = output['py'][-1].detach().cpu().numpy() * snake_config.down_ratio
iter_ply_output_lst = [x.detach().cpu().numpy()* snake_config.down_ratio for x in output['py']]
pys = iter_ply_output_lst[-1]
if cfg.vis_intermediate_output != 'none':
if cfg.vis_intermediate_output == 'htp':
xmin,ymin,xmax,ymax = bboxes[:,0::4], bboxes[:,1::4], bboxes[:, 2::4], bboxes[:,3::4]
pys = np.hstack((xmin,ymin, xmin,ymax,xmax,ymax,xmax,ymin))
pys = pys.reshape(pys.shape[0],4,2)
elif cfg.vis_intermediate_output == 'otp':
pys = ex_pts
elif cfg.vis_intermediate_output == 'clm_1':
pys = iter_ply_output_lst[0]
elif cfg.vis_intermediate_output == 'clm_2':
pys = iter_ply_output_lst[1]
else:
raise ValueError('Not supported type:', cfg.vis_intermediate_output)
cfg.poly_cls_branch = False
final_contour_feat = output['final_feat'].detach().cpu().numpy()
if cfg.poly_cls_branch:
pys_cls = output['py_cls'][-1].detach().cpu().numpy()
text_poly_scores = pys_cls[:, 1]
rem_ids = np.where(text_poly_scores > cfg.poly_conf_thresh)[0]
detections = detections[rem_ids]
pys = pys[rem_ids]
text_poly_scores = text_poly_scores[rem_ids]
ex_pts = ex_pts[rem_ids]
final_contour_feat = final_contour_feat[rem_ids]
if DEBUG:
print('py_cls_scores:', text_poly_scores)
if DEBUG:
print('dets_num:', len(pys))
if len(pys) == 0:
all_boundaries, poly_scores = [], []
else:
trans_output_inv = data_utils.get_affine_transform(center, scale, 0, [w, h], inv=1)
all_boundaries = [data_utils.affine_transform(py_, trans_output_inv) for py_ in pys]
bboxes_tmp = [data_utils.affine_transform(det[:4].reshape(-1,2), trans_output_inv).flatten() for det in detections]
ex_pts_tmp = [data_utils.affine_transform(ep, trans_output_inv) for ep in ex_pts]
detections = np.hstack((np.array(bboxes_tmp), detections[:,4:]))
ex_pts = np.array(ex_pts_tmp)
pp_time_s = time.time()
#sorting detections by scores
if cfg.poly_cls_branch:
detections, ex_points, all_boundaries, final_contour_feat, poly_scores \
= sorting_det_results(detections, ex_pts, all_boundaries, final_contour_feat, text_poly_scores)
else:
detections, ex_points, all_boundaries = sorting_det_results(detections, ex_pts, all_boundaries)
if len(all_boundaries) != 0:
detections[:,:4] /= rz_ratio
ex_points /= rz_ratio
all_boundaries = [poly/rz_ratio for poly in all_boundaries]
if 0:
import matplotlib.pyplot as plt
nms_polygons,rem_inds = snake_poly_utils.poly_nms(all_boundaries)
print('nms_polygons.num:', len(nms_polygons))
plt.subplot(1,2,1)
plt = plot_poly(org_img, all_boundaries,scores=scores)
plt.subplot(1,2,2)
plt = plot_poly(org_img, nms_polygons)
plt.savefig('a.png')
exit()
#nms
all_boundaries, rem_inds = snake_poly_utils.poly_nms(all_boundaries)
detections = detections[rem_inds]
ex_points = ex_points[rem_inds]
final_contour_feat = final_contour_feat[rem_inds]
if cfg.poly_cls_branch:
poly_scores = poly_scores[rem_inds]
pp_used_time = time.time() - pp_time_s
infer_time_lst.append([net_used_time, pp_used_time])
if DEBUG:
print('infer_time:',[net_used_time, pp_used_time])
if 0:
vis_tmp_results(org_img, detections, ex_points, all_boundaries, final_contour_feat, poly_scores, output, indx=img_name[:-4])
#--------------------------------saving results-------------------------------#
if cfg.testing_set == 'mlt':
det_file = os.path.join(cfg.det_dir, ('res_'+img_name[3:-4]+'.txt'))
saving_mot_det_results(det_file, all_boundaries, testing_set=cfg.testing_set, img=org_img)
elif cfg.testing_set == 'ic15':
det_file = os.path.join(cfg.det_dir, ('res_'+img_name[:-4]+'.txt'))
saving_mot_det_results(det_file, all_boundaries, testing_set=cfg.testing_set, img=org_img)
elif cfg.testing_set == 'msra':
det_file = os.path.join(cfg.det_dir, ('res_'+img_name[:-4]+'.txt'))
saving_mot_det_results(det_file, all_boundaries, testing_set=cfg.testing_set, img=org_img)
else: #for arbitrary-shape datasets, e.g., CTW,TOT,ART
det_file = os.path.join(cfg.det_dir, (img_name[:-4]+'.txt'))
saving_det_results(det_file, all_boundaries, img=org_img)
continue
#------------------------visualizing results---------------------------------#
## ~~~~~~ vis-v0 ~~~~~~~ ##
vis_file = os.path.join(cfg.vis_dir,(img_name[:-4]+'.png'))
if cfg.testing_set == 'ctw':
gt_file = os.path.join(cfg.gts_dir, (img_name[:-4]+'.txt'))
gt_polys = load_ctw_gt_label(gt_file)
elif cfg.testing_set == 'tot':
gt_file = os.path.join(cfg.gts_dir, ('poly_gt_'+img_name[:-4]+'.mat'))
gt_polys = load_tot_gt_label(gt_file)
elif cfg.testing_set == 'art':
gt_polys = None
elif cfg.testing_set == 'msra':
gt_file = os.path.join(cfg.gts_dir, ('gt_'+img_name[:-4]+'.txt'))
gt_polys = load_msra_gt_label(gt_file)
else:
raise ValueError('Not supported dataset ({}) for visualizing'.format(cfg.testing_set))
plt = vis_dets_gts(org_img, all_boundaries, gt_polys)
plt.savefig(vis_file,dpi=600,format='png')
plt.close()
### ~~~~~~~~~ vis-v1 ~~~~~~~~~~~ ###
# if cfg.poly_cls_branch:
# visualizing_det_results(org_img,all_boundaries,vis_file, scores=detections[:,4],poly_scores=poly_scores)
# else:
# visualizing_det_results(org_img,all_boundaries,vis_file, scores=detections[:,4])
## vis-v2
#hm_vis_dir = os.path.join(cfg.vis_dir, ('../vis_hm_on_img_dir'))
#if not os.path.exists(hm_vis_dir):
# os.makedirs(hm_vis_dir)
#visualizer.visualize(output, batch, os.path.join(hm_vis_dir,(img_name[:-4]+'.png')))
np.save('infer_time.npy', np.array(infer_time_lst))
def inference():
network = make_network(cfg).cuda()
load_network(network,
cfg.model_dir,
resume=cfg.resume,
epoch=cfg.test.epoch)
network.eval()
with open(os.path.join(cfg.results_dir, 'cfg.json'), 'w') as fid:
json.dump(cfg, fid)
dataset = Dataset()
visualizer = make_visualizer(cfg)
infer_time_lst = []
for batch in tqdm.tqdm(dataset):
batch['inp'] = torch.FloatTensor(batch['inp'])[None].cuda()
net_time_s = time.time()
with torch.no_grad():
output = network(batch['inp'], batch)
net_used_time = time.time() - net_time_s
org_img = batch['org_img']
rz_img = batch['rz_img']
rz_ratio = batch['rz_ratio']
img_name = batch['image_name']
center = batch['meta']['center']
scale = batch['meta']['scale']
h, w = batch['inp'].size(2), batch['inp'].size(3)
detections = output['detection'].detach().cpu().numpy()
detections[:, :4] = detections[:, :4] * snake_config.down_ratio
bboxes = detections[:, :4]
scores = detections[:, 4]
labels = detections[:, 5].astype(int)
ex_pts = output['ex'].detach().cpu().numpy()
ex_pts = ex_pts * snake_config.down_ratio
#pys = output['py'][-1].detach().cpu().numpy() * snake_config.down_ratio
iter_ply_output_lst = [
x.detach().cpu().numpy() * snake_config.down_ratio
for x in output['py']
]
pys = iter_ply_output_lst[-1]
final_contour_feat = output['final_feat'].detach().cpu().numpy()
if cfg.poly_cls_branch:
pys_cls = output['py_cls'][-1].detach().cpu().numpy()
text_poly_scores = pys_cls[:, 1]
rem_ids = np.where(text_poly_scores > cfg.poly_conf_thresh)[0]
detections = detections[rem_ids]
pys = pys[rem_ids]
text_poly_scores = text_poly_scores[rem_ids]
ex_pts = ex_pts[rem_ids]
final_contour_feat = final_contour_feat[rem_ids]
if len(pys) == 0:
all_boundaries, poly_scores = [], []
else:
trans_output_inv = data_utils.get_affine_transform(center,
scale,
0, [w, h],
inv=1)
all_boundaries = [
data_utils.affine_transform(py_, trans_output_inv)
for py_ in pys
]
bboxes_tmp = [
data_utils.affine_transform(det[:4].reshape(-1, 2),
trans_output_inv).flatten()
for det in detections
]
ex_pts_tmp = [
data_utils.affine_transform(ep, trans_output_inv)
for ep in ex_pts
]
detections = np.hstack((np.array(bboxes_tmp), detections[:, 4:]))
ex_pts = np.array(ex_pts_tmp)
pp_time_s = time.time()
#sorting detections by scores
if cfg.poly_cls_branch:
detections, ex_points, all_boundaries, final_contour_feat, poly_scores \
= sorting_det_results(detections, ex_pts, all_boundaries, final_contour_feat, text_poly_scores)
else:
detections, ex_points, all_boundaries = sorting_det_results(
detections, ex_pts, all_boundaries)
if cfg.rle_nms:
tmp_polys = all_boundaries.copy()
#all_boundaries, rem_inds = snake_poly_utils.poly_nms(tmp_polys)
rem_inds = poly_rle_nms(tmp_polys,
detections[:, -1], (h, w),
nms_thresh=0.3)
all_boundaries = [all_boundaries[idx] for idx in rem_inds]
else:
#nms
all_boundaries, rem_inds = snake_poly_utils.poly_nms(
all_boundaries)
detections = detections[rem_inds]
ex_points = ex_points[rem_inds]
final_contour_feat = final_contour_feat[rem_inds]
if cfg.poly_cls_branch:
poly_scores = poly_scores[rem_inds]
pp_used_time = time.time() - pp_time_s
infer_time_lst.append([net_used_time, pp_used_time])
if len(all_boundaries) != 0:
detections[:, :4] /= rz_ratio
ex_points /= rz_ratio
all_boundaries = [poly / rz_ratio for poly in all_boundaries]
#--------------------------------saving results-------------------------------#
det_file = os.path.join(cfg.det_dir, (img_name[:-4] + '.txt'))
saving_det_results(det_file, all_boundaries, img=org_img)
