def train_leaf_kin_mdl_single(self, num_strk, strk_idx, tree_idx, leaf_idx):
"""
A tool method to retrain kinematics parameters for a given node
For fixing some invalid parameters from the bug of rxzero_train after batch training
"""
#extract tmp_mdl
tmp_mdl = None
if self.model_ is not None:
if num_strk in self.model_:
if strk_idx < len(self.model_[num_strk]):
tmp_mdl = self.model_[num_strk][strk_idx]
if tmp_mdl is not None:
if 'samples_dict' in tmp_mdl and 'kinparms_dict' in tmp_mdl:
if (tree_idx, leaf_idx) in tmp_mdl['samples_dict']:
d = tmp_mdl['samples_dict'][tree_idx, leaf_idx]
if len(d) > 1:
mean_sample = np.mean(d, axis=0)
mean_traj = np.reshape(mean_sample, (2, -1)).transpose()
kin_parms = pytkrxz.rxzero_train(mean_traj, verbose=False)
tmp_mdl['kinparms_dict'][tree_idx, leaf_idx] = [mean_traj[0, :], kin_parms]
else:
print 'Only one sample, no need to train.'
else:
print 'No specified tree or leaf index, please check the structure.'
else:
print 'No samples or kinematics parameters found... Not trained yet?'
return
def extend_data_with_lognormal_sampling_helper(char_traj, n_samples, shift_mean):
#the input char_traj is flattened with the last entry as the time, get the 2D form
data_len = (len(char_traj) - 1)/2
t_idx = np.linspace(0, 1.0, data_len)
#is it necessary to also have noise on this?
x0 = char_traj[0]
y0 = char_traj[data_len]
pos_traj = np.array([char_traj[:data_len], char_traj[data_len:-1]]).T
#estimate the lognormal parms
lognorm_parms = np.array(pytk_rz.rxzero_train(pos_traj))
if np.any(np.isinf(lognorm_parms)):
print 'Unable to extract lognormal parameters. Only use the original trajectory.'
return []
n_comps = len(lognorm_parms)
#generate noise for each components, considering amplitude (+-20%), start angle(+-20 deg) and straightness(+-10% difference)
ang_difference = lognorm_parms[:, 5] - lognorm_parms[:, 4]
noises = np.random.randn(n_samples, n_comps, 3) / 3 #white noise to ensure 99.7% samples are within the specified range...
parm_noises = np.array([ np.array([noise[:, 0]*.2*lognorm_parms[:, 0], np.zeros(n_comps), np.zeros(n_comps), np.zeros(n_comps),
noise[:, 1]*np.pi/9, noise[:, 1]*np.pi/9 + noise[:, 2]*.1*ang_difference]).T for noise in noises])
perturbed_parms = np.array([lognorm_parms + parm_noise for parm_noise in parm_noises])
#apply the noise, remember to flatten and put back the phase scale...
res_char_trajs = [np.concatenate([pytk_rz.rxzero_traj_eval(perturbed_parm, t_idx, x0, y0)[0].T.flatten(), [char_traj[-1]]]) for perturbed_parm in perturbed_parms]
if shift_mean:
mean_coords = [np.mean(np.reshape(traj[:-1], (2, -1)).T, axis=0) for traj in res_char_trajs]
for d_idx in range(len(res_char_trajs)):
data_len = (len(res_char_trajs[d_idx]) - 1)/2
res_char_trajs[d_idx][0:data_len] -= mean_coords[d_idx][0]
res_char_trajs[d_idx][data_len:-1] -= mean_coords[d_idx][1]
return res_char_trajs
def train(self, pos_traj):
#extract parameters from given position trajectory
#pos_traj: an array of 2D position coordinates
#get a series of t idx
# vel_profile = self.get_vel_profile(pos_traj)
# reg_pnts = vel_profile_registration(vel_profile)
#<hyin/Feb-09-2015> use rxzero, though a not complete version...
parms, reg_pnts = pyrzx.rxzero_train(pos_traj, getregpnts=True)
self.mdl_parms_ = parms
return parms, reg_pnts
def train_leaf_kin_mdl(self, tmp_rf_mdl):
#construct kinematics model for each leaf, then the synthesis can be done on the kinematics parm space
#prepare a model for each leaf node
kinparms_by_node = defaultdict(list)
for k, d in tmp_rf_mdl['samples_dict'].iteritems():
tree_idx, leaf_idx = k
print 'The leaf contains {0} samples'.format(len(d))
print 'Training kinematics model for tree {0} and leaf node {1}'.format(tree_idx, leaf_idx)
if len(d) > 1:
#extract mean trajectory
mean_sample = np.mean(d, axis=0)
mean_traj = np.reshape(mean_sample, (2, -1)).transpose()
kin_parms = pytkrxz.rxzero_train(mean_traj, global_opt_itrs=1, verbose=False)
kinparms_by_node[tree_idx, leaf_idx] = [mean_traj[0, :], kin_parms]
tmp_rf_mdl['kinparms_dict'] = kinparms_by_node
#to learn the variability of kinematics parameters if possible
return
def trajkin_parm_exploration_to_fit_template(self, sample, template):
#detect improvement suggestion in the span of kinematics feature space
#first extract kinematics for the sample
recons_sample = []
strk_parms_lst = []
fit_parms_lst = []
adjusted_comp = []
adjusted_comp_idx = []
print sample
for strk_idx, strk in enumerate(sample):
print '================================='
print 'For stroke ', strk_idx
print '================================='
t_array = np.linspace(0, 1.0, len(strk))
strk_parms = pytkrxz.rxzero_train(strk, global_opt_itrs=1)
strk_parms_lst.append(strk_parms)
eval_traj, eval_vel = pytkrxz.rxzero_traj_eval(strk_parms, t_array, strk[0, 0], strk[0, 1])
#<hyin/Jun-8th-2015> try another direction, fit the full parameters to the template
# free_comp_idx = range(len(strk_parms))
# fit_parms = pytkrxz.fit_parm_component_with_global_optimization(template[strk_idx], strk_parms, free_comp_idx=free_comp_idx, maxIters=1)
# comp_modulation_lst = []
# recons_parms_lst = []
# for comp_idx, parm_comp in enumerate(strk_parms):
# print 'Examining component ', comp_idx
# recons_parms = [parm for parm in fit_parms[0]]
# # print recons_parms, comp_idx, parm_comp
# recons_parms[comp_idx] = parm_comp
# recons_parms_lst.append(recons_parms)
# comp_modulation_lst.append(np.sum(np.abs(parm_comp-fit_parms[0][comp_idx])))
# # recons_err_comp_lst.append(recons_err)
# # find the smallest one
# significant_comp_idx = np.argmax(comp_modulation_lst)
# print 'The most significant component: ', significant_comp_idx
# print comp_modulation_lst[significant_comp_idx]
# print recons_parms_lst[significant_comp_idx]
# recons_eval_traj, recons_eval_vel = pytkrxz.rxzero_traj_eval(recons_parms_lst[significant_comp_idx], t_array,
# template[strk_idx][0, 0], template[strk_idx][0, 1])
# # strk[0, 0], strk[0, 1])
# recons_sample.append(recons_eval_traj)
# adjusted_comp.append([recons_parms_lst[significant_comp_idx]])
# adjusted_comp_idx.append(significant_comp_idx)
# recons_sample.append(eval_traj)
#call the global optimization in rxzero to see how can we fit the template by modulating the extracted parameters
# fit_parms = pytkrxz.rxzero_global_optimization(template[strk_idx], strk_parms, dt=0.01, maxIters=1)
# fit_parms_lst.append(fit_parms)
# fit_eval_traj, fit_eval_vel = pytkrxz.rxzero_traj_eval(fit_parms, t_array, strk[0, 0], strk[0, 1])
# # recons_sample.append(fit_eval_traj)
#for this stroke, see which component can lead us to a better reconstruction towards the template
recons_err_comp_lst = []
comp_modulation_lst = []
if len(strk_parms) == 1:
#only one component...
print 'Examining the only components'
opt_parms, recons_err = pytkrxz.fit_parm_component_with_global_optimization(template[strk_idx], strk_parms, free_comp_idx=[[0]], maxIters=1)
# opt_parms, recons_err = pytkrxz.fit_parm_scale_ang_component_with_global_optimization(template[strk_idx], strk_parms, free_comp_idx=[[0]], maxIters=1)
comp_modulation_lst.append(opt_parms)
recons_err_comp_lst.append(recons_err)
significant_comp_idx = np.argmin(recons_err_comp_lst)
print 'The only significant components: ', significant_comp_idx, significant_comp_idx+1
print comp_modulation_lst[significant_comp_idx]
recons_eval_traj, recons_eval_vel = pytkrxz.rxzero_traj_eval(comp_modulation_lst[significant_comp_idx], t_array,
template[strk_idx][0, 0], template[strk_idx][0, 1])
# strk[0, 0], strk[0, 1])
recons_sample.append(recons_eval_traj)
adjusted_comp.append(comp_modulation_lst[significant_comp_idx])
adjusted_comp_idx.append([significant_comp_idx])
else:
for comp_idx, parm_comp in enumerate(strk_parms[:-1]):
print 'Examining components ', comp_idx, comp_idx+1
free_comp_idx = [[comp_idx], [comp_idx+1]]
opt_parms, recons_err = pytkrxz.fit_parm_component_with_global_optimization(template[strk_idx], strk_parms, free_comp_idx=free_comp_idx, maxIters=1)
# opt_parms, recons_err = pytkrxz.fit_parm_scale_ang_component_with_global_optimization(template[strk_idx], strk_parms, free_comp_idx=free_comp_idx, maxIters=1)
comp_modulation_lst.append(opt_parms)
recons_err_comp_lst.append(recons_err)
# find the smallest one
significant_comp_idx = np.argmin(recons_err_comp_lst)
print 'The most significant components: ', significant_comp_idx, significant_comp_idx+1
print comp_modulation_lst[significant_comp_idx]
recons_eval_traj, recons_eval_vel = pytkrxz.rxzero_traj_eval(comp_modulation_lst[significant_comp_idx], t_array,
template[strk_idx][0, 0], template[strk_idx][0, 1])
# strk[0, 0], strk[0, 1])
recons_sample.append(recons_eval_traj)
adjusted_comp.append(comp_modulation_lst[significant_comp_idx])
adjusted_comp_idx.append([significant_comp_idx, significant_comp_idx+1])
# #blend these parms to see if this would give us meaningful instructions...
# comb_parms_lst = []
# replace_strk_idx = [0]
# replace_comp_idx = [0]
# comb_recons_sample = []
# for strk_idx, strk_parms in enumerate(strk_parms_lst):
# t_array = np.linspace(0, 1.0, len(sample[strk_idx]))
# comb_strk_parms = []
# for comp_idx, strk_parm_comp in enumerate(strk_parms):
# if strk_idx in replace_strk_idx and comp_idx in replace_comp_idx:
# print 'replace...'
# comb_strk_parms.append(fit_parms_lst[strk_idx][comp_idx])
# else:
# comb_strk_parms.append(strk_parm_comp)
# #evaluate comb trajectory
# comb_eval_traj, comb_eval_vel = pytkrxz.rxzero_traj_eval(comb_strk_parms, t_array, strk[0, 0], strk[0, 1])
# comb_recons_sample.append(comb_eval_traj)
# comb_parms_lst.append(comb_strk_parms)
return strk_parms_lst, recons_sample, adjusted_comp, adjusted_comp_idx
def trajkin_parm_exploration_to_fit_template(self, sample, template):
#detect improvement suggestion in the span of kinematics feature space
#first extract kinematics for the sample
recons_sample = []
strk_parms_lst = []
fit_parms_lst = []
adjusted_comp = []
adjusted_comp_idx = []
print sample
for strk_idx, strk in enumerate(sample):
print '================================='
print 'For stroke ', strk_idx
print '================================='
t_array = np.linspace(0, 1.0, len(strk))
strk_parms = pytkrxz.rxzero_train(strk, global_opt_itrs=1)
strk_parms_lst.append(strk_parms)
eval_traj, eval_vel = pytkrxz.rxzero_traj_eval(
strk_parms, t_array, strk[0, 0], strk[0, 1])
#<hyin/Jun-8th-2015> try another direction, fit the full parameters to the template
# free_comp_idx = range(len(strk_parms))
# fit_parms = pytkrxz.fit_parm_component_with_global_optimization(template[strk_idx], strk_parms, free_comp_idx=free_comp_idx, maxIters=1)
# comp_modulation_lst = []
# recons_parms_lst = []
# for comp_idx, parm_comp in enumerate(strk_parms):
# print 'Examining component ', comp_idx
# recons_parms = [parm for parm in fit_parms[0]]
# # print recons_parms, comp_idx, parm_comp
# recons_parms[comp_idx] = parm_comp
# recons_parms_lst.append(recons_parms)
# comp_modulation_lst.append(np.sum(np.abs(parm_comp-fit_parms[0][comp_idx])))
# # recons_err_comp_lst.append(recons_err)
# # find the smallest one
# significant_comp_idx = np.argmax(comp_modulation_lst)
# print 'The most significant component: ', significant_comp_idx
# print comp_modulation_lst[significant_comp_idx]
# print recons_parms_lst[significant_comp_idx]
# recons_eval_traj, recons_eval_vel = pytkrxz.rxzero_traj_eval(recons_parms_lst[significant_comp_idx], t_array,
# template[strk_idx][0, 0], template[strk_idx][0, 1])
# # strk[0, 0], strk[0, 1])
# recons_sample.append(recons_eval_traj)
# adjusted_comp.append([recons_parms_lst[significant_comp_idx]])
# adjusted_comp_idx.append(significant_comp_idx)
# recons_sample.append(eval_traj)
#call the global optimization in rxzero to see how can we fit the template by modulating the extracted parameters
# fit_parms = pytkrxz.rxzero_global_optimization(template[strk_idx], strk_parms, dt=0.01, maxIters=1)
# fit_parms_lst.append(fit_parms)
# fit_eval_traj, fit_eval_vel = pytkrxz.rxzero_traj_eval(fit_parms, t_array, strk[0, 0], strk[0, 1])
# # recons_sample.append(fit_eval_traj)
#for this stroke, see which component can lead us to a better reconstruction towards the template
recons_err_comp_lst = []
comp_modulation_lst = []
if len(strk_parms) == 1:
#only one component...
print 'Examining the only components'
opt_parms, recons_err = pytkrxz.fit_parm_component_with_global_optimization(
template[strk_idx],
strk_parms,
free_comp_idx=[[0]],
maxIters=1)
# opt_parms, recons_err = pytkrxz.fit_parm_scale_ang_component_with_global_optimization(template[strk_idx], strk_parms, free_comp_idx=[[0]], maxIters=1)
comp_modulation_lst.append(opt_parms)
recons_err_comp_lst.append(recons_err)
significant_comp_idx = np.argmin(recons_err_comp_lst)
print 'The only significant components: ', significant_comp_idx, significant_comp_idx + 1
print comp_modulation_lst[significant_comp_idx]
recons_eval_traj, recons_eval_vel = pytkrxz.rxzero_traj_eval(
comp_modulation_lst[significant_comp_idx], t_array,
template[strk_idx][0, 0], template[strk_idx][0, 1])
# strk[0, 0], strk[0, 1])
recons_sample.append(recons_eval_traj)
adjusted_comp.append(comp_modulation_lst[significant_comp_idx])
adjusted_comp_idx.append([significant_comp_idx])
else:
for comp_idx, parm_comp in enumerate(strk_parms[:-1]):
print 'Examining components ', comp_idx, comp_idx + 1
free_comp_idx = [[comp_idx], [comp_idx + 1]]
opt_parms, recons_err = pytkrxz.fit_parm_component_with_global_optimization(
template[strk_idx],
strk_parms,
free_comp_idx=free_comp_idx,
maxIters=1)
# opt_parms, recons_err = pytkrxz.fit_parm_scale_ang_component_with_global_optimization(template[strk_idx], strk_parms, free_comp_idx=free_comp_idx, maxIters=1)
comp_modulation_lst.append(opt_parms)
recons_err_comp_lst.append(recons_err)
# find the smallest one
significant_comp_idx = np.argmin(recons_err_comp_lst)
print 'The most significant components: ', significant_comp_idx, significant_comp_idx + 1
print comp_modulation_lst[significant_comp_idx]
recons_eval_traj, recons_eval_vel = pytkrxz.rxzero_traj_eval(
comp_modulation_lst[significant_comp_idx], t_array,
template[strk_idx][0, 0], template[strk_idx][0, 1])
# strk[0, 0], strk[0, 1])
recons_sample.append(recons_eval_traj)
adjusted_comp.append(comp_modulation_lst[significant_comp_idx])
adjusted_comp_idx.append(
[significant_comp_idx, significant_comp_idx + 1])
# #blend these parms to see if this would give us meaningful instructions...
# comb_parms_lst = []
# replace_strk_idx = [0]
# replace_comp_idx = [0]
# comb_recons_sample = []
# for strk_idx, strk_parms in enumerate(strk_parms_lst):
# t_array = np.linspace(0, 1.0, len(sample[strk_idx]))
# comb_strk_parms = []
# for comp_idx, strk_parm_comp in enumerate(strk_parms):
# if strk_idx in replace_strk_idx and comp_idx in replace_comp_idx:
# print 'replace...'
# comb_strk_parms.append(fit_parms_lst[strk_idx][comp_idx])
# else:
# comb_strk_parms.append(strk_parm_comp)
# #evaluate comb trajectory
# comb_eval_traj, comb_eval_vel = pytkrxz.rxzero_traj_eval(comb_strk_parms, t_array, strk[0, 0], strk[0, 1])
# comb_recons_sample.append(comb_eval_traj)
# comb_parms_lst.append(comb_strk_parms)
return strk_parms_lst, recons_sample, adjusted_comp, adjusted_comp_idx
