def main_test():
xnet = HourglassNet(16, 8, (256, 256), (64, 64))
xnet.load_model("../../trained_models/hg_s8_b1_sigma1/net_arch.json", "../../trained_models/hg_s8_b1_sigma1/weights_epoch22.h5")
valdata = MPIIDataGen("../../data/mpii/mpii_annotations.json", "../../data/mpii/images",
inres=(256, 256), outres=(64, 64), is_train=False)
total_good, total_fail = 0, 0
threshold = 0.5
print('val data size', valdata.get_dataset_size())
count = 0
batch_size = 8
for _img, _gthmap, _meta in valdata.tt_generator(batch_size, 8, sigma=2, is_shuffle=False , with_meta=True):
count += batch_size
if count % (batch_size*100) == 0:
print(count, 'processed', total_good, total_fail)
if count > valdata.get_dataset_size():
break
out = xnet.model.predict(_img)
good, bad = cal_heatmap_acc(out[-1], _meta, threshold)
total_good += good
total_fail += bad
print(total_good, total_fail, threshold, total_good*1.0/(total_good + total_fail))
def main_eval(model_json, model_weights, num_stack, num_class, matfile):
xnet = HourglassNet(num_class, num_stack, (256, 256), (64, 64))
xnet.load_model(model_json, model_weights)
valdata = MPIIDataGen("../../data/mpii/mpii_annotations.json", "../../data/mpii/images",
inres=(256, 256), outres=(64, 64), is_train=False)
print 'val data size', valdata.get_dataset_size()
valkps = np.zeros(shape=(valdata.get_dataset_size(), 16, 2), dtype=np.float)
count = 0
batch_size = 8
for _img, _gthmap, _meta in valdata.generator(batch_size, num_stack, sigma=1, is_shuffle=False , with_meta=True):
count += batch_size
if count > valdata.get_dataset_size():
break
out = xnet.model.predict(_img)
get_final_pred_kps(valkps, out[-1], _meta)
scipy.io.savemat(matfile, mdict={'preds' : valkps})
run_pckh(model_json, matfile)
def main_test():
xnet = HourglassNet(16, 8, (256, 256), (64, 64))
xnet.load_model("../../trained_models/hg_s8_b1_v1_adam/net_arch.json",
"../../trained_models/hg_s8_b1_v1_adam/weights_epoch22.h5")
valdata = MPIIDataGen("../../data/mpii/mpii_annotations.json", "../../data/mpii/images",
inres=(256, 256), outres=(64, 64), is_train=False)
print 'val data size', valdata.get_dataset_size()
valkps = np.zeros(shape=(valdata.get_dataset_size(), 16, 2), dtype=np.float)
count = 0
batch_size = 8
for _img, _gthmap, _meta in valdata.generator(batch_size, 8, sigma=2, is_shuffle=False , with_meta=True):
count += batch_size
if count > valdata.get_dataset_size():
break
out = xnet.model.predict(_img)
get_final_pred_kps(valkps, out[-1], _meta)
matfile = os.path.join( "../../trained_models/hg_s8_b1_v1_adam/", 'preds_e22.mat')
scipy.io.savemat(matfile, mdict={'preds' : valkps})
run_pckh('hg_s8_b1_epoch22', matfile)
def main_video(model_json, model_weights, num_stack, num_class, videofile,
confth):
xnet = HourglassNet(num_class, num_stack, (256, 256), (64, 64))
xnet.load_model(model_json, model_weights)
cap = cv2.VideoCapture(videofile)
while (cap.isOpened()):
ret, frame = cap.read()
if ret:
rgb = frame[:, :, ::-1] # bgr -> rgb
out, scale = xnet.inference_rgb(rgb, frame.shape)
kps = post_process_heatmap(out[0, :, :, :])
ignore_kps = ['plevis', 'thorax', 'head_top']
kp_keys = MPIIDataGen.get_kp_keys()
mkps = list()
for i, _kp in enumerate(kps):
if kp_keys[i] in ignore_kps:
_conf = 0.0
else:
_conf = _kp[2]
mkps.append(
(_kp[0] * scale[1] * 4, _kp[1] * scale[0] * 4, _conf))
framejoints = render_joints(frame, mkps, confth)
cv2.imshow('frame', framejoints)
cv2.waitKey(10)
def main_eval(model_json, model_weights, num_stack, num_class, matfile, tiny):
inres = (192, 192) if tiny else (256, 256)
outres = (48, 48) if tiny else (64, 64)
num_channles = 128 if tiny else 256
xnet = HourglassNet(num_classes=num_class,
num_stacks=num_stack,
num_channels=num_channles,
inres=inres,
outres=outres)
xnet.load_model(model_json, model_weights)
# dataset_path = '/home/tomas_bordac/nyu_croped'
dataset_path = os.path.join('D:\\', 'nyu_croped')
valdata = NYUHandDataGen('joint_data.mat',
dataset_path,
inres=inres,
outres=outres,
is_train=False)
print('val data size', valdata.get_dataset_size())
valkps = np.zeros(shape=(valdata.get_dataset_size(), 11, 2),
dtype=np.float)
count = 0
batch_size = 8
for _img, _gthmap, _meta in valdata.generator(batch_size,
num_stack,
sigma=3,
is_shuffle=False,
with_meta=True):
count += batch_size
if count > valdata.get_dataset_size():
break
out = xnet.model.predict(_img)
get_final_pred_kps(valkps, out[-1], _meta, outres)
scipy.io.savemat(matfile, mdict={'preds': valkps})
run_pckh(model_json, matfile)
def main_inference(model_json, model_weights, num_stack, num_class, imgfile, confth, tiny):
if tiny:
xnet = HourglassNet(num_classes=16, num_stacks=args.num_stack, num_channels=128, inres=(192, 192),
outres=(48, 48))
else:
xnet = HourglassNet(num_classes=16, num_stacks=args.num_stack, num_channels=256, inres=(256, 256),
outres=(64, 64))
xnet.load_model(model_json, model_weights)
out, scale = xnet.inference_file(imgfile)
kps = post_process_heatmap(out[0, :, :, :])
ignore_kps = ['plevis', 'thorax', 'head_top']
kp_keys = MPIIDataGen.get_kp_keys()
mkps = list()
for i, _kp in enumerate(kps):
if kp_keys[i] in ignore_kps:
_conf = 0.0
else:
_conf = _kp[2]
mkps.append((_kp[0] * scale[1] * 4, _kp[1] * scale[0] * 4, _conf))
cvmat = render_joints(cv2.imread(imgfile), mkps, confth)
cv2.imshow('frame', cvmat)
cv2.waitKey()
def main_test():
xnet = HourglassNet(16, 8, (256, 256), (64, 64))
xnet.load_model("../../trained_models/hg_s8_b1/net_arch.json",
"../../trained_models/hg_s8_b1/weights_epoch29.h5")
valdata = MPIIDataGen("../../data/mpii/mpii_annotations.json",
"../../data/mpii/images",
inres=(256, 256),
outres=(64, 64),
is_train=False)
for _img, _gthmap in valdata.generator(1, 8, sigma=2, is_shuffle=True):
out = xnet.model.predict(_img)
scipy.misc.imshow(_img[0, :, :, :])
#view_predict_hmap(_gthmap)
view_predict_hmap(out, show_raw=False)
def main_eval(model_path, num_stack, num_class, matfile, tiny):
inres = (192, 192) if tiny else (256, 256)
outres = (48, 48) if tiny else (64, 64)
num_channles = 128 if tiny else 256
xnet = HourglassNet(num_classes=num_class,
num_stacks=num_stack,
num_channels=num_channles,
inres=inres,
outres=outres)
xnet.load_model(model_path)
valdata = MPIIDataGen("../../data/mpii/mpii_annotations.json",
"../../data/mpii/images",
inres=inres,
outres=outres,
is_train=False)
print('val data size', valdata.get_dataset_size())
valkps = np.zeros(shape=(valdata.get_dataset_size(), 16, 2),
dtype=np.float)
count = 0
batch_size = 8
for _img, _gthmap, _meta in valdata.generator(batch_size,
num_stack,
sigma=1,
is_shuffle=False,
with_meta=True):
count += batch_size
if count > valdata.get_dataset_size():
break
out = xnet.model.predict(_img)
get_final_pred_kps(valkps, out[-1], _meta, outres)
scipy.io.savemat(matfile, mdict={'preds': valkps})
run_pckh(model_path, matfile)
def __init__(self,
stacks,
blocks,
depth_res,
nParts,
resume_p2v2c=None,
resume_p2v=None,
resume_v2c=None,
is_cuda=True):
super(pvcNet, self).__init__()
self.num_stacks = stacks
self.num_blocks = blocks
self.depth_res = depth_res
self.nParts = nParts
self.resume = dict()
self.resume['p2v2c'] = resume_p2v2c
self.resume['p2v'] = resume_p2v
self.resume['v2c'] = resume_v2c
self.is_cuda = is_cuda
self.epoch = 0
self.best_acc = 0
self.current_acc = -0
if len(set(self.depth_res)) == 1:
self.c2f = False
else:
self.c2f = True
print('coarse to fine mode: {}'.format(self.c2f))
pix2vox = HourglassNet(Bottleneck, self.num_stacks, self.num_blocks,
self.depth_res)
vox2coord = coordRegressor(self.nParts)
if self.is_cuda:
self.pix2vox = torch.nn.DataParallel(pix2vox).cuda()
self.vox2coord = torch.nn.DataParallel(vox2coord).cuda()
else:
self.pix2vox = pix2vox
self.vox2coord = vox2coord
print(' p2v params: %.2fM' %
(sum(p.numel() for p in self.pix2vox.parameters()) / 1000000.0))
print(' v2c params: %.2fM' %
(sum(p.numel()
for p in self.vox2coord.parameters()) / 1000000.0))
init_epoch = 0
# In[6]:
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = str(0)
# TensorFlow wizardry
config = tf.ConfigProto()
# Don't pre-allocate memory; allocate as-needed
config.gpu_options.allow_growth = True
# Only allow a total of half the GPU memory to be allocated
config.gpu_options.per_process_gpu_memory_fraction = 1.0
# Create a session with the above options specified.
k.tensorflow_backend.set_session(tf.Session(config=config))
xnet = HourglassNet(num_classes=16, num_stacks=num_stacks, num_channels=256, inres=(256, 256),outres=(64, 64))
if resume:
xnet.resume_train(batch_size=batch_size,
model_path=model_path,
init_epoch=init_epoch, epochs=args.epochs)
else:
xnet.build_model(show=True)
xnet.train(epochs=epochs, model_path=model_path, batch_size=batch_size)
# %% Load Annotations into dataframes
import hourglass
import imp
imp.reload(hourglass)
from hourglass import HourglassNet
from constants import *
import matplotlib.pyplot as plt
import os
# %matplotlib inline
h = HourglassNet(NUM_COCO_KEYPOINTS, DEFAULT_NUM_HG, INPUT_CHANNELS, INPUT_DIM,
OUTPUT_DIM)
train_df, val_df = h.load_and_filter_annotations(DEFAULT_TRAIN_ANNOT_PATH,
DEFAULT_VAL_ANNOT_PATH, 0.1)
# %% Declare evaluation class instance
import pandas as pd
import evaluation
import HeatMap
imp.reload(evaluation)
imp.reload(HeatMap)
# %%
representative_set_df = pd.read_pickle(
os.path.join(DEFAULT_PICKLE_PATH, 'representative_set.pkl'))
subdir = '2021-04-01-21h-59m_batchsize_16_hg_4_loss_weighted_mse_aug_light_sigma4_learningrate_5.0e-03_opt_rmsProp_gt-4kp_activ_sigmoid_subset_0.50_lrfix'
eval = evaluation.Evaluation(model_sub_dir=subdir, epoch=26)
# %% Save stacked evaluation heatmaps
import data_generator
imp.reload(data_generator)
if __name__ == "__main__":
args = process_args()
print("\n\nSetup start: {}\n".format(time.ctime()))
setup_start = time.time()
tensorflow_setup()
hgnet = HourglassNet(num_classes=NUM_COCO_KEYPOINTS,
num_stacks=args.hourglass,
num_channels=NUM_CHANNELS,
inres=INPUT_DIM,
outres=OUTPUT_DIM,
loss_str=args.loss,
image_aug_str=args.augment,
pickle_name=args.pickle,
optimizer_str=args.optimizer,
learning_rate=args.learning_rate,
activation_str=args.activation)
training_start = time.time()
# TODO Save all model parameters in JSON for easy resuming and parsing later on
if args.resume:
print("\n\nResume training start: {}\n".format(time.ctime()))
hgnet.resume_train(args.batch, args.model_save, args.resume_json, args.resume_weights, \
args.resume_epoch, args.epochs, args.resume_subdir, args.subset, new_run=args.resume_with_new_run)
else:
# Only allow a total of half the GPU memory to be allocated
# -config.gpu_options.per_process_gpu_memory_fraction = 1.0
config.gpu_options.per_process_gpu_memory_fraction = 0.8
# Create a session with the above options specified.
# AttributeError: module 'keras.backend' has no attribute 'tensorflow_backend
# -k.tensorflow_backend.set_session(tf.Session(config=config))
# AttributeError: module 'keras.backend' has no attribute 'set_session'
# -k.set_session(tf.Session(config=config))
tf.compat.v1.keras.backend.set_session(tf.compat.v1.Session(config=config))"""
if args.tiny:
xnet = HourglassNet(num_classes=16,
num_stacks=args.num_stack,
num_channels=128,
inres=(192, 192),
outres=(48, 48))
else:
xnet = HourglassNet(num_classes=16,
num_stacks=args.num_stack,
num_channels=256,
inres=(256, 256),
outres=(64, 64))
if args.resume:
xnet.resume_train(batch_size=args.batch_size,
model_json=args.resume_model_json,
model_weights=args.resume_model,
init_epoch=args.init_epoch,
epochs=epochs)
