def evaluate(args):
assert torch.cuda.is_available(), 'CUDA is not available.'
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
print ('The image is {:}'.format(args.image))
print ('The model is {:}'.format(args.model))
snapshot = Path(args.model)
assert snapshot.exists(), 'The model path {:} does not exist'
print ('The face bounding box is {:}'.format(args.face))
assert len(args.face) == 4, 'Invalid face input : {:}'.format(args.face)
snapshot = torch.load(snapshot)
# General Data Argumentation
mean_fill = tuple( [int(x*255) for x in [0.485, 0.456, 0.406] ] )
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
param = snapshot['args']
import pdb; pdb.set_trace()
eval_transform = transforms.Compose([transforms.PreCrop(param.pre_crop_expand), transforms.TrainScale2WH((param.crop_width, param.crop_height)), transforms.ToTensor(), normalize])
model_config = load_configure(param.model_config, None)
dataset = Dataset(eval_transform, param.sigma, model_config.downsample, param.heatmap_type, param.data_indicator)
dataset.reset(param.num_pts)
net = obtain_model(model_config, param.num_pts + 1)
net = net.cuda()
weights = remove_module_dict(snapshot['detector'])
net.load_state_dict(weights)
print ('Prepare input data')
[image, _, _, _, _, _, cropped_size], meta = dataset.prepare_input(args.image, args.face)
inputs = image.unsqueeze(0).cuda()
# network forward
with torch.no_grad():
batch_heatmaps, batch_locs, batch_scos = net(inputs)
# obtain the locations on the image in the orignial size
cpu = torch.device('cpu')
np_batch_locs, np_batch_scos, cropped_size = batch_locs.to(cpu).numpy(), batch_scos.to(cpu).numpy(), cropped_size.numpy()
locations, scores = np_batch_locs[0,:-1,:], np.expand_dims(np_batch_scos[0,:-1], -1)
scale_h, scale_w = cropped_size[0] * 1. / inputs.size(-2) , cropped_size[1] * 1. / inputs.size(-1)
locations[:, 0], locations[:, 1] = locations[:, 0] * scale_w + cropped_size[2], locations[:, 1] * scale_h + cropped_size[3]
prediction = np.concatenate((locations, scores), axis=1).transpose(1,0)
print ('the coordinates for {:} facial landmarks:'.format(param.num_pts))
for i in range(param.num_pts):
point = prediction[:, i]
print ('the {:02d}/{:02d}-th point : ({:.1f}, {:.1f}), score = {:.2f}'.format(i, param.num_pts, float(point[0]), float(point[1]), float(point[2])))
if args.save:
resize = 512
image = draw_image_by_points(args.image, prediction, 2, (255, 0, 0), args.face, resize)
image.save(args.save)
print ('save the visualization results into {:}'.format(args.save))
else:
print ('ignore the visualization procedure')
def evaluate(args):
assert torch.cuda.is_available(), 'CUDA is not available.'
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
print ('The image is {:}'.format(args.image))
print ('The model is {:}'.format(args.model))
snapshot = Path(args.model)
assert snapshot.exists(), 'The model path {:} does not exist'
print ('The face bounding box is {:}'.format(args.face))
assert len(args.face) == 4, 'Invalid face input : {:}'.format(args.face)
snapshot = torch.load(snapshot)
# General Data Argumentation
mean_fill = tuple( [int(x*255) for x in [0.485, 0.456, 0.406] ] )
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
param = snapshot['args']
eval_transform = transforms.Compose([transforms.PreCrop(param.pre_crop_expand), transforms.TrainScale2WH((param.crop_width, param.crop_height)), transforms.ToTensor(), normalize])
model_config = load_configure(param.model_config, None)
dataset = Dataset(eval_transform, param.sigma, model_config.downsample, param.heatmap_type, param.data_indicator)
dataset.reset(param.num_pts)
net = obtain_model(model_config, param.num_pts + 1)
net = net.cuda()
weights = remove_module_dict(snapshot['state_dict'])
net.load_state_dict(weights)
print ('Prepare input data')
[image, _, _, _, _, _, cropped_size], meta = dataset.prepare_input(args.image, args.face)
inputs = image.unsqueeze(0).cuda()
# network forward
with torch.no_grad():
batch_heatmaps, batch_locs, batch_scos = net(inputs)
# obtain the locations on the image in the orignial size
cpu = torch.device('cpu')
np_batch_locs, np_batch_scos, cropped_size = batch_locs.to(cpu).numpy(), batch_scos.to(cpu).numpy(), cropped_size.numpy()
locations, scores = np_batch_locs[0,:-1,:], np.expand_dims(np_batch_scos[0,:-1], -1)
scale_h, scale_w = cropped_size[0] * 1. / inputs.size(-2) , cropped_size[1] * 1. / inputs.size(-1)
locations[:, 0], locations[:, 1] = locations[:, 0] * scale_w + cropped_size[2], locations[:, 1] * scale_h + cropped_size[3]
prediction = np.concatenate((locations, scores), axis=1).transpose(1,0)
print ('the coordinates for {:} facial landmarks:'.format(param.num_pts))
for i in range(param.num_pts):
point = prediction[:, i]
print ('the {:02d}/{:02d}-th point : ({:.1f}, {:.1f}), score = {:.2f}'.format(i, param.num_pts, float(point[0]), float(point[1]), float(point[2])))
if args.save:
resize = 512
image = draw_image_by_points(args.image, prediction, 2, (255, 0, 0), args.face, resize)
image.save(args.save)
print ('save the visualization results into {:}'.format(args.save))
else:
print ('ignore the visualization procedure')
snapshot = torch.load(snapshot)
mean_fill = tuple([int(x * 255) for x in [0.485, 0.456, 0.406]])
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
param = snapshot['args']
eval_transform = transforms.Compose([
transforms.PreCrop(param.pre_crop_expand),
transforms.TrainScale2WH((param.crop_width, param.crop_height)),
transforms.ToTensor(), normalize
])
model_config = load_configure(param.model_config, None)
dataset = Dataset(eval_transform, param.sigma, model_config.downsample,
param.heatmap_type, param.data_indicator)
dataset.reset(param.num_pts)
net = obtain_model(model_config, param.num_pts + 1)
net = net.cuda()
#import pdb; pdb.set_trace()
try:
weights = remove_module_dict(snapshot['detector'])
except:
weights = remove_module_dict(snapshot['state_dict'])
net.load_state_dict(weights)
def evaluate(args):
assert torch.cuda.is_available(), 'CUDA is not available.'
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
def evaluate(args):
assert torch.cuda.is_available(), 'CUDA is not available.'
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
model_name = os.path.split(args.model)[-1]
onnx_name = os.path.splitext(model_name)[0] + ".onnx"
print('The model is {:}'.format(args.model))
print('Model name is {:} \nOutput onnx file is {:}'.format(
model_name, onnx_name))
snapshot = Path(args.model)
assert snapshot.exists(), 'The model does not exist {:}'
#print('Output onnx file is {:}'.format(onnx_name))
snapshot = torch.load(snapshot)
# General Data Argumentation
mean_fill = tuple([int(x * 255) for x in [0.485, 0.456, 0.406]])
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
param = snapshot['args']
print(param)
eval_transform = transforms.Compose([
transforms.PreCrop(param.pre_crop_expand),
transforms.TrainScale2WH((param.crop_width, param.crop_height)),
transforms.ToTensor(), normalize
])
model_config = load_configure(param.model_config, None)
print(model_config)
dataset = Dataset(eval_transform, param.sigma, model_config.downsample,
param.heatmap_type, param.data_indicator)
dataset.reset(param.num_pts)
net = obtain_model(model_config, param.num_pts + 1)
net = net
weights = remove_module_dict(snapshot['state_dict'])
nu_weights = {}
for key, val in weights.items():
nu_weights[key.split('detector.')[-1]] = val
print(key.split('detector.')[-1])
weights = nu_weights
net.load_state_dict(weights)
input_name = ['image_in']
output_name = ['locs', 'scors', 'crap']
im = cv2.imread('Menpo51220/val/0000018.jpg')
imshape = im.shape
face = [0, 0, imshape[0], imshape[1]]
[image, _, _, _, _, _,
cropped_size], meta = dataset.prepare_input('Menpo51220/val/0000018.jpg',
face)
dummy_input = torch.randn(1,
3,
256,
256,
requires_grad=True,
dtype=torch.float32)
input(dummy_input.dtype)
#input('imcrap')
inputs = image.unsqueeze(0)
out_in = inputs.data.numpy()
with open('pick.pick', 'wb') as crap:
pickle.dump(out_in, crap)
with torch.no_grad():
batch_locs, batch_scos, heatmap = net(inputs)
torch.onnx.export(net.cuda(),
dummy_input.cuda(),
onnx_name,
verbose=True,
input_names=input_name,
output_names=output_name,
export_params=True)
print(batch_locs)
print(batch_scos)
print(heatmap)
cpu = torch.device('cpu')
np_batch_locs, np_batch_scos, cropped_size = batch_locs.to(
cpu).numpy(), batch_scos.to(cpu).numpy(), cropped_size.numpy()
locations = np_batch_locs[:-1, :]
scores = np.expand_dims(np_batch_scos[:-1], -1)
scale_h, scale_w = cropped_size[0] * 1. / inputs.size(
-2), cropped_size[1] * 1. / inputs.size(-1)
locations[:,
0], locations[:,
1] = locations[:,
0] * scale_w, locations[:,
1] * scale_h
prediction = np.concatenate((locations, scores), axis=1).transpose(1, 0)
pred_pts = np.transpose(prediction, [1, 0])
pred_pts = pred_pts[:, :-1]
#print(pred_pts)
sim = draw_pts(im, pred_pts=pred_pts, get_l1e=False)
cv2.imwrite('py_0.jpg', sim)
def evaluate(args):
assert torch.cuda.is_available(), 'CUDA is not available.'
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
print('The image is {:}'.format(args.image))
print('The model is {:}'.format(args.model))
snapshot = Path(args.model)
assert snapshot.exists(), 'The model path {:} does not exist'
snapshot = torch.load(snapshot)
# General Data Argumentation
mean_fill = tuple([int(x * 255) for x in [0.485, 0.456, 0.406]])
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
param = snapshot['args']
eval_transform = transforms.Compose([
transforms.PreCrop(param.pre_crop_expand),
transforms.TrainScale2WH((param.crop_width, param.crop_height)),
transforms.ToTensor(), normalize
])
model_config = load_configure(param.model_config, None)
dataset = Dataset(eval_transform, param.sigma, model_config.downsample,
param.heatmap_type, param.data_indicator)
dataset.reset(param.num_pts)
net = obtain_model(model_config, param.num_pts + 1)
net = net.cuda()
weights = remove_module_dict(snapshot['state_dict'])
nu_weights = {}
for key, val in weights.items():
nu_weights[key.split('detector.')[-1]] = val
print(key.split('detector.')[-1])
weights = nu_weights
net.load_state_dict(weights)
print('Prepare input data')
l1 = []
record_writer = Collection_engine.produce_generator()
total_images = len(images)
for im_ind, aimage in enumerate(images):
progressbar(im_ind, total_images)
pts_name = os.path.splitext(aimage)[0] + '.pts'
pts_full = _pts_path_ + pts_name
gtpts = get_pts(pts_full, 90)
aim = _image_path + aimage
args.image = aim
im = cv2.imread(aim)
imshape = im.shape
args.face = [0, 0, imshape[0], imshape[1]]
[image, _, _, _, _, _,
cropped_size], meta = dataset.prepare_input(args.image, args.face)
inputs = image.unsqueeze(0).cuda()
# network forward
with torch.no_grad():
batch_heatmaps, batch_locs, batch_scos = net(inputs)
# obtain the locations on the image in the orignial size
cpu = torch.device('cpu')
np_batch_locs, np_batch_scos, cropped_size = batch_locs.to(
cpu).numpy(), batch_scos.to(cpu).numpy(), cropped_size.numpy()
locations, scores = np_batch_locs[0, :-1, :], np.expand_dims(
np_batch_scos[0, :-1], -1)
scale_h, scale_w = cropped_size[0] * 1. / inputs.size(
-2), cropped_size[1] * 1. / inputs.size(-1)
locations[:,
0], locations[:,
1] = locations[:, 0] * scale_w + cropped_size[
2], locations[:,
1] * scale_h + cropped_size[3]
prediction = np.concatenate((locations, scores),
axis=1).transpose(1, 0)
#print ('the coordinates for {:} facial landmarks:'.format(param.num_pts))
for i in range(param.num_pts):
point = prediction[:, i]
#print ('the {:02d}/{:02d}-th point : ({:.1f}, {:.1f}), score = {:.2f}'.format(i, param.num_pts, float(point[0]), float(point[1]), float(point[2])))
if args.save:
args.save = _output_path + aimage
resize = 512
#image = draw_image_by_points(args.image, prediction, 2, (255, 0, 0), args.face, resize)
#sim, l1e =draw_pts(im, gt_pts=gtpts, pred_pts=prediction, get_l1e=True)
#print(np.mean(l1e))
#l1.append(np.mean(l1e))
pred_pts = np.transpose(prediction, [1, 0])
pred_pts = pred_pts[:, :-1]
record_writer.consume_data(im,
gt_pts=gtpts,
pred_pts=pred_pts,
name=aimage)
#cv2.imwrite(_output_path+aimage, sim)
#image.save(args.save)
#print ('save the visualization results into {:}'.format(args.save))
else:
print('ignore the visualization procedure')
record_writer.post_process()
record_writer.generate_output(output_path=_output_path,
epochs=50,
name='Supervision By Registration')
def evaluate(args):
assert torch.cuda.is_available(), 'CUDA is not available.'
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
print('The model is {:}'.format(args.model))
snapshot = Path(args.model)
assert snapshot.exists(), 'The model path {:} does not exist'
snapshot = torch.load(snapshot)
# General Data Argumentation
mean_fill = tuple([int(x * 255) for x in [0.485, 0.456, 0.406]])
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
param = snapshot['args']
eval_transform = transforms.Compose([
transforms.PreCrop(param.pre_crop_expand),
transforms.TrainScale2WH((param.crop_width, param.crop_height)),
transforms.ToTensor(), normalize
])
model_config = load_configure(param.model_config, None)
dataset = Dataset(eval_transform, param.sigma, model_config.downsample,
param.heatmap_type, param.data_indicator)
dataset.reset(param.num_pts)
net = obtain_model(model_config, param.num_pts + 1)
net = net.cuda()
weights = remove_module_dict(snapshot['state_dict'])
nu_weights = {}
for key, val in weights.items():
nu_weights[key.split('detector.')[-1]] = val
print(key.split('detector.')[-1])
weights = nu_weights
net.load_state_dict(weights)
print('Prepare input data')
images = os.listdir(args.image_path)
images = natsort.natsorted(images)
total_images = len(images)
for im_ind, aimage in enumerate(images):
progressbar(im_ind, total_images)
#aim = os.path.join(args.image_path, aimage)
aim = '0.jpg'
args.image = aim
im = cv2.imread(aim)
imshape = im.shape
print(imshape)
input('crap12')
args.face = [0, 0, imshape[0], imshape[1]]
[image, _, _, _, _, _,
cropped_size], meta = dataset.prepare_input(args.image, args.face)
inputs = image.unsqueeze(0).cuda()
scale_h, scale_w = cropped_size[0] * 1. / inputs.size(
-2), cropped_size[1] * 1. / inputs.size(-1)
print(inputs.size(-2))
print(inputs.size(-1))
print(scale_w.data.numpy())
print(scale_h.data.numpy())
print(cropped_size.data.numpy())
input('crap')
# network forward
with torch.no_grad():
batch_locs, batch_scos = net(inputs)
c_im = np.expand_dims(image.data.numpy(), 0)
c_locs, c_scors = rep.run(c_im)
# obtain the locations on the image in the orignial size
cpu = torch.device('cpu')
np_batch_locs, np_batch_scos, cropped_size = batch_locs.to(
cpu).numpy(), batch_scos.to(cpu).numpy(), cropped_size.numpy()
locations, scores = np_batch_locs[0, :-1, :], np.expand_dims(
np_batch_scos[0, :-1], -1)
locations[:, 0], locations[:, 1] = locations[:, 0] * scale_w + cropped_size[2], locations[:, 1] * scale_h + \
cropped_size[3]
prediction = np.concatenate((locations, scores),
axis=1).transpose(1, 0)
c_locations = c_locs[0, :-1, :]
c_locations[:, 0], c_locations[:, 1] = c_locations[:, 0] * scale_w + cropped_size[2], c_locations[:, 1] * scale_h + \
cropped_size[3]
c_scores = np.expand_dims(c_scors[0, :-1], -1)
c_pred_pts = np.concatenate((c_locations, c_scores),
axis=1).transpose(1, 0)
pred_pts = np.transpose(prediction, [1, 0])
pred_pts = pred_pts[:, :-1]
c_pred_pts = np.transpose(c_pred_pts, [1, 0])
c_pred_pts = c_pred_pts[:, :-1]
print(c_scors, '\n\n\n')
print(np_batch_scos)
print(c_scors - np_batch_scos)
if args.save:
json_file = os.path.splitext(aimage)[0] + '.jpg'
save_path = os.path.join(args.save, 'caf' + json_file)
save_path2 = os.path.join(args.save, 'py_' + json_file)
sim2 = draw_pts(im, pred_pts=pred_pts, get_l1e=False)
sim = draw_pts(im, pred_pts=c_pred_pts, get_l1e=False)
#print(pred_pts)
cv2.imwrite(save_path, sim)
cv2.imwrite(save_path2, sim2)
input('save1')
# image.save(args.save)
# print ('save the visualization results into {:}'.format(args.save))
else:
print('ignore the visualization procedure')
