def collect_feature_meta(folder, re_exp='batch_feature_\w+$'):
allfile = sorted(iu.getfilelist(folder, re_exp), key=lambda x:extract_batch_num(x))
feature_list_lst = []
feature_dim = None
indexes_lst = []
feature_names = None
if len(allfile) == 0:
return dict()
for f in allfile:
print f
p = iu.fullfile(folder, f)
d = mio.unpickle(p)
feature_list_lst += [d['feature_list']]
if feature_dim:
if feature_dim!= d['feature_dim']:
raise Exception('feature dim inconsistent')
else:
feature_dim = d['feature_dim']
indexes_lst += [d['info']['indexes']]
indexes = np.concatenate(indexes_lst)
n_feature, n_batch = len(feature_dim), len(allfile)
feature_list = [np.concatenate([feature_list_lst[i][k] for i in range(n_batch)],
axis=-1)
for k in range(n_feature)]
return {'feature_list':feature_list, 'feature_dim':feature_dim, 'info':{'indexes':indexes,
'feature_names':d['info']['feature_names']}}
def gbns(name,sp, params):
"""
get bias for combining norm and scale layer
params[0] = model_folder
params[1] = norm layer name [source]
params[2] = scale layer name [source]
"""
model_folder, norm_name, scale_name = params[0], params[1], params[2]
stat_folder = iu.fullfile(model_folder, 'stat')
stat_path = Solver.get_saved_model_path(stat_folder)
stat = mio.unpickle(stat_path)
model = Solver.get_saved_model(model_folder)
layers = get_layers(model)
W= layers[scale_name][2]['weights'][0]
b= layers[scale_name][2]['biases'][0]
print 'W-------------'
iu.print_common_statistics(W)
print 'b'
iu.print_common_statistics(b)
if 'epsilon' in layers[norm_name][2]:
epsilon = layers[norm_name][2]['epsilon']
else:
epsilon = 1e-6
u = stat['layers'][norm_name]['u'].flatten()
var = stat['layers'][norm_name]['var'].flatten()
return [b - W * u / (np.sqrt(var + epsilon))]
def __init__(self, data_dir, feature_range, init_epoch=1, init_batchnum=None, dp_params={}, test=False):
DataProvider.__init__(self, data_dir, feature_range, init_epoch, init_batchnum, dp_params, test)
self.shuffle_data = dp_params['shuffle_data'] # determine whether to shuffle test data
if 'external_meta_path' in dp_params and dp_params['external_meta_path']:
import iread.myio as mio
ext_meta = mio.unpickle(dp_params['external_meta_path'])
print 'Print load external_meta for %s succussfully' % dp_params['external_meta_path']
for item in ext_meta:
self.batch_meta[item] = ext_meta[item]
print '----Load %s from ext_meta succussfully' % item
del ext_meta
self.test = test
self.feature_range = np.asarray(feature_range)
self.num_feature = len(feature_range)
self.batch_size = dp_params['batch_size']
self.keep_data_dic = False
if self.batch_size > self.num_feature or self.batch_size <= 0:
raise BasicDataProviderError('Invaid batch_size %d (num_image=%d)' % (self.batch_size, self.num_feature))
self.num_batch = (self.num_feature - 1)/ self.batch_size + 1
self.batch_range = range(self.num_feature)
if self.curr_batchnum not in self.batch_range:
self.curr_batchnum = 0
self.curr_batchnum = min(max(self.curr_batchnum, 0), self.num_feature - 1)
self.batch_idx = self.curr_batchnum
if test and self.shuffle_data == 0:
# There is no need to shuffle testing data
self.shuffled_feature_range = self.feature_range
else:
self.shuffled_feature_range = self.feature_range[rd.permutation(self.num_feature)]
self.num_feature_type = len(self.batch_meta['feature_dim'])
self.feature_dim = self.batch_meta['feature_dim']
def create_dp(op, saved_model = None):
try:
if saved_model and 'dp_params' in saved_model['solver_params']:
dp_params = saved_model['solver_params']['dp_params']
else:
dp_params = None
required_fields = ['data_path', 'data_provider', 'train_range', 'test_range',
'batch_size']
d = dict()
for e in required_fields:
if op.get_value(e):
d[e] = op.get_value(e)
else:
d[e] = dp_params[e]
except Exception as e:
print e
sys.exit(1)
meta= mio.unpickle(iu.fullfile(d['data_path'], 'batches.meta'))
param1, param2 = dict(), dict()
if saved_model:
copy_dic_by_key(param1, saved_model['model_state']['train'], ['epoch', 'batchnum'])
copy_dic_by_key(param2, saved_model['model_state']['test'], ['epoch', 'batchnum'])
copy_dic_by_key(param1, d, ['batch_size'])
copy_dic_by_key(param2, d, ['batch_size'])
dp_type = d['data_provider']
pre_process_data(meta) # < ---- This should be used with care
train_dp = dp_dic[dp_type](data_dic=meta, train=True, data_range=d['train_range'], params=param1)
test_dp = dp_dic[dp_type](data_dic=meta, train=False, data_range=d['test_range'], params=param2)
return d, train_dp, test_dp
def get_wb_from_convnet2_checkpoint(name, sp, params, item_type):
"""
params = [check_point_path, layer_name, ]
"""
sys.path.append('/home/grads/sijinli2/Projects/cuda-convnet2/')
checkpath = params[0]
layer_name = name if len(params) == 1 else params[1]
filepath = os.path.join(
checkpath,
sorted(os.listdir(checkpath), key=alphanum_key)[-1])
saved = mio.unpickle(filepath)
model_state = saved['model_state']
layer = model_state['layers'][layer_name]
if item_type == 'weights':
# weights
n_w = len(sp)
print ' init from convnet {}--------'.format(checkpath)
idx_list = range(n_w) if len(params) < 3 else iu.get_int_list_from_str(
params[2])
print ','.join(
['{}'.format(layer['weights'][k].shape) for k in idx_list])
print '--------------\n---------\n'
return [layer['weights'][k] for k in idx_list]
else:
return [layer['biases']]
def gbns(name, sp, params):
"""
get bias for combining norm and scale layer
params[0] = model_folder
params[1] = norm layer name [source]
params[2] = scale layer name [source]
"""
model_folder, norm_name, scale_name = params[0], params[1], params[2]
stat_folder = iu.fullfile(model_folder, 'stat')
stat_path = Solver.get_saved_model_path(stat_folder)
stat = mio.unpickle(stat_path)
model = Solver.get_saved_model(model_folder)
layers = get_layers(model)
W = layers[scale_name][2]['weights'][0]
b = layers[scale_name][2]['biases'][0]
print 'W-------------'
iu.print_common_statistics(W)
print 'b'
iu.print_common_statistics(b)
if 'epsilon' in layers[norm_name][2]:
epsilon = layers[norm_name][2]['epsilon']
else:
epsilon = 1e-6
u = stat['layers'][norm_name]['u'].flatten()
var = stat['layers'][norm_name]['var'].flatten()
return [b - W * u / (np.sqrt(var + epsilon))]
def test_tmp():
meta = mio.unpickle('/opt/visal/tmp/for_sijin/Data/H36M/H36MExp/folder_Raw_SP_t004_act_14/batches.meta')
f0, f2 = meta['feature_list'][0], meta['feature_list'][2]
print f0[..., 0]
diff = f0 - f2
print 'diff = {}'.format(diff.flatten().sum())
print '''
def parse_params(self, params):
DataProvider.parse_params(self, params)
if self.data_dic is None:
if 'data_path' in params:
self.data_dic = mio.unpickle(iu.fullfile(params['data_path'], 'batches.meta'))
else:
raise Exception('data-path is missing')
def parse_params(self, params):
DataProvider.parse_params(self, params)
if self.data_dic is None:
if 'data_path' in params:
self.data_dic = mio.unpickle(
iu.fullfile(params['data_path'], 'batches.meta'))
else:
raise Exception('data-path is missing')
def collect_feature(folder, item, re_exp='batch_feature_\w+$'):
allfile = sorted(iu.getfilelist(folder, re_exp), key=lambda x:extract_batch_num(x))
l = []
for f in allfile:
p = iu.fullfile(folder, f)
d = mio.unpickle(p)
l = l + [d[item]]
return np.concatenate(l, axis=1)
def test_tmp():
meta = mio.unpickle(
'/opt/visal/tmp/for_sijin/Data/H36M/H36MExp/folder_Raw_SP_t004_act_14/batches.meta'
)
f0, f2 = meta['feature_list'][0], meta['feature_list'][2]
print f0[..., 0]
diff = f0 - f2
print 'diff = {}'.format(diff.flatten().sum())
print '''
def verify_layer_outputs():
solver_loader = MMSolverLoader()
solver = solver_loader.parse()
net = solver.train_net
output_layers = net.get_layer_by_names(['net1_fc0'])
outputs = [lay.outputs for lay in output_layers]
f = theano.function(inputs=net.inputs,
outputs=outputs, on_unused_input='ignore')
cur_data = solver.get_next_batch(train=False)
mvd = solver.find_most_violated(cur_data, train=False)
alldata = [self.gpu_require(e.T) for e in most_violated_data[2][1:]]
res = f(alldata)
ref_meta = mio.unpickle('/opt/visal/tmp/for_sijin/Data/H36M/H36MExp/folder_SP_t004_act_14/batches.meta')
def show_bm_cmp_from_saved():
save_path = "/public/sijinli2/ibuffer/2015-01-22/saved_batch_data_test_net4_K_rbf_test"
save_path = "/public/sijinli2/ibuffer/2015-01-22/saved_batch_data_test_net4_K_rbf_correct_test"
d = mio.unpickle(save_path)
print d.keys()
bm_target, gt_score, mv_score, mv_target, gt_target, bm_score = (
d["bm_target"],
d["gt_score"],
d["mv_score"],
d["mv_target"],
d["gt_target"],
d["bm_score"],
)
ndata = bm_target.shape[-1]
bm_margin = MMLSSolver.calc_margin(gt_target - bm_target).flatten() * 1200
mv_margin = MMLSSolver.calc_margin(gt_target - mv_target).flatten() * 1200
# bm_rbf_margin = 1 - dutils.calc_RBF_score(gt_target - bm_target, 50/1200.0,3).flatten()
# mv_rbf_margin = 1 - dutils.calc_RBF_score(gt_target - mv_target, 50/1200.0,3).flatten()
# pl.ylabel('bm rbf margin')
# pl.xlabel('highest score rbf margin')
# pl.scatter(mv_rbf_margin, bm_rbf_margin, s=15, c='b')
# pl.show()
score_diff = mv_score - bm_score
pl.ylabel("score_diff")
pl.xlabel("mpjpe (bestmatch_pose, max_score_pose)")
pl.scatter(bm_margin, score_diff, s=15, c="b")
pl.show()
# show the scatter plot for mpjpe vs RBF score
residuals = (gt_target - bm_target) * 1200
bm_margin = bm_margin / 1200.0
t = 0
ncol = 4
sigma_list = [1, 5, 10, 20, 50, 100, 200, 500, 1000, 1500, 2000, 5000]
nrow = (len(sigma_list) - 1) // ncol + 1
# mm = np.max(bm_margin)
for r in range(nrow):
for c in range(ncol):
sigma = float(sigma_list[t])
t = t + 1
pl.subplot(nrow, ncol, t)
bm_rbf_score = 1 - dutils.calc_RBF_score(residuals, sigma)
pl.xlabel("mpjpe (bestmatch_pose, max_score_pose) ")
pl.ylabel("RBF sigma = {:.1f}".format(sigma))
pl.scatter(bm_margin, bm_rbf_score)
if t == len(sigma_list):
break
pl.show()
def create_dp2(train_ext_params=None, test_ext_params=None):
meta_path = "/opt/visal/tmp/for_sijin/Data/H36M/H36MExp/folder_SP_t004_act_14/batches.meta"
d = mio.unpickle(meta_path)
print "data format"
print_dims(d["feature_list"])
train_range = range(0, 132744)
test_range = range(132744, 162008)
params = {"batch_size": 1024, "data_path": meta_path}
train_params = merge_dic(params, train_ext_params)
test_params = merge_dic(params, test_ext_params)
pre_process_data(d)
train_dp = MemoryDataProvider(data_dic=d, train=True, data_range=train_range, params=train_params)
test_dp = MemoryDataProvider(d, train=False, data_range=test_range, params=test_params)
print "Create Data Provider Successfully"
return train_dp, test_dp
def show_bm_cmp_from_saved():
save_path = '/public/sijinli2/ibuffer/2015-01-22/saved_batch_data_test_net4_K_rbf_test'
save_path = '/public/sijinli2/ibuffer/2015-01-22/saved_batch_data_test_net4_K_rbf_correct_test'
d = mio.unpickle(save_path)
print d.keys()
bm_target, gt_score, mv_score, mv_target, gt_target, bm_score = d['bm_target'], \
d['gt_score'], \
d['mv_score'], \
d['mv_target'],\
d['gt_target'],\
d['bm_score']
ndata = bm_target.shape[-1]
bm_margin = MMLSSolver.calc_margin(gt_target - bm_target).flatten() * 1200
mv_margin = MMLSSolver.calc_margin(gt_target - mv_target).flatten() * 1200
# bm_rbf_margin = 1 - dutils.calc_RBF_score(gt_target - bm_target, 50/1200.0,3).flatten()
# mv_rbf_margin = 1 - dutils.calc_RBF_score(gt_target - mv_target, 50/1200.0,3).flatten()
# pl.ylabel('bm rbf margin')
# pl.xlabel('highest score rbf margin')
# pl.scatter(mv_rbf_margin, bm_rbf_margin, s=15, c='b')
# pl.show()
score_diff = mv_score - bm_score
pl.ylabel('score_diff')
pl.xlabel('mpjpe (bestmatch_pose, max_score_pose)')
pl.scatter(bm_margin, score_diff, s=15, c='b')
pl.show()
# show the scatter plot for mpjpe vs RBF score
residuals = (gt_target - bm_target) * 1200
bm_margin = bm_margin / 1200.0
t = 0
ncol = 4
sigma_list = [1, 5, 10, 20, 50, 100, 200, 500, 1000, 1500, 2000, 5000]
nrow = (len(sigma_list) - 1) // ncol + 1
# mm = np.max(bm_margin)
for r in range(nrow):
for c in range(ncol):
sigma = float(sigma_list[t])
t = t + 1
pl.subplot(nrow, ncol, t)
bm_rbf_score = 1 - dutils.calc_RBF_score(residuals, sigma)
pl.xlabel('mpjpe (bestmatch_pose, max_score_pose) ')
pl.ylabel('RBF sigma = {:.1f}'.format(sigma))
pl.scatter(bm_margin, bm_rbf_score)
if t == len(sigma_list):
break
pl.show()
def verify_layer_outputs():
solver_loader = MMSolverLoader()
solver = solver_loader.parse()
net = solver.train_net
output_layers = net.get_layer_by_names(['net1_fc0'])
outputs = [lay.outputs for lay in output_layers]
f = theano.function(inputs=net.inputs,
outputs=outputs,
on_unused_input='ignore')
cur_data = solver.get_next_batch(train=False)
mvd = solver.find_most_violated(cur_data, train=False)
alldata = [self.gpu_require(e.T) for e in most_violated_data[2][1:]]
res = f(alldata)
ref_meta = mio.unpickle(
'/opt/visal/tmp/for_sijin/Data/H36M/H36MExp/folder_SP_t004_act_14/batches.meta'
)
def __init__(self,
data_dir,
feature_range,
init_epoch=1,
init_batchnum=None,
dp_params={},
test=False):
DataProvider.__init__(self, data_dir, range(1), init_epoch,
init_batchnum, dp_params, test)
self.shuffle_data = dp_params[
'shuffle_data'] # determine whether to shuffle test data
if 'external_meta_path' in dp_params and dp_params[
'external_meta_path']:
import iread.myio as mio
ext_meta = mio.unpickle(dp_params['external_meta_path'])
print 'Print load external_meta for %s succussfully' % dp_params[
'external_meta_path']
for item in ext_meta:
self.batch_meta[item] = ext_meta[item]
print '----Load %s from ext_meta succussfully' % item
del ext_meta
self.test = test
self.feature_range = np.asarray(feature_range)
self.num_feature = len(feature_range)
self.batch_size = dp_params['batch_size']
self.keep_data_dic = False
if self.batch_size > self.num_feature or self.batch_size <= 0:
raise BasicDataProviderError(
'Invaid batch_size %d (num_image=%d)' %
(self.batch_size, self.num_feature))
self.num_batch = (self.num_feature - 1) / self.batch_size + 1
self.batch_range = range(self.num_feature)
if self.curr_batchnum not in self.batch_range:
self.curr_batchnum = 0
self.curr_batchnum = min(max(self.curr_batchnum, 0),
self.num_feature - 1)
self.batch_idx = self.curr_batchnum
if test and self.shuffle_data == 0:
# There is no need to shuffle testing data
self.shuffled_feature_range = self.feature_range
else:
self.shuffled_feature_range = self.feature_range[rd.permutation(
self.num_feature)]
self.num_feature_type = len(self.batch_meta['feature_dim'])
self.feature_dim = self.batch_meta['feature_dim']
def cvt1(source_exp_name, target_exp_name):
print '''
SP_t004_act_14:
source meta [rel_gt, img_feature_accv_fc_j0, relskel_feature_t004]
Raw_SP_t004_act_14:
target meta [rel_gt, img_feature_accv_fc_j0, rel_gt]
'''
base_path = '/opt/visal/tmp/for_sijin/Data/H36M/H36MExp/'
source_meta = mio.unpickle(iu.fullfile(base_path, 'folder_%s' % source_exp_name,
'batches.meta'))
target_meta_folder = iu.fullfile(base_path, 'folder_%s' % target_exp_name)
target_meta_path = iu.fullfile(target_meta_folder, 'batches.meta')
d = source_meta.copy()
print d.keys()
d['feature_list'] = [source_meta['feature_list'][k] for k in [0, 1, 0]]
d['feature_dim'] = [source_meta['feature_dim'][k] for k in [0, 1, 0]]
# print d['info']
print 'folder :{}\n path {}'.format(target_meta_folder, target_meta_path)
iu.ensure_dir(target_meta_folder)
mio.pickle(target_meta_path, d)
def cvt1(source_exp_name, target_exp_name):
print '''
SP_t004_act_14:
source meta [rel_gt, img_feature_accv_fc_j0, relskel_feature_t004]
Raw_SP_t004_act_14:
target meta [rel_gt, img_feature_accv_fc_j0, rel_gt]
'''
base_path = '/opt/visal/tmp/for_sijin/Data/H36M/H36MExp/'
source_meta = mio.unpickle(
iu.fullfile(base_path, 'folder_%s' % source_exp_name, 'batches.meta'))
target_meta_folder = iu.fullfile(base_path, 'folder_%s' % target_exp_name)
target_meta_path = iu.fullfile(target_meta_folder, 'batches.meta')
d = source_meta.copy()
print d.keys()
d['feature_list'] = [source_meta['feature_list'][k] for k in [0, 1, 0]]
d['feature_dim'] = [source_meta['feature_dim'][k] for k in [0, 1, 0]]
# print d['info']
print 'folder :{}\n path {}'.format(target_meta_folder, target_meta_path)
iu.ensure_dir(target_meta_folder)
mio.pickle(target_meta_path, d)
def create_dp2(train_ext_params=None, test_ext_params=None):
meta_path = '/opt/visal/tmp/for_sijin/Data/H36M/H36MExp/folder_SP_t004_act_14/batches.meta'
d = mio.unpickle(meta_path)
print 'data format'
print_dims(d['feature_list'])
train_range = range(0, 132744)
test_range = range(132744, 162008)
params = {'batch_size': 1024, 'data_path': meta_path}
train_params = merge_dic(params, train_ext_params)
test_params = merge_dic(params, test_ext_params)
pre_process_data(d)
train_dp = MemoryDataProvider(data_dic=d,
train=True,
data_range=train_range,
params=train_params)
test_dp = MemoryDataProvider(d,
train=False,
data_range=test_range,
params=test_params)
print 'Create Data Provider Successfully'
return train_dp, test_dp
def get_wb_from_convnet2_checkpoint(name, sp, params, item_type):
"""
params = [check_point_path, layer_name, ]
"""
sys.path.append('/home/grads/sijinli2/Projects/cuda-convnet2/')
checkpath= params[0]
layer_name= name if len(params) == 1 else params[1]
filepath = os.path.join(checkpath, sorted(os.listdir(checkpath), key=alphanum_key)[-1])
saved = mio.unpickle(filepath)
model_state = saved['model_state']
layer = model_state['layers'][layer_name]
if item_type == 'weights':
# weights
n_w = len(sp)
print ' init from convnet {}--------'.format(checkpath)
idx_list = range(n_w) if len(params) < 3 else iu.get_int_list_from_str(params[2])
print ','.join(['{}'.format(layer['weights'][k].shape) for k in idx_list])
print '--------------\n---------\n'
return [layer['weights'][k] for k in idx_list]
else:
return [layer['biases']]
def gwns(name, sp_list, params):
"""
get weights for combining norm and scale layer
params[0] = model_folder
params[1] = norm layer name [source]
params[2] = scale layer name [source]
"""
model_folder, norm_name, scale_name = params[0], params[1], params[2]
stat_folder = iu.fullfile(model_folder, 'stat')
stat_path = Solver.get_saved_model_path(stat_folder)
stat = mio.unpickle(stat_path)
print 'stat keys = {}'.format(stat['layers'].keys())
model = Solver.get_saved_model(model_folder)
layers = get_layers(model)
W= layers[scale_name][2]['weights']
if 'epsilon' in layers[norm_name][2]:
epsilon = layers[norm_name][2]['epsilon']
else:
epsilon = 1e-6
# u = stat['layers'][norm_name]['u'].flatten()
var = stat['layers'][norm_name]['var'].flatten()
return [W[0] / np.sqrt(var + epsilon)]
def create_dp(op, saved_model=None):
try:
if saved_model and 'dp_params' in saved_model['solver_params']:
dp_params = saved_model['solver_params']['dp_params']
else:
dp_params = None
required_fields = [
'data_path', 'data_provider', 'train_range', 'test_range',
'batch_size'
]
d = dict()
for e in required_fields:
if op.get_value(e):
d[e] = op.get_value(e)
else:
d[e] = dp_params[e]
except Exception as e:
print e
sys.exit(1)
meta = mio.unpickle(iu.fullfile(d['data_path'], 'batches.meta'))
param1, param2 = dict(), dict()
if saved_model:
copy_dic_by_key(param1, saved_model['model_state']['train'],
['epoch', 'batchnum'])
copy_dic_by_key(param2, saved_model['model_state']['test'],
['epoch', 'batchnum'])
copy_dic_by_key(param1, d, ['batch_size'])
copy_dic_by_key(param2, d, ['batch_size'])
dp_type = d['data_provider']
pre_process_data(meta) # < ---- This should be used with care
train_dp = dp_dic[dp_type](data_dic=meta,
train=True,
data_range=d['train_range'],
params=param1)
test_dp = dp_dic[dp_type](data_dic=meta,
train=False,
data_range=d['test_range'],
params=param2)
return d, train_dp, test_dp
def gwns(name, sp_list, params):
"""
get weights for combining norm and scale layer
params[0] = model_folder
params[1] = norm layer name [source]
params[2] = scale layer name [source]
"""
model_folder, norm_name, scale_name = params[0], params[1], params[2]
stat_folder = iu.fullfile(model_folder, 'stat')
stat_path = Solver.get_saved_model_path(stat_folder)
stat = mio.unpickle(stat_path)
print 'stat keys = {}'.format(stat['layers'].keys())
model = Solver.get_saved_model(model_folder)
layers = get_layers(model)
W = layers[scale_name][2]['weights']
if 'epsilon' in layers[norm_name][2]:
epsilon = layers[norm_name][2]['epsilon']
else:
epsilon = 1e-6
# u = stat['layers'][norm_name]['u'].flatten()
var = stat['layers'][norm_name]['var'].flatten()
return [W[0] / np.sqrt(var + epsilon)]
def show_the_most_violated_poses():
from mpl_toolkits.mplot3d import Axes3D
import imgproc
saved_model_path = '/public/sijinli2/ibuffer/2015-01-16/net2_test_for_stat'
saved_model_path = '/opt/visal/tmp/for_sijin/Data/saved/theano_models/FCJ0_act_14_graph_0029_test_norm_cumulate_update'
data_path = '/opt/visal/tmp/for_sijin/Data/H36M/H36MExp/folder_SP_t004_act_14/batches.meta'
meta = mio.unpickle(data_path)
all_pose = meta['feature_list'][0]
ssolver = Solver.get_saved_model(saved_model_path)
stat = ssolver['model_state']['stat']
cnt_sample = stat['sample_candidate_counts']
mvc = stat['most_violated_counts']
ntrain = cnt_sample.size
sorted_indexes = sorted(range(ntrain), key=lambda k: mvc[k], reverse=True)
show_num = int(144)
selected_indexes = sorted_indexes[:show_num]
max_show_row = int(16)
n_row = (show_num - 1) // max_show_row + 1
nc = 0
selected_pose = all_pose[:, selected_indexes]
limbs = h36m.part_idx
fig = pl.figure()
params = {'elev': -89, 'azim': -107, 'linewidth': 3}
selected_cnt = mvc[selected_indexes]
print n_row, max_show_row
for r in range(n_row):
for c in range(max_show_row):
if nc == show_num:
break
p = selected_pose[..., nc].reshape((3, 17), order='F').T
nc = nc + 1
# pl.subplot(n_row, max_show_row, c)
ax = fig.add_subplot(n_row, max_show_row, nc, projection='3d')
imgproc.turn_off_axis()
dutils.show_3d_skeleton(p, limbs, params)
pl.title('mvc={}'.format(selected_cnt[nc - 1]))
pl.show()
def show_the_most_violated_poses():
from mpl_toolkits.mplot3d import Axes3D
import imgproc
saved_model_path = '/public/sijinli2/ibuffer/2015-01-16/net2_test_for_stat'
saved_model_path = '/opt/visal/tmp/for_sijin/Data/saved/theano_models/FCJ0_act_14_graph_0029_test_norm_cumulate_update'
data_path = '/opt/visal/tmp/for_sijin/Data/H36M/H36MExp/folder_SP_t004_act_14/batches.meta'
meta = mio.unpickle(data_path)
all_pose = meta['feature_list'][0]
ssolver = Solver.get_saved_model(saved_model_path)
stat = ssolver['model_state']['stat']
cnt_sample = stat['sample_candidate_counts']
mvc = stat['most_violated_counts']
ntrain = cnt_sample.size
sorted_indexes = sorted(range(ntrain), key=lambda k: mvc[k], reverse=True)
show_num = int(144)
selected_indexes = sorted_indexes[:show_num]
max_show_row = int(16)
n_row = (show_num - 1)// max_show_row + 1
nc = 0
selected_pose = all_pose[:,selected_indexes]
limbs = h36m.part_idx
fig = pl.figure()
params = {'elev':-89, 'azim':-107, 'linewidth':3}
selected_cnt = mvc[selected_indexes]
print n_row, max_show_row
for r in range(n_row):
for c in range(max_show_row):
if nc == show_num:
break
p = selected_pose[...,nc].reshape((3,17),order='F').T
nc = nc + 1
# pl.subplot(n_row, max_show_row, c)
ax = fig.add_subplot(n_row, max_show_row, nc, projection='3d')
imgproc.turn_off_axis()
dutils.show_3d_skeleton(p, limbs, params)
pl.title('mvc={}'.format(selected_cnt[nc-1]))
pl.show()
def read_inputs():
d = mio.unpickle(
'/opt/visal/tmp/for_sijin/Data/H36M/H36MExp/folder_FCJ0_act_12/batches.meta'
)
info = d['info']
print info.keys()
indexes = info['indexes']
Y = d['feature_list'][0]
X = d['feature_list'][1]
train_range = range(0, 76048)
test_range = range(76048, 105368)
print min(indexes[train_range]), max(indexes[train_range])
print min(indexes[test_range]), max(indexes[test_range])
print 'X '
iu.print_common_statistics(X)
X_train = X[..., train_range]
Y_train = Y[..., train_range]
feature_dim = X_train.shape[0]
X_test = X[..., test_range]
Y_test = Y[..., test_range]
params = {'Sigma': np.ones(feature_dim + 1) * 0.0001}
r = LinearRegression(params)
r.fit(simpleDP(X_train, Y_train))
Y_pred = r.apply(X_test)
print Y_pred.shape
print Y_test[:5, :5]
print Y_pred[:5, :5]
diff = Y_test - Y_pred
print 'abs diff = {}'.format(np.sum(diff.flatten()**2))
mpjpe = dutils.calc_mpjpe_from_residual(diff, 17)
print 'average mpjpe {}'.format(np.mean(mpjpe.flatten()))
def process(op):
data_folder = op.get_value('load_file')
save_path = op.get_value('save_path')
# data_folder = '/public/sijinli2/ibuffer/2015-01-16/net2_test_for_stat_2000'
all_files = iu.getfilelist(data_folder, '\d+@\d+$')
print all_files
d = mio.unpickle(iu.fullfile(data_folder, all_files[0]))
ms = d['model_state']
if op.get_value('cost_name') is not None:
cost_names = op.get_value('cost_name').split(',')
n_cost = len(cost_name)
else:
n_cost = len(d['solver_params']['train_error'][0])
cost_names = d['solver_params']['train_error'][0].keys()
print 'Start to plot'
start_time = time()
for i in range(n_cost):
pl.subplot(n_cost, 1, i + 1)
plot_cost(op, d, cost_names[i])
print 'Cost {} seconds '.format(time() - start_time)
if save_path:
imgproc.imsave_tight(save_path)
pl.show()
def process(op):
data_folder = op.get_value('load_file')
save_path = op.get_value('save_path')
# data_folder = '/public/sijinli2/ibuffer/2015-01-16/net2_test_for_stat_2000'
all_files = iu.getfilelist(data_folder, '\d+@\d+$')
print all_files
d = mio.unpickle(iu.fullfile(data_folder, all_files[0]))
ms = d['model_state']
if op.get_value('cost_name') is not None:
cost_names = op.get_value('cost_name').split(',')
n_cost = len(cost_name)
else:
n_cost = len(d['solver_params']['train_error'][0])
cost_names = d['solver_params']['train_error'][0].keys()
print 'Start to plot'
start_time = time()
for i in range(n_cost):
pl.subplot(n_cost, 1, i + 1)
plot_cost(op, d, cost_names[i])
print 'Cost {} seconds '.format(time()- start_time)
if save_path:
imgproc.imsave_tight(save_path)
pl.show()
def read_inputs():
d = mio.unpickle('/opt/visal/tmp/for_sijin/Data/H36M/H36MExp/folder_FCJ0_act_12/batches.meta')
info = d['info']
print info.keys()
indexes = info['indexes']
Y = d['feature_list'][0]
X = d['feature_list'][1]
train_range = range(0,76048)
test_range = range(76048,105368)
print min(indexes[train_range]), max(indexes[train_range])
print min(indexes[test_range]), max(indexes[test_range])
print 'X '
iu.print_common_statistics(X)
X_train = X[..., train_range]
Y_train = Y[..., train_range]
feature_dim = X_train.shape[0]
X_test = X[..., test_range]
Y_test = Y[..., test_range]
params = {'Sigma':np.ones(feature_dim + 1) * 0.0001}
r = LinearRegression(params)
r.fit(simpleDP(X_train,Y_train))
Y_pred = r.apply(X_test)
print Y_pred.shape
print Y_test[:5,:5]
print Y_pred[:5,:5]
diff = Y_test - Y_pred
print 'abs diff = {}'.format(np.sum(diff.flatten()**2))
mpjpe = dutils.calc_mpjpe_from_residual(diff,17)
print 'average mpjpe {}'.format(np.mean(mpjpe.flatten()))
def __init__(self, data_dir, image_range, init_epoch=1, init_batchnum=None, dp_params={}, test=False):
DataProvider.__init__(self, data_dir, range(len(image_range)), init_epoch, init_batchnum, dp_params, test)
#crop_boarder will crop 2 * crop_boarder in each dimension
#padding is similar. It will pad both size, i.e., adding 2x pixels
self.image_dim = np.asarray(self.batch_meta['image_adjust_dim']).flatten()
if dp_params['crop_border'] > 0:
self.input_image_dim = self.batch_meta['image_adjust_dim']
self.input_image_dim[0] -= dp_params['crop_border'] * 2
self.input_image_dim[1] -= dp_params['crop_border'] * 2
elif dp_params['crop_one_border'] > 0:
self.input_image_dim = self.batch_meta['image_adjust_dim']
self.input_image_dim[0] -= dp_params['crop_one_border']
self.input_image_dim[1] -= dp_params['crop_one_border']
else:
self.input_image_dim = self.batch_meta['image_sample_dim']
if 'fix_num_batch' in dp_params:
# It can be used for forcing the number of batch to be fixed
# The last batch might be smaller than previous batch
self.fix_num_batch = dp_params['fix_num_batch']
else:
self.fix_num_batch = False
self.shuffle_data = dp_params['shuffle_data'] # determine whether to shuffle test data
if 'external_meta_path' in dp_params and dp_params['external_meta_path']:
import iread.myio as mio
ext_meta = mio.unpickle(dp_params['external_meta_path'])
print 'Print load external_meta for %s succussfully' % dp_params['external_meta_path']
override_dic = ['mean_image', 'cropped_mean_image', 'rgb_eigenvalue', \
'rgb_eigenvector', 'RelativeSkel_Y3d_mono_body', \
'Relative_Y3d_mono_body']
for item in override_dic:
if item in ext_meta:
self.batch_meta[item] = ext_meta[item]
print '----Load %s from ext_meta succussfully' % item
del ext_meta
self.mean_image = self.batch_meta['mean_image']
self.cropped_mean_image = self.get_cropped_mean()
self.rgb_eigenvalue = self.batch_meta['rgb_eigenvalue']
self.rgb_eigenvector = self.batch_meta['rgb_eigenvector']
self.test = test
self.image_range = np.asarray(image_range)
self.num_image = len(image_range)
self.batch_size = dp_params['batch_size']
self.keep_data_dic = False
if self.batch_size > self.num_image or self.batch_size <= 0:
raise BasicDataProviderError('Invaid batch_size %d (num_image=%d)' % (self.batch_size, self.num_image))
self.num_batch = (self.num_image - 1)/ self.batch_size + 1
# override batch_range, this is not actually the batch_range
# just keep consistent
self.batch_range = range(self.num_image)
# recheck curr_batchnum
# (Remembering last times' batch_num will not help training), just keep batch consistant
if self.curr_batchnum not in self.batch_range:
self.curr_batchnum = 0
self.curr_batchnum = min(max(self.curr_batchnum, 0), self.num_image - 1)
# print 'Curr_batchnum = %d Test = %s' % (self.curr_batchnum, 'True' if self.test else 'False')
# override batch_Idx
self.batch_idx = self.curr_batchnum
if test and (not self.shuffle_data):
# There is no need to shuffle testing data
self.shuffled_image_range = self.image_range
else:
self.shuffled_image_range = self.image_range[rd.permutation(self.num_image)]
if 'images_path' in self.batch_meta:
self.images_path = self.batch_meta['images_path']
else:
self.images_path = None
from init_test import *
import dhmlpe_utils as dutils
import iutils as iu
import scipy.io as sio
import iread.myio as mio
cutils = dutils.Cutils()
dskels = sio.loadmat(
'/opt/visal/data/H36/H36MData/SLP/data/AngleSamples/skel2.mat')
skel = dskels['skel']
print dskels.keys()
dpose = mio.unpickle(
'/opt/visal/tmp/for_sijin/Data/H36M/H36MExp/folder_ASM_act_14_exp_2/batches.meta'
)
gt_pose = dpose['Relative_Y3d_mono_body']
print gt_pose.shape
dangle = sio.loadmat(
'/opt/visal/data/H36/H36MData/SLP/data/AngleSamples/ASM_act_14_angles.mat')
print dangle.keys()
print dangle['angles_range'].shape
t = dangle['angles_range'].flatten()
print max(t), min(t)
print dangle['angles'].shape
gt_angle = dangle['angles'][0, :, :]
[g_pose, g_rot] = cutils.convert_angle2(skel, gt_angle)
from init_test import *
import dhmlpe_utils as dutils
import iutils as iu
import scipy.io as sio
import iread.myio as mio
cutils = dutils.Cutils()
dskels = sio.loadmat('/opt/visal/data/H36/H36MData/SLP/data/AngleSamples/skel2.mat')
skel = dskels['skel']
print dskels.keys()
dpose = mio.unpickle('/opt/visal/tmp/for_sijin/Data/H36M/H36MExp/folder_ASM_act_14_exp_2/batches.meta')
gt_pose = dpose['Relative_Y3d_mono_body']
print gt_pose.shape
dangle = sio.loadmat('/opt/visal/data/H36/H36MData/SLP/data/AngleSamples/ASM_act_14_angles.mat')
print dangle.keys()
print dangle['angles_range'].shape
t = dangle['angles_range'].flatten()
print max(t), min(t)
print dangle['angles'].shape
gt_angle = dangle['angles'][0,:,:]
[g_pose,g_rot] = cutils.convert_angle2(skel, gt_angle)
def __init__(self,
data_dir,
image_range,
init_epoch=1,
init_batchnum=None,
dp_params={},
test=False):
DataProvider.__init__(self, data_dir, range(1), init_epoch,
init_batchnum, dp_params, test)
#crop_boarder will crop 2 * crop_boarder in each dimension
#padding is similar. It will pad both size, i.e., adding 2x pixels
self.image_dim = np.asarray(
self.batch_meta['image_adjust_dim']).flatten()
if dp_params['crop_border'] > 0:
self.input_image_dim = self.batch_meta['image_adjust_dim']
self.input_image_dim[0] -= dp_params['crop_border'] * 2
self.input_image_dim[1] -= dp_params['crop_border'] * 2
elif dp_params['crop_one_border'] > 0:
self.input_image_dim = self.batch_meta['image_adjust_dim']
self.input_image_dim[0] -= dp_params['crop_one_border']
self.input_image_dim[1] -= dp_params['crop_one_border']
else:
self.input_image_dim = self.batch_meta['image_sample_dim']
self.shuffle_data = dp_params[
'shuffle_data'] # determine whether to shuffle test data
if 'external_meta_path' in dp_params and dp_params[
'external_meta_path']:
import iread.myio as mio
ext_meta = mio.unpickle(dp_params['external_meta_path'])
print 'Print load external_meta for %s succussfully' % dp_params[
'external_meta_path']
override_dic = ['mean_image', 'cropped_mean_image', 'rgb_eigenvalue', \
'rgb_eigenvector', 'RelativeSkel_Y3d_mono_body', \
'Relative_Y3d_mono_body']
for item in override_dic:
if item in ext_meta:
self.batch_meta[item] = ext_meta[item]
print '----Load %s from ext_meta succussfully' % item
del ext_meta
self.mean_image = self.batch_meta['mean_image']
self.cropped_mean_image = self.get_cropped_mean()
self.rgb_eigenvalue = self.batch_meta['rgb_eigenvalue']
self.rgb_eigenvector = self.batch_meta['rgb_eigenvector']
self.test = test
self.image_range = np.asarray(image_range)
self.num_image = len(image_range)
self.batch_size = dp_params['batch_size']
self.keep_data_dic = False
if self.batch_size > self.num_image or self.batch_size <= 0:
raise BasicDataProviderError(
'Invaid batch_size %d (num_image=%d)' %
(self.batch_size, self.num_image))
self.num_batch = (self.num_image - 1) / self.batch_size + 1
# override batch_range, this is not actually the batch_range
# just keep consistent
self.batch_range = range(self.num_image)
# recheck curr_batchnum
# (Remembering last times' batch_num will not help training), just keep batch consistant
if self.curr_batchnum not in self.batch_range:
self.curr_batchnum = 0
self.curr_batchnum = min(max(self.curr_batchnum, 0),
self.num_image - 1)
# print 'Curr_batchnum = %d Test = %s' % (self.curr_batchnum, 'True' if self.test else 'False')
# override batch_Idx
self.batch_idx = self.curr_batchnum
if test and self.shuffle_data == 0:
# There is no need to shuffle testing data
self.shuffled_image_range = self.image_range
else:
self.shuffled_image_range = self.image_range[rd.permutation(
self.num_image)]
if 'images_path' in self.batch_meta:
self.images_path = self.batch_meta['images_path']
else:
self.images_path = None
