def vad_test3(m_eval, sess_eval, batch_size_eval, eval_file_dir, norm_dir, data_len, eval_type): eval_input_dir = eval_file_dir eval_output_dir = eval_file_dir + '/Labels' pad_size = batch_size_eval - data_len % batch_size_eval eval_data_set = dr3.DataReader(eval_input_dir, eval_output_dir, norm_dir, w=5, u=9, name="eval2") final_softout, final_label = evaluation(m_eval, eval_data_set, sess_eval, batch_size_eval, eval_type) return final_softout, final_label
def do_test(fname_model, test_file_dir, norm_dir, data_len, is_default, model_type): eval_input_dir = test_file_dir eval_output_dir = test_file_dir + '/Labels' graph = load_graph(fname_model) w = 19 u = 9 # [print(n.name) for n in graph.as_graph_def().node] # for op in graph.get_operations(): # print(op.name) final_softout = [] final_label = [] if model_type == 0: # acam import data_reader_bDNN_v2 as dr print(os.path.abspath('./configure/ACAM')) sys.path.insert(0, os.path.abspath('./configure/ACAM')) import config as cg if is_default: w = 19 u = 9 valid_batch_size = 4096 else: w = cg.w u = cg.u valid_batch_size = cg.batch_size valid_data_set = dr.DataReader(eval_input_dir, eval_output_dir, norm_dir, w=w, u=u, name="eval") node_inputs = graph.get_tensor_by_name('prefix/model_1/inputs:0') node_labels = graph.get_tensor_by_name('prefix/model_1/labels:0') node_keep_probability = graph.get_tensor_by_name( 'prefix/model_1/keep_probabilty:0') node_logits = graph.get_tensor_by_name('prefix/model_1/logits:0') node_raw_labels = graph.get_tensor_by_name( 'prefix/model_1/raw_labels:0') while True: valid_inputs, valid_labels = valid_data_set.next_batch( valid_batch_size) feed_dict = { node_inputs: valid_inputs, node_labels: valid_labels, node_keep_probability: 1 } if valid_data_set.eof_checker(): final_softout = np.reshape(np.asarray(final_softout), [-1, 1]) final_label = np.reshape(np.asarray(final_label), [-1, 1]) valid_data_set.reader_initialize() # print('Valid data reader was initialized!') # initialize eof flag & num_file & start index break with tf.Session(graph=graph) as sess: logits, raw_labels = sess.run([node_logits, node_raw_labels], feed_dict=feed_dict) soft_pred = bdnn_prediction(valid_batch_size, logits, threshold=0.6, w=w, u=u)[1] raw_labels = raw_labels.reshape((-1, 1)) final_softout.append(soft_pred) final_label.append(raw_labels) # if valid_data_set.eof_checker(): # final_softout = np.reshape(np.asarray(final_softout), [-1, 1]) # final_label = np.reshape(np.asarray(final_label), [-1, 1]) # valid_data_set.reader_initialize() # # print('Valid data reader was initialized!') # initialize eof flag & num_file & start index # break return final_softout[0:data_len, :], final_label[0:data_len, :] if model_type == 1: # bdnn import data_reader_bDNN_v2 as dr print(os.path.abspath('./configure/bDNN')) sys.path.insert(0, os.path.abspath('./configure/bDNN')) import config as cg if is_default: w = 19 u = 9 valid_batch_size = 4096 else: w = cg.w u = cg.u valid_batch_size = cg.batch_size valid_data_set = dr.DataReader( eval_input_dir, eval_output_dir, norm_dir, w=w, u=u, name="eval") # training data reader initialization node_inputs = graph.get_tensor_by_name('prefix/model_1/inputs:0') node_labels = graph.get_tensor_by_name('prefix/model_1/labels:0') node_keep_probability = graph.get_tensor_by_name( 'prefix/model_1/keep_probabilty:0') node_logits = graph.get_tensor_by_name('prefix/model_1/logits:0') while True: valid_inputs, valid_labels = valid_data_set.next_batch( valid_batch_size) feed_dict = { node_inputs: valid_inputs, node_labels: valid_labels, node_keep_probability: 1 } if valid_data_set.eof_checker(): final_softout = np.reshape(np.asarray(final_softout), [-1, 1]) final_label = np.reshape(np.asarray(final_label), [-1, 1]) valid_data_set.reader_initialize() # print('Valid data reader was initialized!') # initialize eof flag & num_file & start index break with tf.Session(graph=graph) as sess: logits, labels = sess.run([node_logits, node_labels], feed_dict=feed_dict) soft_pred = bdnn_prediction(valid_batch_size, logits, threshold=0.6, w=w, u=u)[1] raw_indx = int(np.floor(labels.shape[1] / 2)) raw_labels = labels[:, raw_indx] raw_labels = raw_labels.reshape((-1, 1)) final_softout.append(soft_pred) final_label.append(raw_labels) return final_softout[0:data_len, :], final_label[0:data_len, :] if model_type == 2: # dnn import data_reader_DNN_v2 as dnn_dr print(os.path.abspath('./configure/DNN')) sys.path.insert(0, os.path.abspath('./configure/DNN')) import config as cg if is_default: w = 19 u = 9 valid_batch_size = 4096 else: w = cg.w u = cg.u valid_batch_size = cg.batch_size valid_data_set = dnn_dr.DataReader(eval_input_dir, eval_output_dir, norm_dir, w=w, u=u, name="eval") node_inputs = graph.get_tensor_by_name('prefix/model_1/inputs:0') node_labels = graph.get_tensor_by_name('prefix/model_1/labels:0') node_keep_probability = graph.get_tensor_by_name( 'prefix/model_1/keep_probabilty:0') node_softpred = graph.get_tensor_by_name('prefix/model_1/soft_pred:0') node_raw_labels = graph.get_tensor_by_name( 'prefix/model_1/raw_labels:0') while True: valid_inputs, valid_labels = valid_data_set.next_batch( valid_batch_size) one_hot_labels = valid_labels.reshape((-1, 1)) one_hot_labels = utils.dense_to_one_hot(one_hot_labels, num_classes=2) feed_dict = { node_inputs: valid_inputs, node_labels: one_hot_labels, node_keep_probability: 1 } if valid_data_set.eof_checker(): final_softout = np.reshape(np.asarray(final_softout), [-1, 1]) final_label = np.reshape(np.asarray(final_label), [-1, 1]) valid_data_set.reader_initialize() # print('Valid data reader was initialized!') # initialize eof flag & num_file & start index break print("aa") session_conf = tf.ConfigProto(device_count={ 'CPU': 1, 'GPU': 0 }, allow_soft_placement=True, log_device_placement=False) with tf.Session(graph=graph, config=session_conf) as sess: soft_pred, raw_labels = sess.run( [node_softpred, node_raw_labels], feed_dict=feed_dict) raw_labels = raw_labels.reshape((-1, 1)) final_softout.append(soft_pred) final_label.append(raw_labels) return final_softout[0:data_len, :], final_label[0:data_len, :] if model_type == 3: # lstm import data_reader_RNN as rnn_dr print(os.path.abspath('./configure/LSTM')) sys.path.insert(0, os.path.abspath('./configure/LSTM')) import config as cg if is_default: target_delay = 5 seq_size = 20 batch_num = 200 valid_batch_size = seq_size * batch_num else: target_delay = cg.target_delay seq_size = cg.seq_len batch_num = cg.num_batches valid_batch_size = seq_size * batch_num valid_data_set = rnn_dr.DataReader(eval_input_dir, eval_output_dir, norm_dir, target_delay=target_delay, name="eval") node_inputs = graph.get_tensor_by_name('prefix/model_1/inputs:0') node_labels = graph.get_tensor_by_name('prefix/model_1/labels:0') node_keep_probability = graph.get_tensor_by_name( 'prefix/model_1/keep_probabilty:0') node_softpred = graph.get_tensor_by_name('prefix/model_1/soft_pred:0') node_raw_labels = graph.get_tensor_by_name( 'prefix/model_1/raw_labels:0') while True: valid_inputs, valid_labels = valid_data_set.next_batch( valid_batch_size) one_hot_labels = valid_labels.reshape((-1, 1)) one_hot_labels = utils.dense_to_one_hot(one_hot_labels, num_classes=2) feed_dict = { node_inputs: valid_inputs, node_labels: one_hot_labels, node_keep_probability: 1 } if valid_data_set.eof_checker(): final_softout = np.reshape(np.asarray(final_softout), [-1, 1]) final_label = np.reshape(np.asarray(final_label), [-1, 1]) valid_data_set.reader_initialize() # print('Valid data reader was initialized!') # initialize eof flag & num_file & start index break with tf.Session(graph=graph) as sess: soft_pred, raw_labels = sess.run( [node_softpred, node_raw_labels], feed_dict=feed_dict) raw_labels = raw_labels.reshape((-1, 1)) final_softout.append(soft_pred) final_label.append(raw_labels) # if valid_data_set.eof_checker(): # final_softout = np.reshape(np.asarray(final_softout), [-1, 1]) # final_label = np.reshape(np.asarray(final_label), [-1, 1]) # valid_data_set.reader_initialize() # # print('Valid data reader was initialized!') # initialize eof flag & num_file & start index # break return final_softout[0:data_len, :], final_label[0:data_len, :]
def main(save_dir, prj_dir=None, model=None, mode=None, dev="/gpu:2"): # Configuration Part # # os.environ["CUDA_VISIBLE_DEVICES"] = '3' device = dev os.environ["CUDA_VISIBLE_DEVICES"] = device[-1] if mode is 'train': import path_setting as ps set_path = ps.PathSetting(prj_dir, model,save_dir) logs_dir = initial_logs_dir = set_path.logs_dir input_dir = set_path.input_dir output_dir = set_path.output_dir norm_dir = set_path.norm_dir valid_file_dir = set_path.valid_file_dir sys.path.insert(0, prj_dir+'/configure/LSTM') import config as cg global seq_size, batch_num seq_size = cg.seq_len batch_num = cg.num_batches global learning_rate, dropout_rate, max_epoch, batch_size, valid_batch_size learning_rate = cg.lr dropout_rate = cg.dropout_rate max_epoch = cg.max_epoch batch_size = valid_batch_size = batch_num*seq_size global target_delay target_delay = cg.target_delay global lstm_cell_size, num_layers lstm_cell_size = cg.cell_size num_layers = cg.num_layers # Graph Part # print("Graph initialization...") with tf.device(device): with tf.variable_scope("model", reuse=None): m_train = Model(is_training=True) with tf.variable_scope("model", reuse=True): m_valid = Model(is_training=False) print("Done") # Summary Part # print("Setting up summary op...") summary_ph = tf.placeholder(dtype=tf.float32) with tf.variable_scope("Training_procedure"): cost_summary_op = tf.summary.scalar("cost", summary_ph) accuracy_summary_op = tf.summary.scalar("accuracy", summary_ph) print("Done") # Model Save Part # print("Setting up Saver...") saver = tf.train.Saver() ckpt = tf.train.get_checkpoint_state(logs_dir) print("Done") # Session Part # sess_config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False) sess_config.gpu_options.allow_growth = True sess = tf.Session(config=sess_config) if mode is 'train': train_summary_writer = tf.summary.FileWriter(logs_dir + '/train/', sess.graph, max_queue=2) valid_summary_writer = tf.summary.FileWriter(logs_dir + '/valid/', max_queue=2) if ckpt and ckpt.model_checkpoint_path: # model restore print("Model restored...") if mode is 'train': saver.restore(sess, ckpt.model_checkpoint_path) else: saver.restore(sess, initial_logs_dir+ckpt_name) # saver.restore(sess, logs_dir+ckpt_name) saver.save(sess, logs_dir + "/model_LSTM.ckpt", 0) # model save print("Done") else: sess.run(tf.global_variables_initializer()) # if the checkpoint doesn't exist, do initialization if mode is 'train': train_data_set = dr.DataReader(input_dir, output_dir, norm_dir, target_delay=target_delay, u=u, name="train") # training data reader initialization if mode is 'train': file_len = train_data_set.get_file_len() MAX_STEP = max_epoch * file_len print(get_num_params()) for itr in range(MAX_STEP): train_inputs, train_labels = train_data_set.next_batch(seq_size) one_hot_labels = train_labels.reshape((-1, 1)) one_hot_labels = dense_to_one_hot(one_hot_labels, num_classes=2) feed_dict = {m_train.inputs: train_inputs, m_train.labels: one_hot_labels, m_train.keep_probability: dropout_rate} sess.run(m_train.train_op, feed_dict=feed_dict) if itr % 100 == 0 and itr >= 0: train_cost, train_accuracy, train_rate, train_pre = sess.run([m_train.cost, m_train.accuracy, m_train.lr, m_train.pred], feed_dict=feed_dict) # print(logits) print("Step: %d, train_cost: %.4f, train_accuracy=%4.4f lr=%.8f" % (itr, train_cost, train_accuracy*100, train_rate)) pass train_cost_summary_str = sess.run(cost_summary_op, feed_dict={summary_ph: train_cost}) train_accuracy_summary_str = sess.run(accuracy_summary_op, feed_dict={summary_ph: train_accuracy}) train_summary_writer.add_summary(train_cost_summary_str, itr) # write the train phase summary to event files train_summary_writer.add_summary(train_accuracy_summary_str, itr) if itr % file_len == 0 and itr > 0: saver.save(sess, logs_dir + "/model.ckpt", itr) # model save print('validation start!') valid_accuracy, valid_cost = \ utils.do_validation(m_valid, sess, valid_file_dir, norm_dir, type='LSTM') print("valid_cost: %.4f, valid_accuracy=%4.4f" % (valid_cost, valid_accuracy * 100)) valid_cost_summary_str = sess.run(cost_summary_op, feed_dict={summary_ph: valid_cost}) valid_accuracy_summary_str = sess.run(accuracy_summary_op, feed_dict={summary_ph: valid_accuracy}) valid_summary_writer.add_summary(valid_cost_summary_str, itr) # write the train phase summary to event files valid_summary_writer.add_summary(valid_accuracy_summary_str, itr) gs.freeze_graph(prj_dir + '/logs/LSTM', prj_dir + '/saved_model/graph/LSTM', 'model_1/soft_pred,model_1/raw_labels') elif mode is 'test': final_softout, final_label = utils.vad_test3(m_valid, sess, valid_batch_size, test_file_dir, norm_dir, data_len, eval_type) if data_len is None: return final_softout, final_label else: return final_softout[0:data_len, :], final_label[0:data_len, :]
def full_evaluation(m_eval, sess_eval, batch_size_eval, eval_file_dir, summary_writer, summary_dic, itr): mean_cost = [] mean_accuracy = [] mean_auc = [] mean_time = [] print("-------- Performance for each of noise types --------") noise_list = os.listdir(eval_file_dir) noise_list = sorted(noise_list) summary_ph = summary_dic["summary_ph"] for i in range(len(noise_list)): print("full time evaluation, now loading : %d",i) noise_name = '/' + noise_list[i] eval_input_dir = eval_file_dir + noise_name eval_output_dir = eval_file_dir + noise_name + '/Labels' ########################################## eval_calc_dir = eval_file_dir + noise_name + '/test_result' # for Final layer information saving ########################################## eval_data_set = dr.DataReader(eval_input_dir, eval_output_dir, norm_dir, target_delay=target_delay, u=u, name="eval") eval_cost, eval_accuracy, eval_list, eval_auc, auc_list, eval_time = evaluation(m_eval, eval_data_set, sess_eval, batch_size_eval, noise_list[i], save_dir = eval_calc_dir) print("--noise type : " + noise_list[i]) print("cost: %.3f, accuracy across all SNRs: %.3f, auc across all SNRs: %.3f " % (eval_cost, eval_accuracy, eval_auc)) print('accuracy wrt SNR:') print('SNR_-5 : %.3f, SNR_0 : %.3f, SNR_5 : %.3f, SNR_10 : %.3f' % (eval_list[0], eval_list[1], eval_list[2], eval_list[3])) print('AUC wrt SNR:') print('SNR_-5 : %.3f, SNR_0 : %.3f, SNR_5 : %.3f, SNR_10 : %.3f' % (auc_list[0], auc_list[1], auc_list[2], auc_list[3])) eval_summary_list = [eval_cost] + eval_list + [eval_accuracy] + [eval_auc] for j, summary_name in enumerate(summary_list): summary_str = sess_eval.run(summary_dic[noise_list[i]+"_"+summary_name], feed_dict={summary_ph: eval_summary_list[j]}) summary_writer.add_summary(summary_str, itr) mean_cost.append(eval_cost) mean_accuracy.append(eval_accuracy) mean_auc.append(eval_auc) mean_time.append(eval_time) mean_cost = np.mean(np.asarray(mean_cost)) var_accuracy = np.var(np.asarray(mean_accuracy)) mean_accuracy = np.mean(np.asarray(mean_accuracy)) mean_auc = np.mean(np.asarray(mean_auc)) mean_time = np.mean(np.asarray(mean_time)) summary_writer.add_summary(sess_eval.run(summary_dic["cost_across_all_noise_types"], feed_dict={summary_ph: mean_cost}), itr) summary_writer.add_summary(sess_eval.run(summary_dic["accuracy_across_all_noise_types"], feed_dict={summary_ph: mean_accuracy}), itr) summary_writer.add_summary(sess_eval.run(summary_dic["variance_across_all_noise_types"], feed_dict={summary_ph: var_accuracy}), itr) summary_writer.add_summary(sess_eval.run(summary_dic["AUC_across_all_noise_types"], feed_dict={summary_ph: mean_auc}), itr) print("-------- Performance across all of noise types --------") print("cost : %.3f" % mean_cost) print("******* averaged accuracy across all noise_types : %.3f *******" % mean_accuracy) print("******* variance of accuracies across all noise_types : %6.6f *******" % var_accuracy) print("******* variance of AUC across all noise_types : %6.6f *******" % mean_auc) print("******* mean time : %6.6f *******" % mean_time) return mean_auc
def main(save_dir, prj_dir=None, model=None, mode=None, dev="/gpu:2"): device = dev os.environ["CUDA_VISIBLE_DEVICES"] = device[-1] import path_setting as ps set_path = ps.PathSetting(prj_dir, model, save_dir) logs_dir = initial_logs_dir = set_path.logs_dir input_dir = set_path.input_dir output_dir = set_path.output_dir norm_dir = set_path.norm_dir valid_file_dir = set_path.valid_file_dir sys.path.insert(0, prj_dir + '/configure/LSTM') import config as cg global seq_size, batch_num seq_size = cg.seq_len batch_num = cg.num_batches global learning_rate, dropout_rate, max_epoch, batch_size, valid_batch_size learning_rate = cg.lr dropout_rate = cg.dropout_rate max_epoch = cg.max_epoch batch_size = valid_batch_size = batch_num * seq_size global target_delay target_delay = cg.target_delay global lstm_cell_size, num_layers lstm_cell_size = cg.cell_size num_layers = cg.num_layers print("Graph initialization...") with tf.device(device): with tf.variable_scope("model", reuse=None): m_train = Model(is_training=True) with tf.variable_scope("model", reuse=True): m_valid = Model(is_training=False) print("Done") print("Setting up Saver...") saver = tf.train.Saver() ckpt = tf.train.get_checkpoint_state(logs_dir) print("Done") sess_config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False) sess_config.gpu_options.allow_growth = True sess = tf.Session(config=sess_config) if ckpt and ckpt.model_checkpoint_path: # model restore print("Model restored...") if mode is 'train': saver.restore(sess, ckpt.model_checkpoint_path) else: saver.restore(sess, initial_logs_dir + ckpt_name) saver.save(sess, logs_dir + "/model_LSTM.ckpt", 0) # model save print("Done") train_data_set = dr.DataReader(input_dir, output_dir, norm_dir, target_delay=target_delay, u=u, name="train") if mode is 'train': file_len = train_data_set.get_file_len() acc_sum = 0 tp_sum = 0 tn_sum = 0 fp_sum = 0 fn_sum = 0 frame_num = 0 for itr in range(file_len): train_inputs, train_labels = train_data_set.next_batch(seq_size) one_hot_labels = train_labels.reshape((-1, 1)) one_hot_labels = dense_to_one_hot(one_hot_labels, num_classes=2) feed_dict = { m_train.inputs: train_inputs, m_train.labels: one_hot_labels, m_train.keep_probability: dropout_rate } train_accuracy, train_pre, raw_label = sess.run( [m_train.accuracy, m_train.pre, m_train.raw_labels], feed_dict=feed_dict) frame_s = len(train_pre) frame_num += len(train_pre) tn = 0 tp = 0 fp = 0 fn = 0 for i in range(len(train_pre)): if train_pre[i] == 0 and raw_label[i] == 0: tn += 1 elif train_pre[i] == 0 and raw_label[i] == 1: fn += 1 elif train_pre[i] == 1 and raw_label[i] == 0: fp += 1 elif train_pre[i] == 1 and raw_label[i] == 1: tp += 1 acc_sum += train_accuracy tn_sum += tn tp_sum += tp fp_sum += fp fn_sum += fn # if train_accuracy <= 0.7: # file_name = train_data_set.get_cur_file_name().split('/')[-1] # obj_name = file_name.split('.')[0] # wav_path = "/mnt/E_DRIVE/TIMIT_echo_noisy/train/low" # shutil.copy("/mnt/E_DRIVE/TIMIT_echo_noisy/train/"+obj_name+'.wav', wav_path) # np.save(os.path.join("/mnt/E_DRIVE/TIMIT_echo_noisy/train/low", obj_name+'.label.npy'), original_label(train_pre,"/mnt/E_DRIVE/TIMIT_echo_noisy/train/"+obj_name+'.wav')) print("Step: %d/%d, train_accuracy=%4.4f" % (file_len, itr, train_accuracy * 100)) # print("path is "+train_data_set.get_cur_file_name()) print( "true_positive: %f, false positive: %f, true negative: %f, false negative: %f" % (tp / frame_s, fp / frame_s, tn / frame_s, fn / frame_s)) # valid_file_reader = dr.DataReader(valid_file_dir+'/feature_mrcg', valid_file_dir+'/label', norm_dir, target_delay = target_delay, u=u, name="train") # valid_len = valid_file_reader.get_file_len() # valid_accuracy, valid_cost = utils.do_validation(m_valid, sess, valid_file_dir, norm_dir, type='LSTM') # total_acc = (valid_accuracy*valid_len+acc_sum)/(valid_len+file_len) total_acc = acc_sum / file_len print("valid_accuracy=%4.4f" % (total_acc * 100)) print( "total: true_positive: %f, false positive: %f, true negative: %f, false negative: %f" % (tp_sum / frame_num, fp_sum / frame_num, tn_sum / frame_num, fn_sum / frame_num))
def do_test(fname_model, test_file_dir, norm_dir, prj_dir, is_default, model_type): eval_input_dir = test_file_dir graph = load_graph(fname_model) w = 19 u = 9 # [print(n.name) for n in graph.as_graph_def().node] # for op in graph.get_operations(): # print(op.name) final_softout = [] final_label = [] if model_type == 0: # acam import data_reader_bDNN_v2 as dr print(prj_dir + '/configure/ACAM') sys.path.insert(0, os.path.abspath(prj_dir + 'ACAM')) # import config as cg # # if is_default: # w = 19 # u = 9 # valid_batch_size = 4096 # else: # w = cg.w # u = cg.u # valid_batch_size = cg.batch_size valid_data_set = dr.DataReader(eval_input_dir + "/train/feature_mrcg", eval_input_dir + "/train/label", norm_dir, w=w, u=u, name="eval") node_inputs = graph.get_tensor_by_name('prefix/model_1/inputs:0') node_labels = graph.get_tensor_by_name('prefix/model_1/labels:0') node_keep_probability = graph.get_tensor_by_name( 'prefix/model_1/keep_probabilty:0') node_logits = graph.get_tensor_by_name('prefix/model_1/logits:0') node_raw_labels = graph.get_tensor_by_name( 'prefix/model_1/raw_labels:0') acc_sum = 0 file_num = 0 acc_sum = 0 tp_sum = 0 tn_sum = 0 fp_sum = 0 fn_sum = 0 frame_num = 0 while True: valid_inputs, valid_labels = valid_data_set.next_batch(7) feed_dict = { node_inputs: valid_inputs, node_labels: valid_labels, node_keep_probability: 1 } if valid_data_set.eof_checker(): final_softout = np.reshape(np.asarray(final_softout), [-1, 1]) final_label = np.reshape(np.asarray(final_label), [-1, 1]) valid_data_set.reader_initialize() # print('Valid data reader was initialized!') # initialize eof flag & num_file & start index break with tf.Session(graph=graph) as sess: logits, raw_labels = sess.run([node_logits, node_raw_labels], feed_dict=feed_dict) raw_labels = raw_labels.reshape((-1, 1)) soft_pred = bdnn_prediction(len(raw_labels), logits, threshold=0.6, w=w, u=u)[0] eql = (raw_labels == soft_pred) acc = np.mean(eql) acc_sum += acc file_num += 1 frame_s = len(raw_labels) frame_num += len(raw_labels) tn = 0 tp = 0 fp = 0 fn = 0 for i in range(len(soft_pred)): if soft_pred[i] == 0 and raw_labels[i] == 0: tn += 1 elif soft_pred[i] == 0 and raw_labels[i] == 1: fn += 1 elif soft_pred[i] == 1 and raw_labels[i] == 0: fp += 1 elif soft_pred[i] == 1 and raw_labels[i] == 1: tp += 1 final_softout.append(soft_pred) final_label.append(raw_labels) tn_sum += tn tp_sum += tp fn_sum += fn fp_sum += fp # if acc <= 0.7: # file_name =valid_data_set.get_cur_file_name().split('/')[-1] # obj_name = file_name.split('.')[0] # wav_path = "/mnt/E_DRIVE/Lipr_with_label/train/low" # shutil.copy("/mnt/E_DRIVE/Lipr_with_label/train/" + obj_name + '.wav', wav_path) # np.save(os.path.join("/mnt/E_DRIVE/Lipr_with_label/train/low", obj_name + '.label.npy'), # original_label(soft_pred, "/mnt/E_DRIVE/Lipr_with_label/train/" + obj_name + '.wav')) print(" train_accuracy=%4.4f" % (acc * 100)) # print("path is " + valid_data_set.get_cur_file_name()) print( "true_positive: %f, false positive: %f, true negative: %f, false negative: %f" % (tp / frame_s, fp / frame_s, tn / frame_s, fn / frame_s)) # print("accuracy: %f, true_positive: %f, false positive: %f, true negative: %f, false negative: %f" % ( # acc, tp / frame_s, fp / frame_s, tn / frame_s, fn / frame_s)) print("total accuracy: " + str(acc_sum / file_num)) print( "total: true_positive: %f, false positive: %f, true negative: %f, false negative: %f" % (tp_sum / frame_num, fp_sum / frame_num, tn_sum / frame_num, fn_sum / frame_num)) return final_softout[:, :], final_label[:, :] if model_type == 1: # bdnn import data_reader_bDNN_v2 as dr print(prj_dir + '/configure/bDNN') sys.path.insert(0, os.path.abspath(prj_dir + 'bDNN')) import config as cg if is_default: w = 19 u = 9 valid_batch_size = 4096 else: w = cg.w u = cg.u valid_batch_size = cg.batch_size valid_data_set = dr.DataReader( eval_input_dir, eval_output_dir, norm_dir, w=w, u=u, name="eval") # training data reader initialization node_inputs = graph.get_tensor_by_name('prefix/model_1/inputs:0') node_labels = graph.get_tensor_by_name('prefix/model_1/labels:0') node_keep_probability = graph.get_tensor_by_name( 'prefix/model_1/keep_probabilty:0') node_logits = graph.get_tensor_by_name('prefix/model_1/logits:0') while True: valid_inputs, valid_labels = valid_data_set.next_batch( valid_batch_size) feed_dict = { node_inputs: valid_inputs, node_labels: valid_labels, node_keep_probability: 1 } if valid_data_set.eof_checker(): final_softout = np.reshape(np.asarray(final_softout), [-1, 1]) final_label = np.reshape(np.asarray(final_label), [-1, 1]) valid_data_set.reader_initialize() # print('Valid data reader was initialized!') # initialize eof flag & num_file & start index break with tf.Session(graph=graph) as sess: logits, labels = sess.run([node_logits, node_labels], feed_dict=feed_dict) soft_pred = bdnn_prediction(valid_batch_size, logits, threshold=0.6, w=w, u=u)[1] raw_indx = int(np.floor(labels.shape[1] / 2)) raw_labels = labels[:, raw_indx] raw_labels = raw_labels.reshape((-1, 1)) final_softout.append(soft_pred) final_label.append(raw_labels) return final_softout[0:data_len, :], final_label[0:data_len, :] if model_type == 2: # dnn import data_reader_DNN_v2 as dnn_dr print(prj_dir + '/configure/DNN') sys.path.insert(0, os.path.abspath(prj_dir + 'DNN')) import config as cg if is_default: w = 19 u = 9 valid_batch_size = 4096 else: w = cg.w u = cg.u valid_batch_size = cg.batch_size valid_data_set = dnn_dr.DataReader(eval_input_dir, eval_output_dir, norm_dir, w=w, u=u, name="eval") node_inputs = graph.get_tensor_by_name('prefix/model_1/inputs:0') node_labels = graph.get_tensor_by_name('prefix/model_1/labels:0') node_keep_probability = graph.get_tensor_by_name( 'prefix/model_1/keep_probabilty:0') node_softpred = graph.get_tensor_by_name('prefix/model_1/soft_pred:0') node_raw_labels = graph.get_tensor_by_name( 'prefix/model_1/raw_labels:0') while True: valid_inputs, valid_labels = valid_data_set.next_batch( valid_batch_size) one_hot_labels = valid_labels.reshape((-1, 1)) one_hot_labels = utils.dense_to_one_hot(one_hot_labels, num_classes=2) feed_dict = { node_inputs: valid_inputs, node_labels: one_hot_labels, node_keep_probability: 1 } if valid_data_set.eof_checker(): final_softout = np.reshape(np.asarray(final_softout), [-1, 1]) final_label = np.reshape(np.asarray(final_label), [-1, 1]) valid_data_set.reader_initialize() # print('Valid data reader was initialized!') # initialize eof flag & num_file & start index break with tf.Session(graph=graph) as sess: soft_pred, raw_labels = sess.run( [node_softpred, node_raw_labels], feed_dict=feed_dict) raw_labels = raw_labels.reshape((-1, 1)) final_softout.append(soft_pred) final_label.append(raw_labels) return final_softout[0:data_len, :], final_label[0:data_len, :] if model_type == 3: # lstm import data_reader_RNN as rnn_dr print(prj_dir + '/configure/LSTM') sys.path.insert(0, os.path.abspath(prj_dir + 'LSTM')) import config as cg if is_default: target_delay = 5 seq_size = 20 batch_num = 200 valid_batch_size = seq_size * batch_num else: target_delay = cg.target_delay seq_size = cg.seq_len valid_batch_size = seq_size valid_data_set = rnn_dr.DataReader(eval_input_dir + "/train/feature_mrcg", eval_input_dir + '/train/label', norm_dir, target_delay=target_delay, name="eval") node_inputs = graph.get_tensor_by_name('prefix/model_1/inputs:0') node_labels = graph.get_tensor_by_name('prefix/model_1/labels:0') node_keep_probability = graph.get_tensor_by_name( 'prefix/model_1/keep_probabilty:0') node_softpred = graph.get_tensor_by_name('prefix/model_1/soft_pred:0') node_raw_labels = graph.get_tensor_by_name( 'prefix/model_1/raw_labels:0') while True: valid_inputs, valid_labels = valid_data_set.next_batch( valid_batch_size) one_hot_labels = valid_labels.reshape((-1, 1)) one_hot_labels = utils.dense_to_one_hot(one_hot_labels, num_classes=2) feed_dict = { node_inputs: valid_inputs, node_labels: one_hot_labels, node_keep_probability: 1 } if valid_data_set.eof_checker(): # final_softout = np.reshape(np.asarray(final_softout), [-1, 1]) # final_label = np.reshape(np.asarray(final_label), [-1, 1]) valid_data_set.reader_initialize() break with tf.Session(graph=graph) as sess: soft_pred, raw_labels = sess.run( [node_softpred, node_raw_labels], feed_dict=feed_dict) raw_labels = raw_labels.reshape((-1, 1)) final_softout.append(soft_pred) final_label.append(raw_labels) # if valid_data_set.eof_checker(): # final_softout = np.reshape(np.asarray(final_softout), [-1, 1]) # final_label = np.reshape(np.asarray(final_label), [-1, 1]) # valid_data_set.reader_initialize() # # print('Valid data reader was initialized!') # initialize eof flag & num_file & start index # break return final_softout, final_label
def main(argv=None): mean_acc = 0 # Graph Part # os.environ["CUDA_VISIBLE_DEVICES"] = '3' print("Graph initialization...") with tf.device(device): with tf.variable_scope("model", reuse=None): m_train = Model(is_training=True) with tf.variable_scope("model", reuse=True): m_valid = Model(is_training=False) print("Done") # Summary Part # print("Setting up summary op...") summary_ph = tf.placeholder(dtype=tf.float32) with tf.variable_scope("Aggregated_Training_Parts"): cost_summary_op = tf.summary.scalar("cost", summary_ph) accuracy_summary_op = tf.summary.scalar("accuracy", summary_ph) train_summary_writer = tf.summary.FileWriter(logs_dir + '/train/', max_queue=4) valid_summary_writer = tf.summary.FileWriter(logs_dir + '/valid/', max_queue=4) summary_dic = summary_generation(valid_file_dir) print("Done") # Model Save Part # print("Setting up Saver...") saver = tf.train.Saver() ckpt = tf.train.get_checkpoint_state(initial_logs_dir) print("Done") # Session Part # sess_config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False) sess_config.gpu_options.allow_growth = True sess = tf.Session(config=sess_config) if ckpt and ckpt.model_checkpoint_path: # model restore print("Model restored...") saver.restore(sess, initial_logs_dir + ckpt_name) print("Done") else: sess.run(tf.global_variables_initializer() ) # if the checkpoint doesn't exist, do initialization train_data_set = dr.DataReader( input_dir, output_dir, norm_dir, w=w, u=u, name="train") # training data reader initialization if mode is 'train': file_len = train_data_set.get_file_len() MAX_STEP = max_epoch * file_len * 1000 // batch_size print(get_num_params()) for itr in range(MAX_STEP): train_inputs, train_labels = train_data_set.next_batch(batch_size) one_hot_labels = train_labels.reshape((-1, 1)) one_hot_labels = dense_to_one_hot(one_hot_labels, num_classes=2) feed_dict = { m_train.inputs: train_inputs, m_train.labels: one_hot_labels, m_train.keep_probability: dropout_rate } sess.run(m_train.train_op, feed_dict=feed_dict) if itr % (file_len * 1000 // batch_size) == 0 and itr > 0: train_cost, train_accuracy = sess.run( [m_train.cost, m_train.accuracy], feed_dict=feed_dict) # train_cost, logits = sess.run([m_train.cost, m_train.logits], feed_dict=feed_dict) # # result = bdnn_prediction(batch_size, logits, threshold=th) # raw_indx = int(np.floor(train_labels.shape[1] / 2)) # raw_labels = train_labels[:, raw_indx] # raw_labels = raw_labels.reshape((-1, 1)) # train_accuracy = np.equal(result, raw_labels) # train_accuracy = train_accuracy.astype(int) # train_accuracy = np.sum(train_accuracy) / batch_size # change to mean... print("Step: %d, train_cost: %.3f, train_accuracy=%3.3f" % (itr, train_cost, train_accuracy)) train_cost_summary_str = sess.run( cost_summary_op, feed_dict={summary_ph: train_cost}) train_accuracy_summary_str = sess.run( accuracy_summary_op, feed_dict={summary_ph: train_accuracy}) train_summary_writer.add_summary( train_cost_summary_str, itr) # write the train phase summary to event files train_summary_writer.add_summary(train_accuracy_summary_str, itr) # if train_data_set.eof_checker(): if itr % (file_len * 1000 // batch_size) == 0 and itr > 0: saver.save(sess, logs_dir + "/model.ckpt", itr) # model save print('validation start!') mean_acc = full_evaluation(m_valid, sess, valid_batch_size, valid_file_dir, valid_summary_writer, summary_dic, itr) if mean_acc > 0.88: print('finish!!') break # train_data_set.reader_initialize() # print('Train data reader was initialized!') # initialize eof flag & num_file & start index elif mode is 'test': final_softout, final_label = utils.vad_test3(m_valid, sess, valid_batch_size, test_file_dir, norm_dir, data_len, eval_type) if data_len is None: return final_softout, final_label else: return final_softout[0:data_len, :], final_label[0:data_len, :]
def do_validation(m_valid, sess, valid_file_dir, norm_dir, type='DNN'): # dataset reader setting # # sys.path.insert(0, prj_dir + '/configure/DNN') if type is 'DNN': sys.path.insert(0, os.path.abspath('../../configure/DNN')) import config as cg valid_batch_size = cg.batch_size valid_data_set = dnn_dr.DataReader(valid_file_dir, valid_file_dir + '/Labels', norm_dir, w=cg.w, u=cg.u, name="eval") avg_valid_accuracy = 0. avg_valid_cost = 0. itr_sum = 0. accuracy_list = [0 for i in range(valid_data_set._file_len)] cost_list = [0 for i in range(valid_data_set._file_len)] itr_file = 0 while True: valid_inputs, valid_labels = valid_data_set.next_batch( valid_batch_size) if valid_data_set.file_change_checker(): # print(itr_file) accuracy_list[itr_file] = avg_valid_accuracy / itr_sum cost_list[itr_file] = avg_valid_cost / itr_sum avg_valid_cost = 0. avg_valid_accuracy = 0. itr_sum = 0 itr_file += 1 valid_data_set.file_change_initialize() if valid_data_set.eof_checker(): valid_data_set.reader_initialize() print('Valid data reader was initialized!' ) # initialize eof flag & num_file & start index break one_hot_labels = valid_labels.reshape((-1, 1)) one_hot_labels = dense_to_one_hot(one_hot_labels, num_classes=2) feed_dict = { m_valid.inputs: valid_inputs, m_valid.labels: one_hot_labels, m_valid.keep_probability: 1 } # valid_cost, valid_softpred, valid_raw_labels\ # = sess.run([m_valid.cost, m_valid.softpred, m_valid.raw_labels], feed_dict=feed_dict) # # fpr, tpr, thresholds = metrics.roc_curve(valid_raw_labels, valid_softpred, pos_label=1) # valid_auc = metrics.auc(fpr, tpr) valid_cost, valid_accuracy = sess.run( [m_valid.cost, m_valid.accuracy], feed_dict=feed_dict) avg_valid_accuracy += valid_accuracy avg_valid_cost += valid_cost itr_sum += 1 total_avg_valid_accuracy = np.asscalar( np.mean(np.asarray(accuracy_list))) total_avg_valid_cost = np.asscalar(np.mean(np.asarray(cost_list))) elif type is 'bDNN': sys.path.insert(0, os.path.abspath('../../configure/bDNN')) import config as cg valid_batch_size = cg.batch_size valid_data_set = dr.DataReader(valid_file_dir, valid_file_dir + '/Labels', norm_dir, w=cg.w, u=cg.u, name="eval") avg_valid_accuracy = 0. avg_valid_cost = 0. itr_sum = 0. accuracy_list = [0 for i in range(valid_data_set._file_len)] cost_list = [0 for i in range(valid_data_set._file_len)] itr_file = 0 while True: valid_inputs, valid_labels = valid_data_set.next_batch( valid_batch_size) if valid_data_set.file_change_checker(): # print(itr_file) accuracy_list[itr_file] = avg_valid_accuracy / itr_sum cost_list[itr_file] = avg_valid_cost / itr_sum avg_valid_cost = 0. avg_valid_accuracy = 0. itr_sum = 0 itr_file += 1 valid_data_set.file_change_initialize() if valid_data_set.eof_checker(): valid_data_set.reader_initialize() print('Valid data reader was initialized!' ) # initialize eof flag & num_file & start index break feed_dict = { m_valid.inputs: valid_inputs, m_valid.labels: valid_labels, m_valid.keep_probability: 1 } valid_cost, valid_logits = sess.run([m_valid.cost, m_valid.logits], feed_dict=feed_dict) valid_pred, soft_pred = bdnn_prediction(valid_batch_size, valid_logits, threshold=0.6) # print(np.sum(valid_pred)) raw_indx = int(np.floor(valid_labels.shape[1] / 2)) raw_labels = valid_labels[:, raw_indx] raw_labels = raw_labels.reshape((-1, 1)) valid_accuracy = np.equal(valid_pred, raw_labels) valid_accuracy = valid_accuracy.astype(int) valid_accuracy = np.sum(valid_accuracy) / valid_batch_size avg_valid_cost += valid_cost avg_valid_accuracy += valid_accuracy itr_sum += 1 total_avg_valid_accuracy = np.asscalar( np.mean(np.asarray(accuracy_list))) total_avg_valid_cost = np.asscalar(np.mean(np.asarray(cost_list))) elif type is 'ACAM': sys.path.insert(0, os.path.abspath('../../configure/ACAM')) import config as cg valid_batch_size = cg.batch_size valid_data_set = dr.DataReader(valid_file_dir, valid_file_dir + '/Labels', norm_dir, w=cg.w, u=cg.u, name="eval") avg_valid_accuracy = 0. avg_valid_cost = 0. itr_sum = 0. accuracy_list = [0 for i in range(valid_data_set._file_len)] cost_list = [0 for i in range(valid_data_set._file_len)] itr_file = 0 while True: valid_inputs, valid_labels = valid_data_set.next_batch( valid_batch_size) if valid_data_set.file_change_checker(): # print(itr_file) accuracy_list[itr_file] = avg_valid_accuracy / itr_sum cost_list[itr_file] = avg_valid_cost / itr_sum avg_valid_cost = 0. avg_valid_accuracy = 0. itr_sum = 0 itr_file += 1 valid_data_set.file_change_initialize() if valid_data_set.eof_checker(): valid_data_set.reader_initialize() print('Valid data reader was initialized!' ) # initialize eof flag & num_file & start index break feed_dict = { m_valid.inputs: valid_inputs, m_valid.labels: valid_labels, m_valid.keep_probability: 1 } # valid_cost, valid_softpred, valid_raw_labels\ # = sess.run([m_valid.cost, m_valid.softpred, m_valid.raw_labels], feed_dict=feed_dict) # # fpr, tpr, thresholds = metrics.roc_curve(valid_raw_labels, valid_softpred, pos_label=1) # valid_auc = metrics.auc(fpr, tpr) valid_cost, valid_accuracy = sess.run( [m_valid.cost, m_valid.reward], feed_dict=feed_dict) avg_valid_accuracy += valid_accuracy avg_valid_cost += valid_cost itr_sum += 1 total_avg_valid_accuracy = np.asscalar( np.mean(np.asarray(accuracy_list))) total_avg_valid_cost = np.asscalar(np.mean(np.asarray(cost_list))) elif type is 'LSTM': sys.path.insert(0, os.path.abspath('../../configure/LSTM')) import config as cg valid_batch_size = cg.seq_len * cg.num_batches valid_data_set = rnn_dr.DataReader(valid_file_dir, valid_file_dir + '/Labels', norm_dir, target_delay=cg.target_delay, name="eval") avg_valid_accuracy = 0. avg_valid_cost = 0. itr_sum = 0. accuracy_list = [0 for i in range(valid_data_set._file_len)] cost_list = [0 for i in range(valid_data_set._file_len)] itr_file = 0 while True: valid_inputs, valid_labels = valid_data_set.next_batch( valid_batch_size) if valid_data_set.file_change_checker(): # print(itr_file) accuracy_list[itr_file] = avg_valid_accuracy / itr_sum cost_list[itr_file] = avg_valid_cost / itr_sum avg_valid_cost = 0. avg_valid_accuracy = 0. itr_sum = 0 itr_file += 1 valid_data_set.file_change_initialize() if valid_data_set.eof_checker(): valid_data_set.reader_initialize() print('Valid data reader was initialized!' ) # initialize eof flag & num_file & start index break one_hot_labels = valid_labels.reshape((-1, 1)) one_hot_labels = dense_to_one_hot(one_hot_labels, num_classes=2) feed_dict = { m_valid.inputs: valid_inputs, m_valid.labels: one_hot_labels, m_valid.keep_probability: 1 } # valid_cost, valid_softpred, valid_raw_labels\ # = sess.run([m_valid.cost, m_valid.softpred, m_valid.raw_labels], feed_dict=feed_dict) # # fpr, tpr, thresholds = metrics.roc_curve(valid_raw_labels, valid_softpred, pos_label=1) # valid_auc = metrics.auc(fpr, tpr) valid_cost, valid_accuracy = sess.run( [m_valid.cost, m_valid.accuracy], feed_dict=feed_dict) avg_valid_accuracy += valid_accuracy avg_valid_cost += valid_cost itr_sum += 1 total_avg_valid_accuracy = np.asscalar( np.mean(np.asarray(accuracy_list))) total_avg_valid_cost = np.asscalar(np.mean(np.asarray(cost_list))) return total_avg_valid_accuracy, total_avg_valid_cost
def main(prj_dir=None, model=None, mode=None): # Configuration Part # if mode is 'train': import path_setting as ps set_path = ps.PathSetting(prj_dir, model) logs_dir = initial_logs_dir = set_path.logs_dir input_dir = set_path.input_dir output_dir = set_path.output_dir norm_dir = set_path.norm_dir valid_file_dir = set_path.valid_file_dir sys.path.insert(0, prj_dir+'/configure/LSTM') import config as cg global seq_size, batch_num seq_size = cg.seq_len batch_num = cg.num_batches global learning_rate, dropout_rate, max_epoch, batch_size, valid_batch_size learning_rate = cg.lr dropout_rate = cg.dropout_rate max_epoch = cg.max_epoch batch_size = valid_batch_size = batch_num*seq_size global target_delay target_delay = cg.target_delay global lstm_cell_size, num_layers lstm_cell_size = cg.cell_size num_layers = cg.num_layers # Graph Part # print("Graph initialization...") with tf.device(device): with tf.variable_scope("model", reuse=None): m_train = Model(is_training=True) with tf.variable_scope("model", reuse=True): m_valid = Model(is_training=False) print("Done") # Summary Part # print("Setting up summary op...") summary_ph = tf.placeholder(dtype=tf.float32) with tf.variable_scope("Training_procedure"): cost_summary_op = tf.summary.scalar("cost", summary_ph) accuracy_summary_op = tf.summary.scalar("accuracy", summary_ph) # train_summary_writer = tf.summary.FileWriter(logs_dir + '/train/', max_queue=4) # valid_summary_writer = tf.summary.FileWriter(logs_dir + '/valid/', max_queue=4) # summary_dic = summary_generation(valid_file_dir) print("Done") # Model Save Part # print("Setting up Saver...") saver = tf.train.Saver() ckpt = tf.train.get_checkpoint_state(logs_dir + '/LSTM') print("Done") # Session Part # sess_config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False) sess_config.gpu_options.allow_growth = True sess = tf.Session(config=sess_config) if mode is 'train': train_summary_writer = tf.summary.FileWriter(logs_dir + '/train/', sess.graph, max_queue=2) valid_summary_writer = tf.summary.FileWriter(logs_dir + '/valid/', max_queue=2) if ckpt and ckpt.model_checkpoint_path: # model restore print("Model restored...") if mode is 'train': saver.restore(sess, ckpt.model_checkpoint_path) else: saver.restore(sess, initial_logs_dir+ckpt_name) # saver.restore(sess, logs_dir+ckpt_name) saver.save(sess, logs_dir + "/model_LSTM.ckpt", 0) # model save print("Done") else: sess.run(tf.global_variables_initializer()) # if the checkpoint doesn't exist, do initialization if mode is 'train': train_data_set = dr.DataReader(input_dir, output_dir, norm_dir, target_delay=target_delay, u=u, name="train") # training data reader initialization # train_data_set = dr.DataReader(input_dir, output_dir, norm_dir, target_delay=target_delay, u=u, name="train") # training data reader initialization if mode is 'train': for itr in range(max_epoch): train_inputs, train_labels = train_data_set.next_batch(batch_size) one_hot_labels = train_labels.reshape((-1, 1)) one_hot_labels = dense_to_one_hot(one_hot_labels, num_classes=2) feed_dict = {m_train.inputs: train_inputs, m_train.labels: one_hot_labels, m_train.keep_probability: dropout_rate} sess.run(m_train.train_op, feed_dict=feed_dict) if itr % 10 == 0 and itr >= 0: train_cost, train_accuracy = sess.run([m_train.cost, m_train.accuracy], feed_dict=feed_dict) print("Step: %d, train_cost: %.4f, train_accuracy=%4.4f" % (itr, train_cost, train_accuracy*100)) train_cost_summary_str = sess.run(cost_summary_op, feed_dict={summary_ph: train_cost}) train_accuracy_summary_str = sess.run(accuracy_summary_op, feed_dict={summary_ph: train_accuracy}) train_summary_writer.add_summary(train_cost_summary_str, itr) # write the train phase summary to event files train_summary_writer.add_summary(train_accuracy_summary_str, itr) # if train_data_set.eof_checker(): if itr % 50 == 0 and itr > 0: saver.save(sess, logs_dir + "/model.ckpt", itr) # model save print('validation start!') valid_accuracy, valid_cost = \ utils.do_validation(m_valid, sess, valid_file_dir, norm_dir, type='LSTM') print("valid_cost: %.4f, valid_accuracy=%4.4f" % (valid_cost, valid_accuracy * 100)) valid_cost_summary_str = sess.run(cost_summary_op, feed_dict={summary_ph: valid_cost}) valid_accuracy_summary_str = sess.run(accuracy_summary_op, feed_dict={summary_ph: valid_accuracy}) valid_summary_writer.add_summary(valid_cost_summary_str, itr) # write the train phase summary to event files valid_summary_writer.add_summary(valid_accuracy_summary_str, itr) # mean_acc = full_evaluation(m_valid, sess, valid_batch_size, valid_file_dir, # valid_summary_writer, summary_dic, itr) # if mean_acc > 0.968: # print('finish!!') # break # train_data_set.reader_initialize() # print('Train data reader was initialized!') # initialize eof flag & num_file & start index elif mode is 'test': final_softout, final_label = utils.vad_test3(m_valid, sess, valid_batch_size, test_file_dir, norm_dir, data_len, eval_type) if data_len is None: return final_softout, final_label else: return final_softout[0:data_len, :], final_label[0:data_len, :]