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