def test_data(sess, X, Y, index_list, S_list, R_L_list, F_list, e, pre_test, n_batches): LStateList_F_t = ut.get_zero_state(params) LStateList_F_pre = ut.get_zero_state(params) LStateList_K_t = ut.get_zero_state(params, t='K') LStateList_K_pre = ut.get_zero_state(params, t='K') state_reset_counter_lst = [0 for i in range(batch_size)] total_loss = 0.0 total_n_count = 0.0 for minibatch_index in xrange(n_batches): state_reset_counter_lst = [s + 1 for s in state_reset_counter_lst] (LStateList_F_pre,LStateList_K_pre,_,x,y,r,f,state_reset_counter_lst)=\ dut.prepare_kfl_QRFf_batch(index_list, minibatch_index, batch_size, S_list, LStateList_F_t, LStateList_F_pre, LStateList_K_t, LStateList_K_pre, None, None, params, Y, X, R_L_list,F_list,state_reset_counter_lst) gt = y mes = x # print(r) feed = { tracker._z: mes, tracker.target_data: gt, tracker.repeat_data: r, tracker.initial_state: LStateList_F_pre, tracker.initial_state_Q_noise: LStateList_K_pre, tracker.output_keep_prob: 1 } # feed = {tracker._z: mes, tracker.target_data: gt, tracker.initial_state: LStateList_F_pre # , tracker._P_inp: P, tracker._I: I} LStateList_F_t,LStateList_K_t,final_output,y = \ sess.run([tracker.final_state_F,tracker.final_state_K, tracker.final_output,tracker.y], feed) tmp_lst = [] for item in LStateList_F_t: tmp_lst.append(item.c) tmp_lst.append(item.h) LStateList_F_t = tmp_lst tmp_lst = [] for item in LStateList_K_t: tmp_lst.append(item.c) tmp_lst.append(item.h) LStateList_K_t = tmp_lst # print(y) # print(y.shape) # print(final_output.shape) if params["normalise_data"] == 3 or params["normalise_data"] == 2: final_output = ut.unNormalizeData(final_output, params["y_men"], params["y_std"]) y = ut.unNormalizeData(y, params["y_men"], params["y_std"]) test_loss, n_count = ut.get_loss(params, gt=y, est=final_output) total_loss += test_loss * n_count total_n_count += n_count # if (minibatch_index%show_every==0): # print pre_test+" test batch loss: (%i / %i / %i) %f"%(e,minibatch_index,n_train_batches,test_loss) total_loss = total_loss / total_n_count s = pre_test + ' Loss --> epoch %i | error %f' % (e, total_loss) ut.log_write(s, params) return total_loss
def test_data(sess,params,X,Y,index_list,S_list,R_L_list,F_list,e, pre_test,n_batches): is_test=1 dic_state=ut.get_state_list(params) I= np.asarray([np.diag([1.0]*params['n_output']) for i in range(params["batch_size"])],dtype=np.float32) params["reset_state"]=-1 #Never reset state_reset_counter_lst=[0 for i in range(batch_size)] total_loss=0.0 total_pred_loss=0.0 total_meas_loss=0.0 total_n_count=0.0 for minibatch_index in xrange(n_batches): state_reset_counter_lst=[s+1 for s in state_reset_counter_lst] # print state_reset_counter_lst (dic_state,x,y,r,f,_,state_reset_counter_lst,_)= \ th.prepare_batch(is_test,index_list, minibatch_index, batch_size, S_list, dic_state, params, Y, X, R_L_list,F_list,state_reset_counter_lst) feed=th.get_feed(Model,params,r,x,y,I,dic_state, is_training=0) states,final_output,final_pred_output,final_meas_output,y =sess.run([Model.states,Model.final_output,Model.final_pred_output,Model.final_meas_output,Model.y], feed) for k in states.keys(): dic_state[k] = states[k] if params["normalise_data"]==3 or params["normalise_data"]==2: final_output=ut.unNormalizeData(final_output,params["y_men"],params["y_std"]) final_pred_output=ut.unNormalizeData(final_pred_output,params["y_men"],params["y_std"]) final_meas_output=ut.unNormalizeData(final_meas_output,params["x_men"],params["x_std"]) y=ut.unNormalizeData(y,params["y_men"],params["y_std"]) if params["normalise_data"]==4: final_output=ut.unNormalizeData(final_output,params["x_men"],params["x_std"]) final_pred_output=ut.unNormalizeData(final_pred_output,params["x_men"],params["x_std"]) final_meas_output=ut.unNormalizeData(final_meas_output,params["x_men"],params["x_std"]) y=ut.unNormalizeData(y,params["x_men"],params["x_std"]) test_loss,n_count=ut.get_loss(params,gt=y,est=final_output,r=r) test_pred_loss,n_count=ut.get_loss(params,gt=y,est=final_pred_output,r=r) test_meas_loss,n_count=ut.get_loss(params,gt=y,est=final_meas_output,r=r) total_loss+=test_loss*n_count total_pred_loss+=test_pred_loss*n_count total_meas_loss+=test_meas_loss*n_count total_n_count+=n_count # if (minibatch_index%show_every==0): # print pre_test+" test batch loss: (%i / %i / %i) %f"%(e,minibatch_index,n_train_batches,test_loss) total_loss=total_loss/total_n_count total_pred_loss=total_pred_loss/total_n_count total_meas_loss=total_meas_loss/total_n_count s =pre_test+' Loss --> epoch %i | error %f, %f, %f'%(e,total_loss,total_pred_loss,total_meas_loss) ut.log_write(s,params) return total_loss
def test_data(sess, params, X, Y, index_list, S_list, R_L_list, F_list, e, pre_test, n_batches): dic_state = ut.get_state_list(params) I = np.asarray([ np.diag([1.0] * params['n_output']) for i in range(params["batch_size"]) ], dtype=np.float32) dict_err = {} dict_name = {} uniq_lst = [item for item in collections.Counter(S_list)] is_test = 1 file_lst = [] for u in uniq_lst: idx = np.where(S_list == u) sname = F_list[idx][0][0][0].split('/')[-2] dict_name[u] = sname dict_err[u] = [] state_reset_counter_lst = [0 for i in range(batch_size)] total_loss = 0.0 total_n_count = 0.0 full_curr_id_lst = [] full_noise_lst = [] full_r_lst = [] full_y_lst = [] full_final_output_lst = [] for minibatch_index in xrange(n_batches): state_reset_counter_lst = [s + 1 for s in state_reset_counter_lst] (dic_state,x_sel,y,r,f,curr_sid,state_reset_counter_lst,curr_id_lst)= \ th.prepare_batch(is_test,index_list, minibatch_index, batch_size, S_list, dic_state, params, Y, X, R_L_list,F_list,state_reset_counter_lst) feed = th.get_feed(tracker, params, r, x_sel, y, I, dic_state, is_training=0) if params["model"] == "lstm": states, final_output, sel_y = sess.run( [tracker.states, tracker.final_output, tracker.y], feed) else: states,final_output,full_final_output,sel_y,x,qnoise_lst =\ sess.run([tracker.states,tracker.final_output,tracker.full_final_output,tracker.y,tracker.x,tracker.qnoise_lst], feed) full_final_output = np.asarray(full_final_output).reshape( (batch_size, params['seq_length'], params['n_output'])) for k in states.keys(): dic_state[k] = states[k] full_curr_id_lst.extend(curr_id_lst) full_r_lst.extend(r) file_lst.extend(f) full_final_output_lst.extend(full_final_output) full_y_lst.extend(y) if params["model"] != "lstm": full_noise_lst.extend(qnoise_lst) # total_loss=total_loss/total_n_count index_lst = sh.get_nondublicate_lst(full_curr_id_lst) full_r_lst = np.asarray(full_r_lst)[index_lst] # if params["model"] != "lstm": # full_noise_lst=np.asarray(full_noise_lst)[index_lst] # full_noise_lst=full_noise_lst[full_r_lst==1] full_final_output_lst = np.asarray(full_final_output_lst)[index_lst] full_y_lst = np.asarray(full_y_lst)[index_lst] file_lst = np.asarray(file_lst)[index_lst] file_lst = file_lst[full_r_lst == 1] full_final_output_lst = full_final_output_lst[full_r_lst == 1] full_y_lst = full_y_lst[full_r_lst == 1] dict_err = {} if params["normalise_data"] == 3 or params["normalise_data"] == 2: full_final_output_lst = ut.unNormalizeData(full_final_output_lst, params["y_men"], params["y_std"]) full_y_lst = ut.unNormalizeData(full_y_lst, params["y_men"], params["y_std"]) if params["normalise_data"] == 4: full_final_output_lst = ut.unNormalizeData(full_final_output_lst, params["x_men"], params["x_std"]) full_y_lst = ut.unNormalizeData(full_y_lst, params["x_men"], params["x_std"]) full_loss, dict_err = sh.get_loss(file_lst, gt=full_y_lst, est=full_final_output_lst) # np.savetxt('trials/garb/x',np.asarray(x_lst)) if params["sequence"] == "David": for u in dict_err.keys(): seq_err = dict_err[u] median_result = np.median(seq_err, axis=0) mean_result = np.mean(seq_err, axis=0) print 'Epoch:', e, ' full ', u, ' median/mean error ', median_result[ 0], '/', mean_result[0], 'm and ', median_result[ 1], '/', mean_result[1], 'degrees.' else: median_result = np.median(full_loss, axis=0) mean_result = np.mean(full_loss, axis=0) if params["data_mode"] == "xyx": print 'Epoch:', e, ' full sequence median/mean error ', median_result[ 0], '/', mean_result[0], '' elif params["data_mode"] == "q": print 'Epoch:', e, ' full sequence median/mean error ', median_result[ 0], '/', mean_result[0], 'degrees.' else: print 'Epoch:', e, ' full sequence median/mean error ', median_result[ 0], '/', mean_result[0], 'm and ', median_result[ 1], '/', mean_result[1], 'degrees.' # s =pre_test+' Loss --> epoch %i | error %f'%(e,total_loss) # ut.log_write(s,params) return total_loss, median_result, mean_result, full_final_output_lst, file_lst, full_noise_lst
def test_data(sess, params, X, Y, index_list, S_list, R_L_list, F_list, e, pre_test, n_batches): dic_state = ut.get_state_list(params) I = np.asarray([ np.diag([1.0] * params['n_output']) for i in range(params["batch_size"]) ], dtype=np.float32) is_test = 1 state_reset_counter_lst = [0 for i in range(batch_size)] total_loss = 0.0 total_n_count = 0.0 for minibatch_index in xrange(n_batches): state_reset_counter_lst = [s + 1 for s in state_reset_counter_lst] (dic_state,x,y,r,f,_,state_reset_counter_lst,_)= \ th.prepare_batch(is_test,index_list, minibatch_index, batch_size, S_list, dic_state, params, Y, X, R_L_list,F_list,state_reset_counter_lst) feed = th.get_feed(tracker, params, r, x, y, I, dic_state, is_training=0) if mode == 'klstm': states,final_output,final_pred_output,final_meas_output,q_mat,r_mat,k_mat,y =\ sess.run([tracker.states,tracker.final_output,tracker.final_pred_output,tracker.final_meas_output, tracker.final_q_output,tracker.final_r_output,tracker.final_k_output,tracker.y], feed) else: states, final_output, y = \ sess.run([tracker.states, tracker.final_output, tracker.y], feed) for k in states.keys(): dic_state[k] = states[k] if params["normalise_data"] == 3 or params["normalise_data"] == 2: final_output = ut.unNormalizeData(final_output, params["y_men"], params["y_std"]) y = ut.unNormalizeData(y, params["y_men"], params["y_std"]) if params["normalise_data"] == 4: final_output = ut.unNormalizeData(final_output, params["x_men"], params["x_std"]) y = ut.unNormalizeData(y, params["x_men"], params["x_std"]) if mode == 'klstm': final_pred_output = ut.unNormalizeData(final_pred_output, params["x_men"], params["x_std"]) final_meas_output = ut.unNormalizeData(final_meas_output, params["x_men"], params["x_std"]) test_loss, n_count = ut.get_loss(params, gt=y, est=final_output, r=None) f = f.reshape((-1, 2)) y_f = y.reshape(final_output.shape) r = r.flatten() fnames = f[np.nonzero(r)] # e=final_output[np.nonzero(r)] if mode == 'klstm': ut.write_est(est_file=params["est_file"] + "/kal_est/", est=final_output, file_names=fnames) ut.write_est(est_file=params["est_file"] + "/kal_est_dif/", est=np.abs(final_output - y_f), file_names=fnames) ut.write_est(est_file=params["est_file"] + "/kal_pred/", est=final_pred_output, file_names=fnames) ut.write_est(est_file=params["est_file"] + "/kal_pred_dif/", est=np.abs(final_pred_output - y_f), file_names=fnames) ut.write_est(est_file=params["est_file"] + "/meas/", est=final_meas_output, file_names=fnames) ut.write_est(est_file=params["est_file"] + "/q_mat/", est=q_mat, file_names=fnames) ut.write_est(est_file=params["est_file"] + "/r_mat/", est=r_mat, file_names=fnames) ut.write_est(est_file=params["est_file"] + "/k_mat/", est=k_mat, file_names=fnames) ut.write_est(est_file=params["est_file"] + "/y_f/", est=y_f, file_names=fnames) else: ut.write_est(est_file=params["est_file"], est=final_output, file_names=fnames) # print test/_loss total_loss += test_loss * n_count total_n_count += n_count print total_loss / total_n_count # if (minibatch_index%show_every==0): # print pre_test+" test batch loss: (%i / %i / %i) %f"%(e,minibatch_index,n_train_batches,test_loss) total_loss = total_loss / total_n_count s = pre_test + ' Loss --> epoch %i | error %f' % (e, total_loss) ut.log_write(s, params) return total_loss