def main(): # global n_words # Prepare training and testing data loadpath = "./data/yahoo.p" x = cPickle.load(open(loadpath, "rb")) train, val, test = x[0], x[1], x[2] train_lab, val_lab, test_lab = x[3], x[4], x[5] wordtoix, ixtoword = x[6], x[7] train_lab = np.array(train_lab, dtype='float32') val_lab = np.array(val_lab, dtype='float32') test_lab = np.array(test_lab, dtype='float32') opt = Options() opt.n_words = len(ixtoword) del x print(dict(opt)) print('Total words: %d' % opt.n_words) if opt.part_data: np.random.seed(123) train_ind = np.random.choice(len(train), int(len(train) * opt.portion), replace=False) train = [train[t] for t in train_ind] train_lab = [train_lab[t] for t in train_ind] try: params = np.load('./param_g.npz') if params['Wemb'].shape == (opt.n_words, opt.embed_size): print('Use saved embedding.') opt.W_emb = params['Wemb'] else: print('Emb Dimension mismatch: param_g.npz:' + str(params['Wemb'].shape) + ' opt: ' + str((opt.n_words, opt.embed_size))) opt.fix_emb = False except IOError: print('No embedding file found.') opt.fix_emb = False with tf.device('/gpu:1'): x_ = tf.placeholder(tf.int32, shape=[opt.batch_size, opt.maxlen]) x_mask_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.maxlen]) keep_prob = tf.placeholder(tf.float32) y_ = tf.placeholder(tf.float32, shape=[opt.batch_size, 10]) accuracy_, loss_, train_op, W_emb_ = emb_classifier( x_, x_mask_, y_, keep_prob, opt) # merged = tf.summary.merge_all() uidx = 0 max_val_accuracy = 0. max_test_accuracy = 0. # gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1) config = tf.ConfigProto(log_device_placement=False, allow_soft_placement=True) config.gpu_options.allow_growth = True np.set_printoptions(precision=3) np.set_printoptions(threshold=np.inf) saver = tf.train.Saver() with tf.Session(config=config) as sess: train_writer = tf.summary.FileWriter(opt.log_path + '/train', sess.graph) test_writer = tf.summary.FileWriter(opt.log_path + '/test', sess.graph) sess.run(tf.global_variables_initializer()) if opt.restore: try: t_vars = tf.trainable_variables() # print([var.name[:-2] for var in t_vars]) save_keys = tensors_key_in_file(opt.save_path) # print(save_keys.keys()) ss = set([var.name for var in t_vars]) & set( [s + ":0" for s in save_keys.keys()]) cc = {var.name: var for var in t_vars} # only restore variables with correct shape ss_right_shape = set( [s for s in ss if cc[s].get_shape() == save_keys[s[:-2]]]) loader = tf.train.Saver(var_list=[ var for var in t_vars if var.name in ss_right_shape ]) loader.restore(sess, opt.save_path) print("Loading variables from '%s'." % opt.save_path) print("Loaded variables:" + str(ss)) except: print("No saving session, using random initialization") sess.run(tf.global_variables_initializer()) try: for epoch in range(opt.max_epochs): print("Starting epoch %d" % epoch) kf = get_minibatches_idx(len(train), opt.batch_size, shuffle=True) for _, train_index in kf: uidx += 1 sents = [train[t] for t in train_index] x_labels = [train_lab[t] for t in train_index] x_labels = np.array(x_labels) x_labels = x_labels.reshape((len(x_labels), 10)) x_batch, x_batch_mask = prepare_data_for_emb(sents, opt) _, loss = sess.run( [train_op, loss_], feed_dict={ x_: x_batch, x_mask_: x_batch_mask, y_: x_labels, keep_prob: opt.drop_rate }) if uidx % opt.valid_freq == 0: train_correct = 0.0 kf_train = get_minibatches_idx(500, opt.batch_size, shuffle=True) for _, train_index in kf_train: train_sents = [train[t] for t in train_index] train_labels = [train_lab[t] for t in train_index] train_labels = np.array(train_labels) train_labels = train_labels.reshape( (len(train_labels), 10)) x_train_batch, x_train_batch_mask = prepare_data_for_emb( train_sents, opt) # Batch L train_accuracy = sess.run(accuracy_, feed_dict={ x_: x_train_batch, x_mask_: x_train_batch_mask, y_: train_labels, keep_prob: 1.0 }) train_correct += train_accuracy * len(train_index) train_accuracy = train_correct / 500 print("Iteration %d: Training loss %f " % (uidx, loss)) print("Train accuracy %f " % train_accuracy) val_correct = 0.0 kf_val = get_minibatches_idx(20000, opt.batch_size, shuffle=True) for _, val_index in kf_val: val_sents = [val[t] for t in val_index] val_labels = [val_lab[t] for t in val_index] val_labels = np.array(val_labels) val_labels = val_labels.reshape( (len(val_labels), 10)) x_val_batch, x_val_batch_mask = prepare_data_for_emb( val_sents, opt) val_accuracy = sess.run(accuracy_, feed_dict={ x_: x_val_batch, x_mask_: x_val_batch_mask, y_: val_labels, keep_prob: 1.0 }) val_correct += val_accuracy * len(val_index) val_accuracy = val_correct / 20000 print("Validation accuracy %f " % val_accuracy) if val_accuracy > max_val_accuracy: max_val_accuracy = val_accuracy test_correct = 0.0 kf_test = get_minibatches_idx(len(test), opt.batch_size, shuffle=True) for _, test_index in kf_test: test_sents = [test[t] for t in test_index] test_labels = [test_lab[t] for t in test_index] test_labels = np.array(test_labels) test_labels = test_labels.reshape( (len(test_labels), 10)) x_test_batch, x_test_batch_mask = prepare_data_for_emb( test_sents, opt) test_accuracy = sess.run(accuracy_, feed_dict={ x_: x_test_batch, x_mask_: x_test_batch_mask, y_: test_labels, keep_prob: 1.0 }) test_correct += test_accuracy * len(test_index) test_accuracy = test_correct / len(test) print("Test accuracy %f " % test_accuracy) max_test_accuracy = test_accuracy print("Epoch %d: Max Test accuracy %f" % (epoch, max_test_accuracy)) emb = sess.run(W_emb_, feed_dict={x_: x_test_batch}) cPickle.dump([emb], open("yahoo_emb_max_300.p", "wb")) print("Max Test accuracy %f " % max_test_accuracy) except KeyboardInterrupt: # print 'Training interupted' print('Training interupted') print("Max Test accuracy %f " % max_test_accuracy)
def main(): # Prepare training and testing data opt = Options() # load data loadpath = "./data/mimic3.p" embpath = "mimic3_emb.p" opt.num_class = 50 x = cPickle.load(open(loadpath, "rb")) train, train_text, train_lab = x[0], x[1], x[2] val, val_text, val_lab = x[3], x[4], x[5] test, test_text, test_lab = x[6], x[7], x[8] wordtoix, ixtoword = x[10], x[9] del x print("load data finished") train_lab = np.array(train_lab, dtype='float32') val_lab = np.array(val_lab, dtype='float32') test_lab = np.array(test_lab, dtype='float32') opt.n_words = len(ixtoword) if opt.part_data: #np.random.seed(123) train_ind = np.random.choice(len(train), int(len(train) * opt.portion), replace=False) train = [train[t] for t in train_ind] train_lab = [train_lab[t] for t in train_ind] os.environ['CUDA_VISIBLE_DEVICES'] = str(opt.GPUID) print(dict(opt)) print('Total words: %d' % opt.n_words) try: opt.W_emb = np.array(cPickle.load(open(embpath, 'rb')), dtype='float32') opt.W_class_emb = load_class_embedding(wordtoix, opt) except IOError: print('No embedding file found.') opt.fix_emb = False with tf.device('/gpu:1'): x_ = tf.placeholder(tf.int32, shape=[opt.batch_size, opt.maxlen], name='x_') x_mask_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.maxlen], name='x_mask_') keep_prob = tf.placeholder(tf.float32, name='keep_prob') y_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.num_class], name='y_') class_penalty_ = tf.placeholder(tf.float32, shape=()) accuracy_, loss_, train_op, W_norm_, global_step, logits_, prob_ = emb_classifier( x_, x_mask_, y_, keep_prob, opt, class_penalty_) uidx = 0 max_val_accuracy = 0. max_test_accuracy = 0. max_val_auc_mean = 0. max_test_auc_mean = 0. config = tf.ConfigProto( log_device_placement=False, allow_soft_placement=True, ) config.gpu_options.allow_growth = True np.set_printoptions(precision=3) np.set_printoptions(threshold=np.inf) saver = tf.train.Saver() with tf.Session(config=config) as sess: train_writer = tf.summary.FileWriter(opt.log_path + '/train', sess.graph) test_writer = tf.summary.FileWriter(opt.log_path + '/test', sess.graph) sess.run(tf.global_variables_initializer()) if opt.restore: try: t_vars = tf.trainable_variables() save_keys = tensors_key_in_file(opt.save_path) ss = set([var.name for var in t_vars]) & set( [s + ":0" for s in save_keys.keys()]) cc = {var.name: var for var in t_vars} # only restore variables with correct shape ss_right_shape = set( [s for s in ss if cc[s].get_shape() == save_keys[s[:-2]]]) loader = tf.train.Saver(var_list=[ var for var in t_vars if var.name in ss_right_shape ]) loader.restore(sess, opt.save_path) print("Loading variables from '%s'." % opt.save_path) print("Loaded variables:" + str(ss)) except: print("No saving session, using random initialization") sess.run(tf.global_variables_initializer()) try: for epoch in range(opt.max_epochs): print("Starting epoch %d" % epoch) kf = get_minibatches_idx(len(train), opt.batch_size, shuffle=True) for _, train_index in kf: uidx += 1 sents = [train[t] for t in train_index] x_labels = [train_lab[t] for t in train_index] x_labels = np.array(x_labels) x_labels = x_labels.reshape((len(x_labels), opt.num_class)) x_batch, x_batch_mask = prepare_data_for_emb(sents, opt) _, loss, step, = sess.run( [train_op, loss_, global_step], feed_dict={ x_: x_batch, x_mask_: x_batch_mask, y_: x_labels, keep_prob: opt.dropout, class_penalty_: opt.class_penalty }) if uidx % opt.valid_freq == 0: train_correct = 0.0 # sample evaluate accuaccy on 500 sample data kf_train = get_minibatches_idx(500, opt.batch_size, shuffle=True) for _, train_index in kf_train: train_sents = [train[t] for t in train_index] train_labels = [train_lab[t] for t in train_index] train_labels = np.array(train_labels) train_labels = train_labels.reshape( (len(train_labels), opt.num_class)) x_train_batch, x_train_batch_mask = prepare_data_for_emb( train_sents, opt) train_accuracy = sess.run(accuracy_, feed_dict={ x_: x_train_batch, x_mask_: x_train_batch_mask, y_: train_labels, keep_prob: 1.0, class_penalty_: 0.0 }) train_correct += train_accuracy * len(train_index) train_accuracy = train_correct / 500 print("Iteration %d: Training loss %f " % (uidx, loss)) print("Train accuracy %f " % train_accuracy) val_correct = 0.0 val_y = [] val_logits_list = [] val_prob_list = [] val_true_list = [] kf_val = get_minibatches_idx(len(val), opt.batch_size, shuffle=True) for _, val_index in kf_val: val_sents = [val[t] for t in val_index] val_labels = [val_lab[t] for t in val_index] val_labels = np.array(val_labels) val_labels = val_labels.reshape( (len(val_labels), opt.num_class)) x_val_batch, x_val_batch_mask = prepare_data_for_emb( val_sents, opt) val_accuracy, val_logits, val_probs = sess.run( [accuracy_, logits_, prob_], feed_dict={ x_: x_val_batch, x_mask_: x_val_batch_mask, y_: val_labels, keep_prob: 1.0, class_penalty_: 0.0 }) val_correct += val_accuracy * len(val_index) val_y += np.argmax(val_labels, axis=1).tolist() val_logits_list += val_logits.tolist() val_prob_list += val_probs.tolist() val_true_list += val_labels.tolist() val_accuracy = val_correct / len(val) val_logits_array = np.asarray(val_logits_list) val_prob_array = np.asarray(val_prob_list) val_true_array = np.asarray(val_true_list) val_auc_list = [] val_auc_micro = roc_auc_score(y_true=val_true_array, y_score=val_logits_array, average='micro') val_auc_macro = roc_auc_score(y_true=val_true_array, y_score=val_logits_array, average='macro') for i in range(opt.num_class): if np.max(val_true_array[:, i] > 0): val_auc = roc_auc_score( y_true=val_true_array[:, i], y_score=val_logits_array[:, i], ) val_auc_list.append(val_auc) val_auc_mean = np.mean(val_auc) # print("Validation accuracy %f " % val_accuracy) print("val auc macro %f micro %f " % (val_auc_macro, val_auc_micro)) if True: test_correct = 0.0 test_y = [] test_logits_list = [] test_prob_list = [] test_true_list = [] kf_test = get_minibatches_idx(len(test), opt.batch_size, shuffle=True) for _, test_index in kf_test: test_sents = [test[t] for t in test_index] test_labels = [test_lab[t] for t in test_index] test_labels = np.array(test_labels) test_labels = test_labels.reshape( (len(test_labels), opt.num_class)) x_test_batch, x_test_batch_mask = prepare_data_for_emb( test_sents, opt) test_accuracy, test_logits, test_probs = sess.run( [accuracy_, logits_, prob_], feed_dict={ x_: x_test_batch, x_mask_: x_test_batch_mask, y_: test_labels, keep_prob: 1.0, class_penalty_: 0.0 }) test_correct += test_accuracy * len(test_index) test_correct += test_accuracy * len(test_index) test_y += np.argmax(test_labels, axis=1).tolist() test_logits_list += test_logits.tolist() test_prob_list += test_probs.tolist() test_true_list += test_labels.tolist() test_accuracy = test_correct / len(test) test_logits_array = np.asarray(test_logits_list) test_prob_array = np.asarray(test_prob_list) test_true_array = np.asarray(test_true_list) test_auc_list = [] test_auc_micro = roc_auc_score( y_true=test_true_array, y_score=test_logits_array, average='micro') test_auc_macro = roc_auc_score( y_true=test_true_array, y_score=test_logits_array, average='macro') test_f1_micro = micro_f1( test_prob_array.ravel() > 0.5, test_true_array.ravel(), ) test_f1_macro = macro_f1( test_prob_array > 0.5, test_true_array, ) test_p5 = precision_at_k(test_logits_array, test_true_array, 5) for i in range(opt.num_class): if np.max(test_true_array[:, i] > 0): test_auc = roc_auc_score( y_true=test_true_array[:, i], y_score=test_logits_array[:, i], ) test_auc_list.append(test_auc) test_auc_mean = np.mean(test_auc) print("Test auc macro %f micro %f " % (test_auc_macro, test_auc_micro)) print("Test f1 macro %f micro %f " % (test_f1_macro, test_f1_micro)) print("P5 %f" % test_p5) # max_test_accuracy = test_accuracy max_test_auc_mean = test_auc_mean # print("Test accuracy %f " % test_accuracy) # max_test_accuracy = test_accuracy # print("Epoch %d: Max Test accuracy %f" % (epoch, max_test_accuracy)) print("Epoch %d: Max Test auc %f" % (epoch, max_test_auc_mean)) saver.save(sess, opt.save_path, global_step=epoch) print("Max Test accuracy %f " % max_test_accuracy) except KeyboardInterrupt: print('Training interupted') print("Max Test accuracy %f " % max_test_accuracy)
def main(opt): # global n_words # Prepare training and testing data data_path = opt.data_dir + "/" + opt.data_name print('loading '+data_path) x = cPickle.load(open(data_path, "rb")) train, val, test = x[0], x[1], x[2] wordtoix, ixtoword = x[3], x[4] opt.n_words = len(ixtoword) print datetime.datetime.now().strftime("%I:%M%p on %B %d, %Y") print dict(opt) print('Total words: %d' % opt.n_words) with tf.device('/gpu:1'): x_1_ = tf.placeholder(tf.int32, shape=[opt.batch_size, opt.sent_len]) x_2_ = tf.placeholder(tf.int32, shape=[opt.batch_size, opt.sent_len]) y_ = tf.placeholder(tf.float32, shape=[opt.batch_size,]) l_temp_ = tf.placeholder(tf.float32, shape=[]) res_, loss_ ,train_op = cons_disc(x_1_, x_2_, y_, opt, l_temp_) merged = tf.summary.merge_all() uidx = 0 config = tf.ConfigProto(log_device_placement=False, allow_soft_placement=True) config.gpu_options.allow_growth = True config.gpu_options.per_process_gpu_memory_fraction = 0.95 np.set_printoptions(precision=3) np.set_printoptions(threshold=np.inf) saver = tf.train.Saver() with tf.Session(config=config) as sess: train_writer = tf.summary.FileWriter(opt.log_path + '/train', sess.graph) test_writer = tf.summary.FileWriter(opt.log_path + '/test', sess.graph) sess.run(tf.global_variables_initializer()) # feed_dict={x_: np.zeros([opt.batch_size, opt.sent_len]), x_org_: np.zeros([opt.batch_size, opt.sent_len])} if opt.restore: print('-'*20) print("Loading variables from '%s'." % opt.load_path) try: #pdb.set_trace() t_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES) #tf.trainable_variables() #print([var.name[:-2] for var in t_vars] save_keys = tensors_key_in_file(opt.load_path) ss = [var for var in t_vars if var.name[:-2] in save_keys.keys()] ss = [var.name for var in ss if var.get_shape() == save_keys[var.name[:-2]]] loader = tf.train.Saver(var_list= [var for var in t_vars if var.name in ss]) loader.restore(sess, opt.load_path) print("Loaded variables:"+str(ss)) print('-'*20) except Exception as e: print 'Error: '+str(e) exit() print("No saving session, using random initialization") sess.run(tf.global_variables_initializer()) # train # if don't want to train, set max_epochs=0 for epoch in range(opt.max_epochs): print("Starting epoch %d" % epoch) opt.l_temp = min(opt.l_temp * opt.l_temp_factor, opt.l_temp_max) print("Annealing temperature " + str(opt.l_temp)) kf = get_minibatches_idx(len(train), opt.batch_size, shuffle=True) for _, train_index in kf: uidx += 1 sents = [train[t] for t in train_index] indice = [rand_pair(opt.task, opt.data_name) for _ in range(opt.batch_size)] if opt.task == 'L': x_1 = [sents[i][idx[0]] for i, idx in enumerate(indice)] x_2 = [sents[i][idx[1]] for i, idx in enumerate(indice)] y_batch = [(i1-i2)%2 == 0 for i1,i2 in indice] elif opt.task == 'C': batch_indice = np.concatenate([np.random.permutation(opt.batch_size/2) , range(opt.batch_size/2, opt.batch_size)]) y_batch = (range(opt.batch_size) == batch_indice) rn = np.random.choice(7,size = opt.batch_size) x_1 = [sents[i][idx[0]] for i, idx in enumerate(indice)] x_2 = [sents[batch_indice[i]][idx[1]] for i, idx in enumerate(indice)] else: # G batch_indice = np.concatenate([np.random.permutation(opt.batch_size/2) , range(opt.batch_size/2, opt.batch_size)]) y_batch = (range(opt.batch_size) == batch_indice) x_1 = [sents[i][idx[0]] for i, idx in enumerate(indice)] x_2 = [sents[batch_indice[i]][idx[1]] for i, idx in enumerate(indice)] x_1_batch = prepare_data_for_cnn(x_1, opt) # Batch L x_2_batch = prepare_data_for_cnn(x_2, opt) # Batch L feed = {x_1_: x_1_batch, x_2_: x_2_batch, y_:np.float32(y_batch),l_temp_:opt.l_temp} _, loss = sess.run([train_op, loss_], feed_dict=feed) if uidx % opt.print_freq == 1: print("Iteration %d: loss %f " % (uidx, loss)) res = sess.run(res_, feed_dict=feed) if opt.verbose: print("logits:" + str(res['logits'])) print("H1:" + str(res['H_1'][0])) print("H2:" + str(res['H_2'][0])) # print("H2:" + str(res['H_1'][0]*res['H_2'][0]-0.5)) acc = sum(np.equal(res['y_pred'],y_batch))/np.float(opt.batch_size) print("Accuracy: %f" % (acc)) print("y_mean: %f" % (np.mean(y_batch))) print("corr:" + str(res['corr'])) sys.stdout.flush() summary = sess.run(merged, feed_dict=feed) train_writer.add_summary(summary, uidx) if uidx % opt.valid_freq == 1: acc, loss_val, y_mean, corr = 0, 0, 0, 0 indice = [rand_pair(opt.task, opt.data_name) for _ in range(opt.batch_size)] for i in range(100): valid_index = np.random.choice(len(test), opt.batch_size) sents = [test[t] for t in valid_index] if opt.task == 'L': x_1 = [sents[i][idx[0]] for i, idx in enumerate(indice)] x_2 = [sents[i][idx[1]] for i, idx in enumerate(indice)] y_batch = [(i1-i2)%2 == 0 for i1,i2 in indice] elif opt.task == 'C': batch_indice = np.concatenate([np.random.permutation(opt.batch_size/2) , range(opt.batch_size/2, opt.batch_size)]) y_batch = (range(opt.batch_size) == batch_indice) rn = np.random.choice(7,size = opt.batch_size) x_1 = [sents[i][idx[0]] for i, idx in enumerate(indice)] x_2 = [sents[batch_indice[i]][idx[1]] for i, idx in enumerate(indice)] else: # G batch_indice = np.concatenate([np.random.permutation(opt.batch_size/2) , range(opt.batch_size/2, opt.batch_size)]) y_batch = (range(opt.batch_size) == batch_indice) x_1 = [sents[i][idx[0]] for i, idx in enumerate(indice)] x_2 = [sents[batch_indice[i]][idx[1]] for i, idx in enumerate(indice)] x_1_batch = prepare_data_for_cnn(x_1, opt) # Batch L x_2_batch = prepare_data_for_cnn(x_2, opt) # Batch L feed = {x_1_: x_1_batch, x_2_: x_2_batch, y_:np.float32(y_batch),l_temp_:opt.l_temp} loss_val += sess.run(loss_, feed_dict=feed) res = sess.run(res_, feed_dict=feed) acc += sum(np.equal(res['y_pred'],y_batch))/np.float(opt.batch_size) y_mean += np.mean(y_batch) corr += res['corr'] loss_val = loss_val / 100.0 acc = acc / 100.0 y_mean = y_mean / 100.0 corr = corr / 100.0 print("Validation loss %.4f " % (loss_val)) print("Validation accuracy: %.4f" % (acc)) print("Validation y_mean: %.4f" % (y_mean)) print("Validation corr: %.4f" % (corr)) print("") sys.stdout.flush() summary = sess.run(merged, feed_dict=feed) test_writer.add_summary(summary, uidx) saver.save(sess, opt.save_path, global_step=epoch) # test if opt.test: print('Testing....') iter_num = np.int(np.floor(len(test)/opt.batch_size))+1 for i in range(iter_num): if i%100 == 0: print('Iter %i/%i'%(i, iter_num)) test_index = range(i*opt.batch_size, (i+1)*opt.batch_size) test_sents = [test[t%len(test)] for t in test_index] indice = [(0,1),(2,3),(4,5),(6,7)] for idx in indice: x_1 = [test_sents[i][idx[0]] for i in range(opt.batch_size)] x_2 = [test_sents[i][idx[1]] for i in range(opt.batch_size)] y_batch = [True for i in range(opt.batch_size)] x_1_batch = prepare_data_for_cnn(x_1, opt) # Batch L x_2_batch = prepare_data_for_cnn(x_2, opt) # Batch L feed = {x_1_: x_1_batch, x_2_: x_2_batch, y_:np.float32(y_batch), l_temp_:opt.l_temp} res = sess.run(res_, feed_dict=feed) for d in range(opt.batch_size): with open(opt.log_path + '.feature.txt', "a") as myfile: myfile.write(str(test_index[d]) + "\t" + str(idx[0]) + "\t" + " ".join([ixtoword[x] for x in x_1_batch[d] if x != 0]) + "\t" + " ".join(map(str,res['H_1'][d]))+ "\n") myfile.write(str(test_index[d]) + "\t" + str(idx[1]) + "\t" + " ".join([ixtoword[x] for x in x_2_batch[d] if x != 0]) + "\t" + " ".join(map(str,res['H_2'][d]))+ "\n")
def main(): # Prepare training and testing data opt = Options() # load data if opt.dataset == 'yahoo': loadpath = "./data/yahoo.p" embpath = "./data/yahoo_glove.p" opt.num_class = 10 opt.class_name = [ 'Society Culture', 'Science Mathematics', 'Health', 'Education Reference', 'Computers Internet', 'Sports', 'Business Finance', 'Entertainment Music', 'Family Relationships', 'Politics Government' ] elif opt.dataset == 'agnews': loadpath = "./data/ag_news.p" embpath = "./data/ag_news_glove.p" opt.num_class = 4 opt.class_name = ['World', 'Sports', 'Business', 'Science'] elif opt.dataset == 'dbpedia': loadpath = "./data/dbpedia.p" embpath = "./data/dbpedia_glove.p" opt.num_class = 14 opt.class_name = [ 'Company', 'Educational Institution', 'Artist', 'Athlete', 'Office Holder', 'Mean Of Transportation', 'Building', 'Natural Place', 'Village', 'Animal', 'Plant', 'Album', 'Film', 'Written Work', ] elif opt.dataset == 'yelp_full': loadpath = "./data/yelp_full.p" embpath = "./data/yelp_full_glove.p" opt.num_class = 5 opt.class_name = ['worst', 'bad', 'middle', 'good', 'best'] elif opt.dataset == 'Positive': loadpath = "./data/Positive.p" embpath = "./data/glove.p" opt.num_class = 2 opt.class_name = ['Control', 'Other'] elif opt.dataset == 'Negative': loadpath = "./data/Negative.p" embpath = "./data/glove.p" opt.num_class = 2 opt.class_name = ['Control', 'Other'] x = cPickle.load(open(loadpath, "rb")) train, val, test = x[0], x[1], x[2] train_lab, val_lab, test_lab = x[3], x[4], x[5] wordtoix, ixtoword = x[6], x[7] del x print("load data finished") train_lab = np.array(train_lab, dtype='float32') val_lab = np.array(val_lab, dtype='float32') test_lab = np.array(test_lab, dtype='float32') opt.n_words = len(ixtoword) if opt.part_data: #np.random.seed(123) train_ind = np.random.choice(len(train), int(len(train) * opt.portion), replace=False) train = [train[t] for t in train_ind] train_lab = [train_lab[t] for t in train_ind] os.environ['CUDA_VISIBLE_DEVICES'] = str(opt.GPUID) print(dict(opt)) print('Total words: %d' % opt.n_words) try: opt.W_emb = np.array(cPickle.load(open(embpath, 'rb')), dtype='float32') #opt.W_class_emb = load_class_embedding( wordtoix, opt) except IOError: print('No embedding file found.') opt.fix_emb = False with tf.device('/gpu:1'): x_ = tf.placeholder(tf.int32, shape=[opt.batch_size, opt.maxlen], name='x_') x_mask_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.maxlen], name='x_mask_') keep_prob = tf.placeholder(tf.float32, name='keep_prob') y_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.num_class], name='y_') class_penalty_ = tf.placeholder(tf.float32, shape=()) accuracy_, loss_, train_op, W_norm_, W_class, global_step = emb_classifier( x_, x_mask_, y_, keep_prob, opt, class_penalty_) uidx = 0 max_val_accuracy = 0. max_test_accuracy = 0. config = tf.ConfigProto( log_device_placement=False, allow_soft_placement=True, ) config.gpu_options.allow_growth = True np.set_printoptions(precision=3) np.set_printoptions(threshold=np.inf) saver = tf.train.Saver() with tf.Session(config=config) as sess: train_writer = tf.summary.FileWriter(opt.log_path + '/train', sess.graph) test_writer = tf.summary.FileWriter(opt.log_path + '/test', sess.graph) sess.run(tf.global_variables_initializer()) if opt.restore: try: t_vars = tf.trainable_variables() save_keys = tensors_key_in_file(opt.save_path) ss = set([var.name for var in t_vars]) & set( [s + ":0" for s in save_keys.keys()]) cc = {var.name: var for var in t_vars} # only restore variables with correct shape ss_right_shape = set( [s for s in ss if cc[s].get_shape() == save_keys[s[:-2]]]) loader = tf.train.Saver(var_list=[ var for var in t_vars if var.name in ss_right_shape ]) loader.restore(sess, opt.save_path) print("Loading variables from '%s'." % opt.save_path) print("Loaded variables:" + str(ss)) except: print("No saving session, using random initialization") sess.run(tf.global_variables_initializer()) try: for epoch in range(opt.max_epochs): print("Starting epoch %d" % epoch) kf = get_minibatches_idx(len(train), opt.batch_size, shuffle=True) for _, train_index in kf: uidx += 1 sents = [train[t] for t in train_index] x_labels = [train_lab[t] for t in train_index] x_labels = np.array(x_labels) x_labels = x_labels.reshape((len(x_labels), opt.num_class)) x_batch, x_batch_mask = prepare_data_for_emb(sents, opt) _, loss, step, = sess.run( [train_op, loss_, global_step], feed_dict={ x_: x_batch, x_mask_: x_batch_mask, y_: x_labels, keep_prob: opt.dropout, class_penalty_: opt.class_penalty }) if uidx % opt.valid_freq == 0: train_correct = 0.0 # sample evaluate accuaccy on 500 sample data kf_train = get_minibatches_idx(50, opt.batch_size, shuffle=True) for _, train_index in kf_train: train_sents = [train[t] for t in train_index] train_labels = [train_lab[t] for t in train_index] train_labels = np.array(train_labels) train_labels = train_labels.reshape( (len(train_labels), opt.num_class)) x_train_batch, x_train_batch_mask = prepare_data_for_emb( train_sents, opt) train_accuracy = sess.run(accuracy_, feed_dict={ x_: x_train_batch, x_mask_: x_train_batch_mask, y_: train_labels, keep_prob: 1.0, class_penalty_: 0.0 }) train_correct += train_accuracy * len(train_index) train_accuracy = train_correct / 50 with open("weights.pkl", "wb") as handle: pickle.dump(sess.run(W_norm_), handle) pickle.dump(sess.run(W_class), handle) print("Iteration %d: Training loss %f " % (uidx, loss)) print("Train accuracy %f " % train_accuracy) val_correct = 0.0 kf_val = get_minibatches_idx(len(val), opt.batch_size, shuffle=True) for _, val_index in kf_val: val_sents = [val[t] for t in val_index] val_labels = [val_lab[t] for t in val_index] val_labels = np.array(val_labels) val_labels = val_labels.reshape( (len(val_labels), opt.num_class)) x_val_batch, x_val_batch_mask = prepare_data_for_emb( val_sents, opt) val_accuracy = sess.run(accuracy_, feed_dict={ x_: x_val_batch, x_mask_: x_val_batch_mask, y_: val_labels, keep_prob: 1.0, class_penalty_: 0.0 }) val_correct += val_accuracy * len(val_index) val_accuracy = val_correct / (len(val) + 0.1) print("Validation accuracy %f " % val_accuracy) if val_accuracy > max_val_accuracy: max_val_accuracy = val_accuracy test_correct = 0.0 kf_test = get_minibatches_idx(len(test), opt.batch_size, shuffle=True) for _, test_index in kf_test: test_sents = [test[t] for t in test_index] test_labels = [test_lab[t] for t in test_index] test_labels = np.array(test_labels) test_labels = test_labels.reshape( (len(test_labels), opt.num_class)) x_test_batch, x_test_batch_mask = prepare_data_for_emb( test_sents, opt) test_accuracy = sess.run(accuracy_, feed_dict={ x_: x_test_batch, x_mask_: x_test_batch_mask, y_: test_labels, keep_prob: 1.0, class_penalty_: 0.0 }) test_correct += test_accuracy * len(test_index) test_accuracy = test_correct / (len(test) + 0.1) print("Test accuracy %f " % test_accuracy) max_test_accuracy = test_accuracy print("Epoch %d: Max Test accuracy %f" % (epoch, max_test_accuracy)) saver.save(sess, opt.save_path, global_step=epoch) print("Max Test accuracy %f " % max_test_accuracy) except KeyboardInterrupt: print('Training interupted') print("Max Test accuracy %f " % max_test_accuracy)
def main(): # Prepare training and testing data opt = Options() # load data if opt.dataset == 'Tweet': loadpath = "./data/langdetect_tweet0.7.p" embpath = "./data/langdetect_tweet_emb.p" opt.num_class = 4 opt.class_name = ['apple', 'google', 'microsoft', 'twitter'] if opt.dataset == 'N20short': loadpath = "./data/N20short.p" embpath = "./data/N20short_emb.p" opt.class_name = [ 'rec.autos', 'talk.politics.misc', 'sci.electronics', 'comp.sys.ibm.pc.hardware', 'talk.politics.guns', 'sci.med', 'rec.motorcycles', 'soc.religion.christian', 'comp.sys.mac.hardware', 'comp.graphics', 'sci.space', 'alt.atheism', 'rec.sport.baseball', 'comp.windows.x', 'talk.religion.misc', 'comp.os.ms-windows.misc', 'misc.forsale', 'talk.politics.mideast', 'sci.crypt', 'rec.sport.hockey' ] opt.num_class = len(opt.class_name) elif opt.dataset == 'agnews': loadpath = "./data/ag_news.p" embpath = "./data/ag_news_glove.p" opt.num_class = 4 opt.class_name = ['World', 'Sports', 'Business', 'Science'] elif opt.dataset == 'dbpedia': loadpath = "./data/dbpedia.p" embpath = "./data/dbpedia_glove.p" opt.num_class = 14 opt.class_name = [ 'Company', 'Educational Institution', 'Artist', 'Athlete', 'Office Holder', 'Mean Of Transportation', 'Building', 'Natural Place', 'Village', 'Animal', 'Plant', 'Album', 'Film', 'Written Work', ] elif opt.dataset == 'yelp_full': loadpath = "./data/yelp_full.p" embpath = "./data/yelp_full_glove.p" opt.num_class = 5 opt.class_name = ['worst', 'bad', 'middle', 'good', 'best'] x = cPickle.load(open(loadpath, "rb"), encoding='iso-8859-1') train, val, test = x[0], x[1], x[2] print(len(val)) train_lab, val_lab, test_lab = x[3], x[4], x[5] wordtoix, ixtoword = x[6], x[7] del x print("len of train,val,test:", len(train), len(val), len(test)) print("load data finished") train_lab = np.array(train_lab, dtype='float32') val_lab = np.array(val_lab, dtype='float32') test_lab = np.array(test_lab, dtype='float32') opt.n_words = len(ixtoword) if opt.part_data: #np.random.seed(123) train_ind = np.random.choice(len(train), int(len(train) * opt.portion), replace=False) train = [train[t] for t in train_ind] train_lab = [train_lab[t] for t in train_ind] os.environ['CUDA_VISIBLE_DEVICES'] = str(opt.GPUID) print(dict(opt)) print('Total words: %d' % opt.n_words) try: opt.W_emb = np.array(cPickle.load(open(embpath, 'rb'), encoding='iso-8859-1'), dtype='float32') opt.W_class_emb = load_class_embedding(wordtoix, opt) except IOError: print('No embedding file found.') opt.fix_emb = False with tf.device('/cpu:0'): x_ = tf.placeholder(tf.int32, shape=[opt.batch_size, opt.maxlen], name='x_') x_mask_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.maxlen], name='x_mask_') keep_prob = tf.placeholder(tf.float32, name='keep_prob') y_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.num_class], name='y_') class_penalty_ = tf.placeholder(tf.float32, shape=()) accuracy_, loss_, train_op, W_norm_, global_step, prob_ = emb_classifier( x_, x_mask_, y_, keep_prob, opt, class_penalty_) uidx = 0 max_val_accuracy = 0. max_test_accuracy = 0. config = tf.ConfigProto( log_device_placement=False, allow_soft_placement=True, ) config.gpu_options.allow_growth = True np.set_printoptions(precision=3) np.set_printoptions(threshold=np.inf) saver = tf.train.Saver() with tf.Session(config=config) as sess: train_writer = tf.summary.FileWriter(opt.log_path + '/train', sess.graph) test_writer = tf.summary.FileWriter(opt.log_path + '/test', sess.graph) sess.run(tf.global_variables_initializer()) if opt.restore: try: t_vars = tf.trainable_variables() save_keys = tensors_key_in_file(opt.save_path) ss = set([var.name for var in t_vars]) & set( [s + ":0" for s in save_keys.keys()]) cc = {var.name: var for var in t_vars} # only restore variables with correct shape ss_right_shape = set( [s for s in ss if cc[s].get_shape() == save_keys[s[:-2]]]) loader = tf.train.Saver(var_list=[ var for var in t_vars if var.name in ss_right_shape ]) loader.restore(sess, opt.save_path) print("Loading variables from '%s'." % opt.save_path) print("Loaded variables:" + str(ss)) except: print("No saving session, using random initialization") sess.run(tf.global_variables_initializer()) try: for epoch in range(opt.max_epochs): print("Starting epoch %d" % epoch) kf = get_minibatches_idx(len(train), opt.batch_size, shuffle=True) for _, train_index in kf: uidx += 1 sents = [train[t] for t in train_index] x_labels = [train_lab[t] for t in train_index] # print(x_labels) x_labels = np.array(x_labels) x_labels = x_labels.reshape((len(x_labels), opt.num_class)) # print(x_labels) # exit() x_batch, x_batch_mask = prepare_data_for_emb(sents, opt) _, loss, step, = sess.run( [train_op, loss_, global_step], feed_dict={ x_: x_batch, x_mask_: x_batch_mask, y_: x_labels, keep_prob: opt.dropout, class_penalty_: opt.class_penalty }) if uidx % opt.valid_freq == 0: train_correct = 0.0 # sample evaluate accuaccy on 500 sample data kf_train = get_minibatches_idx(500, opt.batch_size, shuffle=True) for _, train_index in kf_train: train_sents = [train[t] for t in train_index] train_labels = [train_lab[t] for t in train_index] train_labels = np.array(train_labels) train_labels = train_labels.reshape( (len(train_labels), opt.num_class)) x_train_batch, x_train_batch_mask = prepare_data_for_emb( train_sents, opt) train_accuracy = sess.run(accuracy_, feed_dict={ x_: x_train_batch, x_mask_: x_train_batch_mask, y_: train_labels, keep_prob: 1.0, class_penalty_: 0.0 }) train_correct += train_accuracy * len(train_index) train_accuracy = train_correct / 500 print("Iteration %d: Training loss %f " % (uidx, loss)) print("Train accuracy %f " % train_accuracy) val_correct = 0.0 kf_val = get_minibatches_idx(len(val), opt.batch_size, shuffle=True) for _, val_index in kf_val: val_sents = [val[t] for t in val_index] val_labels = [val_lab[t] for t in val_index] val_labels = np.array(val_labels) val_labels = val_labels.reshape( (len(val_labels), opt.num_class)) x_val_batch, x_val_batch_mask = prepare_data_for_emb( val_sents, opt) val_accuracy = sess.run(accuracy_, feed_dict={ x_: x_val_batch, x_mask_: x_val_batch_mask, y_: val_labels, keep_prob: 1.0, class_penalty_: 0.0 }) val_correct += val_accuracy * len(val_index) val_accuracy = val_correct / len(val) print("Validation accuracy %f " % val_accuracy) if val_accuracy > max_val_accuracy: max_val_accuracy = val_accuracy # test_correct = 0.0 # # kf_test = get_minibatches_idx(len(test), opt.batch_size, shuffle=True) # for _, test_index in kf_test: # test_sents = [test[t] for t in test_index] # test_labels = [test_lab[t] for t in test_index] # test_labels = np.array(test_labels) # test_labels = test_labels.reshape((len(test_labels), opt.num_class)) # x_test_batch, x_test_batch_mask = prepare_data_for_emb(test_sents, opt) # # test_accuracy,predict_prob = sess.run([accuracy_,prob_],feed_dict={x_: x_test_batch, x_mask_: x_test_batch_mask,y_: test_labels, keep_prob: 1.0, class_penalty_: 0.0}) # print(predict_prob) # test_correct += test_accuracy * len(test_index) # # test_accuracy = test_correct / len(test) # print("Test accuracy %f " % test_accuracy) # max_test_accuracy = test_accuracy # print("Epoch %d: Max Test accuracy %f" % (epoch, max_test_accuracy)) saver.save(sess, opt.save_path, global_step=epoch) saver.save(sess, "save_model/model.ckpt") # print("Max Test accuracy %f " % max_test_accuracy) test_correct = 0.0 kf_test = get_minibatches_idx(len(test), opt.batch_size, shuffle=False) for _, test_index in kf_test: test_sents = [test[t] for t in test_index] test_labels = [test_lab[t] for t in test_index] test_labels = np.array(test_labels) test_labels = test_labels.reshape( (len(test_labels), opt.num_class)) x_test_batch, x_test_batch_mask = prepare_data_for_emb( test_sents, opt) test_accuracy, predict_prob = sess.run( [accuracy_, prob_], feed_dict={ x_: x_test_batch, x_mask_: x_test_batch_mask, y_: test_labels, keep_prob: 1.0, class_penalty_: 0.0 }) for prob in predict_prob: topnlabel_onedoc = [0] * opt.num_class for iter_topnlabel in range(opt.topnlabel): index_label = np.argwhere(prob == max(prob)) topnlabel_onedoc[index_label[0] [0]] = prob[index_label][0][0] prob[index_label] = -1 topnlabel_docwithoutlabel.append(topnlabel_onedoc) test_correct += test_accuracy * len(test_index) print(topnlabel_docwithoutlabel) test_accuracy = test_correct / len(test) print("Predict accuracy %f " % test_accuracy) max_test_accuracy = test_accuracy filename = 'test' file = open(filename, 'w') file.write(str(len(test))) file.write('\n') # print(wordtoix.get('close')) # exit() for topic_prob in topnlabel_docwithoutlabel: print(topic_prob) for prob_each_label in topic_prob: file.write(str(prob_each_label)) file.write(" ") file.write('\n') except KeyboardInterrupt: print('Training interupted') print("Max Test accuracy %f " % max_test_accuracy)
def main(): # Prepare training and testing data loadpath = "./data/" src_file = loadpath + "Pairs2M.src.num" tgt_file = loadpath + "Pairs2M.tgt.num" dic_file = loadpath + "Pairs2M.reddit.dic" opt = Options() opt_t = Options() train, val, test, wordtoix, ixtoword = read_pair_data_full( src_file, tgt_file, dic_file, max_num=opt.data_size, p_f=loadpath + 'demo.p') train = [ x for x in train if 2 < len(x[1]) < opt.maxlen - 4 and 2 < len(x[0]) < opt_t.maxlen - 4 ] val = [ x for x in val if 2 < len(x[1]) < opt.maxlen - 4 and 2 < len(x[0]) < opt_t.maxlen - 4 ] if TEST_FLAG: test = [test] opt.test_freq = 1 opt.n_words = len(ixtoword) opt_t.n_words = len(ixtoword) print dict(opt) if opt.model == 'cnn_rnn': opt_t.maxlen = opt_t.maxlen - opt_t.filter_shape + 1 opt_t.update_params() print dict(opt_t) print('Total words: %d' % opt.n_words) # load w2v if os.path.exists(opt.embedding_path_lime): with open(opt.embedding_path_lime, 'rb') as pfile: embedding = cPickle.load(pfile) else: w2v = gensim.models.KeyedVectors.load_word2vec_format( opt.embedding_path, binary=True) embedding = { i: copy.deepcopy(w2v[ixtoword[i]]) for i in range(opt.n_words) if ixtoword[i] in w2v } with open(opt.embedding_path_lime, 'wb') as pfile: cPickle.dump(embedding, pfile, protocol=cPickle.HIGHEST_PROTOCOL) for d in ['/gpu:0']: with tf.device(d): src_ = tf.placeholder(tf.int32, shape=[opt.batch_size, opt.sent_len]) tgt_ = tf.placeholder(tf.int32, shape=[opt_t.batch_size, opt_t.sent_len]) res_, gan_cost_d_, train_op_d, gan_cost_g_, train_op_g = dialog_gan( src_, tgt_, opt, opt_t) merged = tf.summary.merge_all() uidx = 0 graph_options = tf.GraphOptions(build_cost_model=1) config = tf.ConfigProto(log_device_placement=False, allow_soft_placement=True, graph_options=graph_options) config.gpu_options.per_process_gpu_memory_fraction = 0.95 np.set_printoptions(precision=3) np.set_printoptions(threshold=np.inf) saver = tf.train.Saver() run_metadata = tf.RunMetadata() with tf.Session(config=config) as sess: train_writer = tf.summary.FileWriter(opt.log_path + '/train', sess.graph) test_writer = tf.summary.FileWriter(opt.log_path + '/test', sess.graph) sess.run(tf.global_variables_initializer()) if opt.restore: try: t_vars = tf.get_collection( tf.GraphKeys.GLOBAL_VARIABLES) #tf.trainable_variables() if opt.load_from_ae: save_keys = tensors_key_in_file( opt.load_path) #t_var g_W:0 key: W ss = [ var for var in t_vars if var.name[2:][:-2] in save_keys.keys() ] ss = [ var.name[2:] for var in ss if var.get_shape() == save_keys[var.name[2:][:-2]] ] cc = { var.name[2:][:-2]: var for var in t_vars if var.name[2:] in ss } loader = tf.train.Saver(var_list=cc) loader.restore(sess, opt.load_path) print("Loading variables from '%s'." % opt.load_path) print( "Loaded variables:" + " ".join( [var.name for var in t_vars if var.name[2:] in ss])) else: save_keys = tensors_key_in_file(opt.load_path) ss = [ var for var in t_vars if var.name[:-2] in save_keys.keys() ] ss = [ var.name for var in ss if var.get_shape() == save_keys[var.name[:-2]] ] loader = tf.train.Saver( var_list=[var for var in t_vars if var.name in ss]) loader.restore(sess, opt.load_path) print("Loading variables from '%s'." % opt.load_path) print("Loaded variables:" + str(ss)) # load reverse model try: save_keys = tensors_key_in_file('./save/rev_model') ss = [ var for var in t_vars if var.name[:-2] in save_keys.keys() and 'g_rev_' in var.name ] ss = [ var.name for var in ss if var.get_shape() == save_keys[var.name[:-2]] ] loader = tf.train.Saver( var_list=[var for var in t_vars if var.name in ss]) loader.restore(sess, './save/rev_model') print( "Loading reverse variables from ./save/rev_model") print("Loaded variables:" + str(ss)) except Exception as e: print("No reverse model loaded") except Exception as e: print 'Error: ' + str(e) print("No saving session, using random initialization") sess.run(tf.global_variables_initializer()) loss_d, loss_g = 0, 0 for epoch in range(opt.max_epochs): print("Starting epoch %d" % epoch) kf = get_minibatches_idx(len(train), opt.batch_size, shuffle=True) for _, train_index in kf: uidx += 1 if uidx % opt.test_freq == 1: iter_num = np.int(np.floor(len(test) / opt.batch_size)) + 1 res_all, test_tgt_all = [], [] for i in range(iter_num): test_index = range(i * opt.batch_size, (i + 1) * opt.batch_size) test_tgt, test_src = zip( *[test[t % len(test)] for t in test_index]) test_tgt_all.extend(test_tgt) x_batch = prepare_data_for_cnn(test_src, opt) y_batch = prepare_data_for_rnn( test_tgt, opt_t, is_add_GO=False ) if opt.model == 'cnn_rnn' else prepare_data_for_cnn( test_tgt, opt_t) feed = {src_: x_batch, tgt_: y_batch} res = sess.run(res_, feed_dict=feed) res_all.extend(res['syn_sent']) test_set = [prepare_for_bleu(s) for s in test_tgt_all] gen = [prepare_for_bleu(s) for s in res_all] [bleu1s, bleu2s, bleu3s, bleu4s] = cal_BLEU_4(gen, {0: test_set}, is_corpus=opt.is_corpus) [rouge1, rouge2, rouge3, rouge4, rougeL, rouges] = cal_ROUGE(gen, {0: test_set}, is_corpus=opt.is_corpus) etp_score, dist_score = cal_entropy(gen) bleu_nltk = cal_BLEU_4_nltk(gen, test_set, is_corpus=opt.is_corpus) rel_score = cal_relevance(gen, test_set, embedding) print 'Test BLEU: ' + ' '.join([ str(round(it, 3)) for it in (bleu_nltk, bleu1s, bleu2s, bleu3s, bleu4s) ]) print 'Test Rouge: ' + ' '.join([ str(round(it, 3)) for it in (rouge1, rouge2, rouge3, rouge4) ]) print 'Test Entropy: ' + ' '.join([ str(round(it, 3)) for it in (etp_score[0], etp_score[1], etp_score[2], etp_score[3]) ]) print 'Test Diversity: ' + ' '.join([ str(round(it, 3)) for it in (dist_score[0], dist_score[1], dist_score[2], dist_score[3]) ]) print 'Test Relevance(G,A,E): ' + ' '.join([ str(round(it, 3)) for it in (rel_score[0], rel_score[1], rel_score[2]) ]) print 'Test Avg. length: ' + str( round( np.mean([ len([y for y in x if y != 0]) for x in res_all ]), 3)) print '' if TEST_FLAG: exit() tgt, src = zip(*[train[t] for t in train_index]) x_batch = prepare_data_for_cnn(src, opt) # Batch L y_batch = prepare_data_for_rnn( tgt, opt_t, is_add_GO=False ) if opt.model == 'cnn_rnn' else prepare_data_for_cnn( tgt, opt_t) feed = {src_: x_batch, tgt_: y_batch} if uidx % opt.d_freq == 1: if profile: _, loss_d = sess.run( [train_op_d, gan_cost_d_], feed_dict=feed, options=tf.RunOptions( trace_level=tf.RunOptions.FULL_TRACE), run_metadata=run_metadata) else: _, loss_d = sess.run([train_op_d, gan_cost_d_], feed_dict=feed) if uidx % opt.g_freq == 1: if profile: _, loss_g = sess.run( [train_op_g, gan_cost_g_], feed_dict=feed, options=tf.RunOptions( trace_level=tf.RunOptions.FULL_TRACE), run_metadata=run_metadata) else: _, loss_g = sess.run([train_op_g, gan_cost_g_], feed_dict=feed) if profile: tf.contrib.tfprof.model_analyzer.print_model_analysis( tf.get_default_graph(), run_meta=run_metadata, tfprof_options=tf.contrib.tfprof.model_analyzer. PRINT_ALL_TIMING_MEMORY) exit(0) if uidx % opt.valid_freq == 1: VALID_SIZE = 1024 valid_multiplier = np.int( np.floor(VALID_SIZE / opt.batch_size)) res_all, val_tgt_all, loss_val_d_all, loss_val_g_all = [], [], [], [] for val_step in range(valid_multiplier): valid_index = np.random.choice(len(val), opt.batch_size) val_tgt, val_src = zip(*[val[t] for t in valid_index]) val_tgt_all.extend(val_tgt) x_val_batch = prepare_data_for_cnn(val_src, opt) # Batch L y_val_batch = prepare_data_for_rnn( val_tgt, opt_t, is_add_GO=False ) if opt.model == 'cnn_rnn' else prepare_data_for_cnn( val_tgt, opt_t) feed_val = {src_: x_val_batch, tgt_: y_val_batch} loss_val_d, loss_val_g = sess.run( [gan_cost_d_, gan_cost_g_], feed_dict=feed_val) loss_val_d_all.append(loss_val_d) loss_val_g_all.append(loss_val_g) res = sess.run(res_, feed_dict=feed_val) res_all.extend(res['syn_sent']) print("Validation: loss D %f loss G %f " % (np.mean(loss_val_d_all), np.mean(loss_val_g_all))) #print "Val Perm :" + " ".join([ixtoword[x] for x in val_src_permutated[0] if x != 0]) print "Val Source:" + u' '.join([ ixtoword[x] for x in val_src[0] if x != 0 ]).encode('utf-8').strip() print "Val Target :" + u' '.join([ ixtoword[x] for x in val_tgt[0] if x != 0 ]).encode('utf-8').strip() print "Val Generated:" + u' '.join([ ixtoword[x] for x in res['syn_sent'][0] if x != 0 ]).encode('utf-8').strip() print "" val_set = [prepare_for_bleu(s) for s in val_tgt_all] gen = [prepare_for_bleu(s) for s in res_all] [bleu1s, bleu2s, bleu3s, bleu4s] = cal_BLEU_4(gen, {0: val_set}, is_corpus=opt.is_corpus) [rouge1, rouge2, rouge3, rouge4, rougeL, rouges] = cal_ROUGE(gen, {0: val_set}, is_corpus=opt.is_corpus) etp_score, dist_score = cal_entropy(gen) bleu_nltk = cal_BLEU_4_nltk(gen, val_set, is_corpus=opt.is_corpus) rel_score = cal_relevance(gen, val_set, embedding) print 'Val BLEU: ' + ' '.join([ str(round(it, 3)) for it in (bleu_nltk, bleu1s, bleu2s, bleu3s, bleu4s) ]) print 'Val Rouge: ' + ' '.join([ str(round(it, 3)) for it in (rouge1, rouge2, rouge3, rouge4) ]) print 'Val Entropy: ' + ' '.join([ str(round(it, 3)) for it in (etp_score[0], etp_score[1], etp_score[2], etp_score[3]) ]) print 'Val Diversity: ' + ' '.join([ str(round(it, 3)) for it in (dist_score[0], dist_score[1], dist_score[2], dist_score[3]) ]) print 'Val Relevance(G,A,E): ' + ' '.join([ str(round(it, 3)) for it in (rel_score[0], rel_score[1], rel_score[2]) ]) print 'Val Avg. length: ' + str( round( np.mean([ len([y for y in x if y != 0]) for x in res_all ]), 3)) print "" summary = sess.run(merged, feed_dict=feed_val) summary2 = tf.Summary(value=[ tf.Summary.Value(tag="bleu-2", simple_value=bleu2s), tf.Summary.Value(tag="rouge-2", simple_value=rouge2), tf.Summary.Value(tag="etp-4", simple_value=etp_score[3]) ]) test_writer.add_summary(summary, uidx) test_writer.add_summary(summary2, uidx) if uidx % opt.print_freq == 1: print("Iteration %d: loss D %f loss G %f" % (uidx, loss_d, loss_g)) res = sess.run(res_, feed_dict=feed) if opt.grad_penalty: print "grad_penalty: " + str(res['gp']) print "Source:" + u' '.join([ ixtoword[x] for x in x_batch[0] if x != 0 ]).encode('utf-8').strip() print "Target:" + u' '.join([ ixtoword[x] for x in y_batch[0] if x != 0 ]).encode('utf-8').strip() print "Generated:" + u' '.join([ ixtoword[x] for x in res['syn_sent'][0] if x != 0 ]).encode('utf-8').strip() print "" sys.stdout.flush() summary = sess.run(merged, feed_dict=feed) train_writer.add_summary(summary, uidx) if uidx % opt.save_freq == 1: saver.save(sess, opt.save_path)
def main(): opt = Options() vocabulary_word2index, vocabulary_index2word, vocabulary_label2index, vocabulary_index2label = create_vocabulary( "data/atec_nlp_sim_train2.csv", opt.vocab_size, name_scope=opt.name_scope, tokenize_style=opt.tokenize_style) vocab_size = len(vocabulary_word2index) print("vocab_size:", vocab_size) num_classes = len(vocabulary_index2label) print("num_classes:", num_classes) with open("./cache_SWEM_1/train_valid_test.pik") as f: train, valid, test, true_label_percent = pickle.load(f) train_q, train_a, _, train_lab = train print("train_nums:", len(train_q)) val_q, val_a, _, val_lab = valid test_q, test_a, _, test_lab = test wordtoix = vocabulary_word2index ixtoword = vocabulary_index2word opt.n_words = len(ixtoword) # loadpath = "./data/snli.p" # x = cPickle.load(open(loadpath, "rb")) # # train, val, test = x[0], x[1], x[2] # wordtoix, ixtoword = x[4], x[5] # # train_q, train_a, train_lab = train[0], train[1], train[2] # val_q, val_a, val_lab = val[0], val[1], val[2] # test_q, test_a, test_lab = test[0], test[1], test[2] # # train_lab = np.array(train_lab, dtype='float32') # val_lab = np.array(val_lab, dtype='float32') # test_lab = np.array(test_lab, dtype='float32') # # opt = Options() # opt.n_words = len(ixtoword) # # del x print(dict(opt)) print('Total words: %d' % opt.n_words) #若partially use labeled data则进行以下操作,这部分操作什么意思? # 目前猜测part_data设置为True时只利用部分训练集,portion就是保留的训练集大小,应该是用于测试模型阶段使用的 if opt.part_data: np.random.seed(123) train_ind = np.random.choice(len(train_q), int(len(train_q) * opt.portion), replace=False) train_q = [train_q[t] for t in train_ind] train_a = [train_a[t] for t in train_ind] train_lab = [train_lab[t] for t in train_ind] #验证训练集和预处理好的词嵌入文件是否对齐 try: params = np.load('./data/snli_emb.p') if params[0].shape == (opt.n_words, opt.embed_size): print('Use saved embedding.') #pdb.set_trace() opt.W_emb = np.array(params[0], dtype='float32') else: print('Emb Dimension mismatch: param_g.npz:' + str(params[0].shape) + ' opt: ' + str((opt.n_words, opt.embed_size))) opt.fix_emb = False except IOError: print('No embedding file found.') opt.fix_emb = False with tf.device('/gpu:0'): #注意训练数据是两批句子,所以x的占位符要成对定义 x_1_ = tf.placeholder(tf.int32, shape=[opt.batch_size, opt.maxlen]) x_2_ = tf.placeholder(tf.int32, shape=[opt.batch_size, opt.maxlen]) x_mask_1_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.maxlen]) x_mask_2_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.maxlen]) y_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.category]) keep_prob = tf.placeholder(tf.float32) #auto_encoder就是模型的定义、模型运行过程中的所有tensor,这个项目将其封装起来了,很值得借鉴的工程技巧 # 返回的是一些重要的tensor,后面sess.run的时候作为参数传入 accuracy_, loss_, train_op_, W_emb, logits_ = auto_encoder( x_1_, x_2_, x_mask_1_, x_mask_2_, y_, keep_prob, opt) merged = tf.summary.merge_all() def do_eval(sess, train_q, train_a, train_lab): train_correct = 0.0 # number_examples = len(train_q) # print("valid examples:", number_examples) eval_loss, eval_accc, eval_counter = 0.0, 0.0, 0 eval_true_positive, eval_false_positive, eval_true_negative, eval_false_negative = 0, 0, 0, 0 # batch_size = 1 weights_label = {} # weight_label[label_index]=(number,correct) weights = np.ones((opt.batch_size)) kf_train = get_minibatches_idx(len(train_q), opt.batch_size, shuffle=True) for _, train_index in kf_train: train_sents_1 = [train_q[t] for t in train_index] train_sents_2 = [train_a[t] for t in train_index] train_labels = [train_lab[t] for t in train_index] train_labels_array = np.array(train_labels) # print("train_labels", train_labels.shape) # train_labels = train_labels.reshape((len(train_labels), opt.category)) train_labels = np.eye(opt.category)[train_labels_array] x_train_batch_1, x_train_mask_1 = prepare_data_for_emb( train_sents_1, opt) x_train_batch_2, x_train_mask_2 = prepare_data_for_emb( train_sents_2, opt) curr_eval_loss, curr_accc, logits = sess.run( [loss_, accuracy_, logits_], feed_dict={ x_1_: x_train_batch_1, x_2_: x_train_batch_2, x_mask_1_: x_train_mask_1, x_mask_2_: x_train_mask_2, y_: train_labels, opt.weights_label: weights, keep_prob: 1.0 }) true_positive, false_positive, true_negative, false_negative = compute_confuse_matrix( logits, train_labels ) # logits:[batch_size,label_size]-->logits[0]:[label_size] # write_predict_error_to_file(start,file_object,logits[0], evalY[start:end][0],vocabulary_index2word,evalX1[start:end],evalX2[start:end]) eval_loss, eval_accc, eval_counter = eval_loss + curr_eval_loss, eval_accc + curr_accc, eval_counter + 1 # 注意这里计算loss和accc的方法,计算累加值,然后归一化 weights_label = compute_labels_weights( weights_label, logits, train_labels_array ) # compute_labels_weights(weights_label,logits,labels) eval_true_positive, eval_false_positive = eval_true_positive + true_positive, eval_false_positive + false_positive eval_true_negative, eval_false_negative = eval_true_negative + true_negative, eval_false_negative + false_negative # weights_label = compute_labels_weights(weights_label, logits, evalY[start:end]) #compute_labels_weights(weights_label,logits,labels) print("true_positive:", eval_true_positive, ";false_positive:", eval_false_positive, ";true_negative:", eval_true_negative, ";false_negative:", eval_false_negative) p = float(eval_true_positive) / float(eval_true_positive + eval_false_positive) r = float(eval_true_positive) / float(eval_true_positive + eval_false_negative) f1_score = (2 * p * r) / (p + r) print("eval_counter:", eval_counter, ";eval_acc:", eval_accc) return eval_loss / float(eval_counter), eval_accc / float( eval_counter), f1_score, p, r, weights_label max_val_accuracy = 0. max_test_accuracy = 0. weights_dict = init_weights_dict( vocabulary_label2index) # init weights dict. # gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1) config = tf.ConfigProto(log_device_placement=False, allow_soft_placement=True) config.gpu_options.allow_growth = True np.set_printoptions(precision=3) np.set_printoptions(threshold=np.inf) saver = tf.train.Saver() with tf.Session(config=config) as sess: train_writer = tf.summary.FileWriter(opt.log_path + '/train', sess.graph) test_writer = tf.summary.FileWriter(opt.log_path + '/test', sess.graph) sess.run(tf.global_variables_initializer()) if opt.restore: #若使用已保存好的参数 try: #pdb.set_trace() t_vars = tf.trainable_variables() # print([var.name[:-2] for var in t_vars]) save_keys = tensors_key_in_file(opt.save_path) # pdb.set_trace() # print(save_keys.keys()) ss = set([var.name for var in t_vars]) & set( [s + ":0" for s in save_keys.keys()]) cc = {var.name: var for var in t_vars} #pdb.set_trace() # only restore variables with correct shape ss_right_shape = set( [s for s in ss if cc[s].get_shape() == save_keys[s[:-2]]]) loader = tf.train.Saver(var_list=[ var for var in t_vars if var.name in ss_right_shape ]) loader.restore(sess, opt.save_path) print("Loading variables from '%s'." % opt.save_path) print("Loaded variables:" + str(ss)) except: print("No saving session, using random initialization") sess.run(tf.global_variables_initializer()) try: best_acc = 0 best_f1_score = 0 for epoch in range(opt.max_epochs): print("Starting epoch %d" % epoch) loss, acc, uidx = 0.0, 0.0, 0.0 kf = get_minibatches_idx(len(train_q), opt.batch_size, shuffle=True) #随机创建minibatch数据 for _, train_index in kf: uidx += 1 sents_1 = [train_q[t] for t in train_index] #根据索引回到总数据集中寻找相应数据 sents_2 = [train_a[t] for t in train_index] x_labels = [train_lab[t] for t in train_index] x_labels_array = np.array(x_labels) # print("x_labels:", x_labels.shape) # 为何要在这里进行reshape,是想进行onehot操作?但是这明显是错误的,((len(x_labels),))怎么能reshape成((len(x_labels),opt.category)) # x_labels = x_labels.reshape((len(x_labels),opt.category)) # one-hot向量化 x_labels = np.eye(opt.category)[x_labels_array] #prepare_data_for_emb函数的作用是什么?初步猜测是把sents中每一个单词替换成相应的索引,然后才能根据索引获取词向量 x_batch_1, x_batch_mask_1 = prepare_data_for_emb( sents_1, opt) x_batch_2, x_batch_mask_2 = prepare_data_for_emb( sents_2, opt) weights = get_weights_for_current_batch( list(x_labels_array), weights_dict) _, curr_loss, curr_accuracy = sess.run( [train_op_, loss_, accuracy_], feed_dict={ x_1_: x_batch_1, x_2_: x_batch_2, x_mask_1_: x_batch_mask_1, x_mask_2_: x_batch_mask_2, y_: x_labels, opt.weights_label: weights, keep_prob: opt.dropout_ratio }) loss, acc = loss + curr_loss, acc + curr_accuracy if uidx % 100 == 0: print( "Epoch %d\tBatch %d\tTrain Loss:%.3f\tAcc:%.3f\t" % (epoch, uidx, loss / float(uidx), acc / float(uidx))) if epoch % 1 == 0: # do_eval参数待修改 eval_loss, eval_accc, f1_scoree, precision, recall, weights_label = do_eval( sess, train_q, train_a, train_lab) weights_dict = get_weights_label_as_standard_dict( weights_label) # print("label accuracy(used for label weight):==========>>>>", weights_dict) print( "【Validation】Epoch %d\t Loss:%.3f\tAcc %.3f\tF1 Score:%.3f\tPrecision:%.3f\tRecall:%.3f" % (epoch, eval_loss, eval_accc, f1_scoree, precision, recall)) # save model to checkpoint if eval_accc > best_acc and f1_scoree > best_f1_score: save_path = opt.ckpt_dir + "/model.ckpt" print("going to save model. eval_f1_score:", f1_scoree, ";previous best f1 score:", best_f1_score, ";eval_acc", str(eval_accc), ";previous best_acc:", str(best_acc)) saver.save(sess, save_path, global_step=epoch) best_acc = eval_accc best_f1_score = f1_scoree test_loss, acc_t, f1_score_t, precision, recall, weights_label = do_eval( sess, test_q, test_a, test_lab) print( "Test Loss:%.3f\tAcc:%.3f\tF1 Score:%.3f\tPrecision:%.3f\tRecall:%.3f:" % (test_loss, acc_t, f1_score_t, precision, recall)) #每训练valid_freq个minibatch就在训练集、验证集和测试集上计算准确率,并更新最优测试集准确率 # if uidx % opt.valid_freq == 0: # train_correct = 0.0 # kf_train = get_minibatches_idx(len(train_q), opt.batch_size, shuffle=True) # for _, train_index in kf_train: # train_sents_1 = [train_q[t] for t in train_index] # train_sents_2 = [train_a[t] for t in train_index] # train_labels = [train_lab[t] for t in train_index] # train_labels = np.array(train_labels) # # print("train_labels", train_labels.shape) # # train_labels = train_labels.reshape((len(train_labels), opt.category)) # train_labels = np.eye(opt.category)[train_labels] # x_train_batch_1, x_train_mask_1 = prepare_data_for_emb(train_sents_1, opt) # x_train_batch_2, x_train_mask_2 = prepare_data_for_emb(train_sents_2, opt) # # train_accuracy = sess.run(accuracy_, # feed_dict={x_1_: x_train_batch_1, x_2_: x_train_batch_2, x_mask_1_: x_train_mask_1, x_mask_2_: x_train_mask_2, # y_: train_labels, keep_prob: 1.0}) # # train_correct += train_accuracy * len(train_index) # # train_accuracy = train_correct / len(train_q) # # # print("Iteration %d: Training loss %f, dis loss %f, rec loss %f" % (uidx, # # loss, dis_loss, rec_loss)) # print("Train accuracy %f " % train_accuracy) # # val_correct = 0.0 # is_train = True # kf_val = get_minibatches_idx(len(val_q), opt.batch_size, shuffle=True) # for _, val_index in kf_val: # val_sents_1 = [val_q[t] for t in val_index] # val_sents_2 = [val_a[t] for t in val_index] # val_labels = [val_lab[t] for t in val_index] # val_labels = np.array(val_labels) # # val_labels = val_labels.reshape((len(val_labels), opt.category)) # val_labels = np.eye(opt.category)[val_labels] # x_val_batch_1, x_val_mask_1 = prepare_data_for_emb(val_sents_1, opt) # x_val_batch_2, x_val_mask_2 = prepare_data_for_emb(val_sents_2, opt) # # val_accuracy = sess.run(accuracy_, feed_dict={x_1_: x_val_batch_1, x_2_: x_val_batch_2, # x_mask_1_: x_val_mask_1, x_mask_2_: x_val_mask_2, y_: val_labels, keep_prob: 1.0}) # # val_correct += val_accuracy * len(val_index) # # val_accuracy = val_correct / len(val_q) # # print("Validation accuracy %f " % val_accuracy) # # if val_accuracy > max_val_accuracy: # max_val_accuracy = val_accuracy # # test_correct = 0.0 # kf_test = get_minibatches_idx(len(test_q), opt.batch_size, shuffle=True) # for _, test_index in kf_test: # test_sents_1 = [test_q[t] for t in test_index] # test_sents_2 = [test_a[t] for t in test_index] # test_labels = [test_lab[t] for t in test_index] # test_labels = np.array(test_labels) # # test_labels = test_labels.reshape((len(test_labels), opt.category)) # test_labels = np.eye(opt.category)[test_labels] # x_test_batch_1, x_test_mask_1 = prepare_data_for_emb(test_sents_1, opt) # x_test_batch_2, x_test_mask_2 = prepare_data_for_emb(test_sents_2, opt) # # test_accuracy = sess.run(accuracy_, feed_dict={x_1_: x_test_batch_1, x_2_: x_test_batch_2, # x_mask_1_: x_test_mask_1, x_mask_2_: x_test_mask_2, # y_: test_labels, keep_prob: 1.0}) # # test_correct += test_accuracy * len(test_index) # # test_accuracy = test_correct / len(test_q) # # print("Test accuracy %f " % test_accuracy) # # max_test_accuracy = test_accuracy # # print("Epoch %d: Max Test accuracy %f" % (epoch, max_test_accuracy)) # # print("Max Test accuracy %f " % max_test_accuracy) except KeyboardInterrupt: print('Training interupted') print("Max Test accuracy %f " % max_test_accuracy)
def main(): loadpath = "./data/snli.p" x = cPickle.load(open(loadpath, "rb")) train, val, test = x[0], x[1], x[2] wordtoix, ixtoword = x[4], x[5] train_q, train_a, train_lab = train[0], train[1], train[2] val_q, val_a, val_lab = val[0], val[1], val[2] test_q, test_a, test_lab = test[0], test[1], test[2] train_lab = np.array(train_lab, dtype='float32') val_lab = np.array(val_lab, dtype='float32') test_lab = np.array(test_lab, dtype='float32') opt = Options() opt.n_words = len(ixtoword) del x print(dict(opt)) print('Total words: %d' % opt.n_words) if opt.part_data: np.random.seed(123) train_ind = np.random.choice(len(train_q), int(len(train_q)*opt.portion), replace=False) train_q = [train_q[t] for t in train_ind] train_a = [train_a[t] for t in train_ind] train_lab = [train_lab[t] for t in train_ind] try: params = np.load('./data/snli_emb.p') if params[0].shape == (opt.n_words, opt.embed_size): print('Use saved embedding.') #pdb.set_trace() opt.W_emb = np.array(params[0], dtype='float32') else: print('Emb Dimension mismatch: param_g.npz:' + str(params[0].shape) + ' opt: ' + str( (opt.n_words, opt.embed_size))) opt.fix_emb = False except IOError: print('No embedding file found.') opt.fix_emb = False with tf.device('/gpu:1'): x_1_ = tf.placeholder(tf.int32, shape=[opt.batch_size, opt.maxlen]) x_2_ = tf.placeholder(tf.int32, shape=[opt.batch_size, opt.maxlen]) x_mask_1_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.maxlen]) x_mask_2_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.maxlen]) y_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.category]) keep_prob = tf.placeholder(tf.float32) accuracy_, loss_, train_op_, W_emb_ = auto_encoder(x_1_, x_2_, x_mask_1_, x_mask_2_, y_, keep_prob, opt) merged = tf.summary.merge_all() uidx = 0 max_val_accuracy = 0. max_test_accuracy = 0. # gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1) config = tf.ConfigProto(log_device_placement=False, allow_soft_placement=True) config.gpu_options.allow_growth = True np.set_printoptions(precision=3) np.set_printoptions(threshold=np.inf) saver = tf.train.Saver() with tf.Session(config=config) as sess: train_writer = tf.summary.FileWriter(opt.log_path + '/train', sess.graph) test_writer = tf.summary.FileWriter(opt.log_path + '/test', sess.graph) sess.run(tf.global_variables_initializer()) if opt.restore: try: #pdb.set_trace() t_vars = tf.trainable_variables() # print([var.name[:-2] for var in t_vars]) save_keys = tensors_key_in_file(opt.save_path) # pdb.set_trace() # print(save_keys.keys()) ss = set([var.name for var in t_vars]) & set([s + ":0" for s in save_keys.keys()]) cc = {var.name: var for var in t_vars} #pdb.set_trace() # only restore variables with correct shape ss_right_shape = set([s for s in ss if cc[s].get_shape() == save_keys[s[:-2]]]) loader = tf.train.Saver(var_list=[var for var in t_vars if var.name in ss_right_shape]) loader.restore(sess, opt.save_path) print("Loading variables from '%s'." % opt.save_path) print("Loaded variables:" + str(ss)) except: print("No saving session, using random initialization") sess.run(tf.global_variables_initializer()) try: for epoch in range(opt.max_epochs): print("Starting epoch %d" % epoch) kf = get_minibatches_idx(len(train_q), opt.batch_size, shuffle=True) for _, train_index in kf: uidx += 1 sents_1 = [train_q[t] for t in train_index] sents_2 = [train_a[t] for t in train_index] x_labels = [train_lab[t] for t in train_index] x_labels = np.array(x_labels) x_labels = x_labels.reshape((len(x_labels), opt.category)) x_batch_1, x_batch_mask_1 = prepare_data_for_emb(sents_1, opt) x_batch_2, x_batch_mask_2 = prepare_data_for_emb(sents_2, opt) _, loss = sess.run([train_op_, loss_], feed_dict={x_1_: x_batch_1, x_2_: x_batch_2, x_mask_1_: x_batch_mask_1, x_mask_2_: x_batch_mask_2, y_: x_labels, keep_prob: opt.dropout_ratio}) if uidx % opt.valid_freq == 0: train_correct = 0.0 kf_train = get_minibatches_idx(3070, opt.batch_size, shuffle=True) for _, train_index in kf_train: train_sents_1 = [train_q[t] for t in train_index] train_sents_2 = [train_a[t] for t in train_index] train_labels = [train_lab[t] for t in train_index] train_labels = np.array(train_labels) train_labels = train_labels.reshape((len(train_labels), opt.category)) x_train_batch_1, x_train_mask_1 = prepare_data_for_emb(train_sents_1, opt) x_train_batch_2, x_train_mask_2 = prepare_data_for_emb(train_sents_2, opt) train_accuracy = sess.run(accuracy_, feed_dict={x_1_: x_train_batch_1, x_2_: x_train_batch_2, x_mask_1_: x_train_mask_1, x_mask_2_: x_train_mask_2, y_: train_labels, keep_prob: 1.0}) train_correct += train_accuracy * len(train_index) train_accuracy = train_correct / 3070 # print("Iteration %d: Training loss %f, dis loss %f, rec loss %f" % (uidx, # loss, dis_loss, rec_loss)) print("Train accuracy %f " % train_accuracy) val_correct = 0.0 is_train = True kf_val = get_minibatches_idx(len(val_q), opt.batch_size, shuffle=True) for _, val_index in kf_val: val_sents_1 = [val_q[t] for t in val_index] val_sents_2 = [val_a[t] for t in val_index] val_labels = [val_lab[t] for t in val_index] val_labels = np.array(val_labels) val_labels = val_labels.reshape((len(val_labels), opt.category)) x_val_batch_1, x_val_mask_1 = prepare_data_for_emb(val_sents_1, opt) x_val_batch_2, x_val_mask_2 = prepare_data_for_emb(val_sents_2, opt) val_accuracy = sess.run(accuracy_, feed_dict={x_1_: x_val_batch_1, x_2_: x_val_batch_2, x_mask_1_: x_val_mask_1, x_mask_2_: x_val_mask_2, y_: val_labels, keep_prob: 1.0}) val_correct += val_accuracy * len(val_index) val_accuracy = val_correct / len(val_q) print("Validation accuracy %f " % val_accuracy) if val_accuracy > max_val_accuracy: max_val_accuracy = val_accuracy test_correct = 0.0 kf_test = get_minibatches_idx(len(test_q), opt.batch_size, shuffle=True) for _, test_index in kf_test: test_sents_1 = [test_q[t] for t in test_index] test_sents_2 = [test_a[t] for t in test_index] test_labels = [test_lab[t] for t in test_index] test_labels = np.array(test_labels) test_labels = test_labels.reshape((len(test_labels), opt.category)) x_test_batch_1, x_test_mask_1 = prepare_data_for_emb(test_sents_1, opt) x_test_batch_2, x_test_mask_2 = prepare_data_for_emb(test_sents_2, opt) test_accuracy = sess.run(accuracy_, feed_dict={x_1_: x_test_batch_1, x_2_: x_test_batch_2, x_mask_1_: x_test_mask_1, x_mask_2_: x_test_mask_2, y_: test_labels, keep_prob: 1.0}) test_correct += test_accuracy * len(test_index) test_accuracy = test_correct / len(test_q) print("Test accuracy %f " % test_accuracy) max_test_accuracy = test_accuracy print("Epoch %d: Max Test accuracy %f" % (epoch, max_test_accuracy)) print("Max Test accuracy %f " % max_test_accuracy) except KeyboardInterrupt: print('Training interupted') print("Max Test accuracy %f " % max_test_accuracy)
def main(): loadpath = "./data/snli.p" x = cPickle.load(open(loadpath, "rb")) train, val, test = x[0], x[1], x[2] wordtoix, ixtoword = x[4], x[5] train_q, train_a, train_lab = train[0], train[1], train[2] val_q, val_a, val_lab = val[0], val[1], val[2] test_q, test_a, test_lab = test[0], test[1], test[2] train_lab = np.array(train_lab, dtype='float32') val_lab = np.array(val_lab, dtype='float32') test_lab = np.array(test_lab, dtype='float32') opt = Options() opt.n_words = len(ixtoword) del x print(dict(opt)) print('Total words: %d' % opt.n_words) #若partially use labeled data则进行以下操作,这部分操作什么意思? # 目前猜测part_data设置为True时只利用部分训练集,portion就是保留的训练集大小 if opt.part_data: np.random.seed(123) train_ind = np.random.choice(len(train_q), int(len(train_q) * opt.portion), replace=False) train_q = [train_q[t] for t in train_ind] train_a = [train_a[t] for t in train_ind] train_lab = [train_lab[t] for t in train_ind] #验证训练集和预处理好的词嵌入文件是否对齐 try: params = np.load('./data/snli_emb.p') if params[0].shape == (opt.n_words, opt.embed_size): print('Use saved embedding.') #pdb.set_trace() opt.W_emb = np.array(params[0], dtype='float32') else: print('Emb Dimension mismatch: param_g.npz:' + str(params[0].shape) + ' opt: ' + str((opt.n_words, opt.embed_size))) opt.fix_emb = False except IOError: print('No embedding file found.') opt.fix_emb = False with tf.device('/gpu:1'): #注意训练数据是两批句子,所以x的占位符要成对定义 x_1_ = tf.placeholder(tf.int32, shape=[opt.batch_size, opt.maxlen]) x_2_ = tf.placeholder(tf.int32, shape=[opt.batch_size, opt.maxlen]) x_mask_1_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.maxlen]) x_mask_2_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.maxlen]) y_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.category]) keep_prob = tf.placeholder(tf.float32) #auto_encoder就是模型的定义、模型运行过程中的所有tensor,这个项目将其封装起来了,很值得借鉴的工程技巧 # 返回的是一些重要的tensor,后面sess.run的时候作为参数传入 accuracy_, loss_, train_op_, W_emb_ = auto_encoder( x_1_, x_2_, x_mask_1_, x_mask_2_, y_, keep_prob, opt) merged = tf.summary.merge_all() uidx = 0 max_val_accuracy = 0. max_test_accuracy = 0. # gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1) config = tf.ConfigProto(log_device_placement=False, allow_soft_placement=True) config.gpu_options.allow_growth = True np.set_printoptions(precision=3) np.set_printoptions(threshold=np.inf) saver = tf.train.Saver() with tf.Session(config=config) as sess: train_writer = tf.summary.FileWriter(opt.log_path + '/train', sess.graph) test_writer = tf.summary.FileWriter(opt.log_path + '/test', sess.graph) sess.run(tf.global_variables_initializer()) if opt.restore: #若使用已保存好的参数 try: #pdb.set_trace() t_vars = tf.trainable_variables() # print([var.name[:-2] for var in t_vars]) save_keys = tensors_key_in_file(opt.save_path) # pdb.set_trace() # print(save_keys.keys()) ss = set([var.name for var in t_vars]) & set( [s + ":0" for s in save_keys.keys()]) cc = {var.name: var for var in t_vars} #pdb.set_trace() # only restore variables with correct shape ss_right_shape = set( [s for s in ss if cc[s].get_shape() == save_keys[s[:-2]]]) loader = tf.train.Saver(var_list=[ var for var in t_vars if var.name in ss_right_shape ]) loader.restore(sess, opt.save_path) print("Loading variables from '%s'." % opt.save_path) print("Loaded variables:" + str(ss)) except: print("No saving session, using random initialization") sess.run(tf.global_variables_initializer()) try: for epoch in range(opt.max_epochs): print("Starting epoch %d" % epoch) kf = get_minibatches_idx(len(train_q), opt.batch_size, shuffle=True) #随机创建minibatch数据 for _, train_index in kf: uidx += 1 sents_1 = [train_q[t] for t in train_index] #根据索引回到总数据集中寻找相应数据 sents_2 = [train_a[t] for t in train_index] x_labels = [train_lab[t] for t in train_index] x_labels = np.array(x_labels) print("x_labels:", x_labels.shape) x_labels = x_labels.reshape( (len(x_labels), opt.category)) #返回one-hot向量? #prepare_data_for_emb函数的作用是什么?初步猜测是把sents中每一个单词替换成相应的索引,然后才能根据索引获取词向量 x_batch_1, x_batch_mask_1 = prepare_data_for_emb( sents_1, opt) x_batch_2, x_batch_mask_2 = prepare_data_for_emb( sents_2, opt) _, loss = sess.run( [train_op_, loss_], feed_dict={ x_1_: x_batch_1, x_2_: x_batch_2, x_mask_1_: x_batch_mask_1, x_mask_2_: x_batch_mask_2, y_: x_labels, keep_prob: opt.dropout_ratio }) #每训练valid_freq个minibatch就在训练集、验证集和测试集上计算准确率,并更新最优测试集准确率 if uidx % opt.valid_freq == 0: train_correct = 0.0 kf_train = get_minibatches_idx(3070, opt.batch_size, shuffle=True) for _, train_index in kf_train: train_sents_1 = [train_q[t] for t in train_index] train_sents_2 = [train_a[t] for t in train_index] train_labels = [train_lab[t] for t in train_index] train_labels = np.array(train_labels) train_labels = train_labels.reshape( (len(train_labels), opt.category)) x_train_batch_1, x_train_mask_1 = prepare_data_for_emb( train_sents_1, opt) x_train_batch_2, x_train_mask_2 = prepare_data_for_emb( train_sents_2, opt) train_accuracy = sess.run(accuracy_, feed_dict={ x_1_: x_train_batch_1, x_2_: x_train_batch_2, x_mask_1_: x_train_mask_1, x_mask_2_: x_train_mask_2, y_: train_labels, keep_prob: 1.0 }) train_correct += train_accuracy * len(train_index) train_accuracy = train_correct / 3070 # print("Iteration %d: Training loss %f, dis loss %f, rec loss %f" % (uidx, # loss, dis_loss, rec_loss)) print("Train accuracy %f " % train_accuracy) val_correct = 0.0 is_train = True kf_val = get_minibatches_idx(len(val_q), opt.batch_size, shuffle=True) for _, val_index in kf_val: val_sents_1 = [val_q[t] for t in val_index] val_sents_2 = [val_a[t] for t in val_index] val_labels = [val_lab[t] for t in val_index] val_labels = np.array(val_labels) val_labels = val_labels.reshape( (len(val_labels), opt.category)) x_val_batch_1, x_val_mask_1 = prepare_data_for_emb( val_sents_1, opt) x_val_batch_2, x_val_mask_2 = prepare_data_for_emb( val_sents_2, opt) val_accuracy = sess.run(accuracy_, feed_dict={ x_1_: x_val_batch_1, x_2_: x_val_batch_2, x_mask_1_: x_val_mask_1, x_mask_2_: x_val_mask_2, y_: val_labels, keep_prob: 1.0 }) val_correct += val_accuracy * len(val_index) val_accuracy = val_correct / len(val_q) print("Validation accuracy %f " % val_accuracy) if val_accuracy > max_val_accuracy: max_val_accuracy = val_accuracy test_correct = 0.0 kf_test = get_minibatches_idx(len(test_q), opt.batch_size, shuffle=True) for _, test_index in kf_test: test_sents_1 = [test_q[t] for t in test_index] test_sents_2 = [test_a[t] for t in test_index] test_labels = [test_lab[t] for t in test_index] test_labels = np.array(test_labels) test_labels = test_labels.reshape( (len(test_labels), opt.category)) x_test_batch_1, x_test_mask_1 = prepare_data_for_emb( test_sents_1, opt) x_test_batch_2, x_test_mask_2 = prepare_data_for_emb( test_sents_2, opt) test_accuracy = sess.run(accuracy_, feed_dict={ x_1_: x_test_batch_1, x_2_: x_test_batch_2, x_mask_1_: x_test_mask_1, x_mask_2_: x_test_mask_2, y_: test_labels, keep_prob: 1.0 }) test_correct += test_accuracy * len(test_index) test_accuracy = test_correct / len(test_q) print("Test accuracy %f " % test_accuracy) max_test_accuracy = test_accuracy print("Epoch %d: Max Test accuracy %f" % (epoch, max_test_accuracy)) print("Max Test accuracy %f " % max_test_accuracy) except KeyboardInterrupt: print('Training interupted') print("Max Test accuracy %f " % max_test_accuracy)
def main(): # Prepare training and testing data opt = Options() main_Path = '/home/dell/桌面/GG/TDD/keyword/Our_method/dataset/' # load data if opt.dataset == 'yahoo': loadpath = "/home/dell/PycharmProjects/NLP/Idea-1/New_leam_dataset/yahoo.p" embpath = "/home/dell/PycharmProjects/NLP/Idea-1/New_leam_dataset/yahoo_glove.p" load_G_path = '/home/dell/PycharmProjects/NLP/Idea-1/Results/yahoo/08/cnn/yahoo_G.pickle' opt.num_class = 10 opt.class_name = ['Society Culture', 'Science Mathematics', 'Health', 'Education Reference', 'Computers Internet', 'Sports', 'Business Finance', 'Entertainment Music', 'Family Relationships', 'Politics Government'] elif opt.dataset == 'agnews': loadpath = "/home/dell/PycharmProjects/NLP/Idea-1/New_leam_dataset/ag_news.pickle" embpath = "/home/dell/PycharmProjects/NLP/Idea-1/New_leam_dataset/ag_news_glove.pickle" load_G_path = '/home/dell/PycharmProjects/NLP/Idea-1/Results/ag_news/08/cnn/ag_news_G.pickle' opt.num_class = 4 opt.class_name = ['World', 'Sports', 'Business', 'Science'] elif opt.dataset == 'dbpedia': loadpath = "/home/dell/PycharmProjects/NLP/Idea-1/New_leam_dataset/dbpedia.pickle" embpath = "/home/dell/PycharmProjects/NLP/Idea-1/New_leam_dataset/dbpedia_glove.pickle" load_G_path = '/home/dell/PycharmProjects/NLP/Idea-1/Results/dbpedia/08/cnn/dbpedia_G.pickle' opt.num_class = 14 opt.class_name = ['Company', 'Educational Institution', 'Artist', 'Athlete', 'Office Holder', 'Mean Of Transportation', 'Building', 'Natural Place', 'Village', 'Animal', 'Plant', 'Album', 'Film', 'Written Work', ] elif opt.dataset == 'yelp_full': loadpath = "/home/dell/PycharmProjects/NLP/Idea-1/New_leam_dataset/yelp_full.pickle" embpath = "/home/dell/PycharmProjects/NLP/Idea-1/New_leam_dataset/yelp_full_glove.pickle" load_G_path = '/home/dell/PycharmProjects/NLP/Idea-1/Results/yelp_full/08/cnn/yelp_full_G.pickle' opt.num_class = 5 opt.class_name = ['worst', 'bad', 'middle', 'good', 'best'] elif opt.dataset == 'yelp': loadpath = "/home/dell/PycharmProjects/NLP/Idea-1/New_leam_dataset/yelp.pickle" embpath = "/home/dell/PycharmProjects/NLP/Idea-1/New_leam_dataset/yelp_glove.pickle" load_G_path = '/home/dell/PycharmProjects/NLP/Idea-1/Results/yelp/08/cnn/yelp_G.pickle' opt.num_class = 2 opt.class_name = ['bad', 'good'] x = pickle.load(open(loadpath, "rb")) train, val, test = x[0], x[1], x[2] #将单词由数字表示,已做了分词工作,且句子长度尚未统一 train_lab, val_lab, test_lab = x[3], x[4], x[5]#label 采用one-hot编码形式表示 wordtoix, ixtoword = x[6], x[7] #加载权重G G_train, G_val, G_test = pickle.load(open(load_G_path, "rb")) del x print("load data finished") train_lab = np.array(train_lab, dtype='float32') val_lab = np.array(val_lab, dtype='float32') test_lab = np.array(test_lab, dtype='float32') opt.n_words = len(ixtoword) if opt.part_data: #np.random.seed(123) train_ind = np.random.choice(len(train), int(len(train)*opt.portion), replace=False) train = [train[t] for t in train_ind] train_lab = [train_lab[t] for t in train_ind] os.environ['CUDA_VISIBLE_DEVICES'] = str(opt.GPUID) print(dict(opt)) print('Total words: %d' % opt.n_words) try: opt.W_emb = np.array(pickle.load(open(embpath, 'rb')),dtype='float32') opt.W_class_emb = load_class_embedding( wordtoix, opt) except IOError: print('No embedding file found.') opt.fix_emb = False with tf.device('/gpu:1'): x_ = tf.placeholder(tf.int32, shape=[opt.batch_size, opt.maxlen],name='x_') x_mask_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.maxlen],name='x_mask_') keep_prob = tf.placeholder(tf.float32,name='keep_prob') y_ = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.num_class],name='y_') class_penalty_ = tf.placeholder(tf.float32, shape=()) G_our = tf.placeholder(tf.float32, shape=[opt.batch_size, opt.maxlen, opt.num_class], name='G_our') seq_len = tf.placeholder(tf.int32, shape=[opt.batch_size], name='sque_sentence_num') accuracy_, loss_, train_op, W_norm_, global_step = emb_classifier(x_, x_mask_, y_, keep_prob, opt, class_penalty_, G_our, seq_len) uidx = 0 max_val_accuracy = 0. max_test_accuracy = 0. val_acc = 0. config = tf.ConfigProto(log_device_placement=False, allow_soft_placement=True, ) config.gpu_options.allow_growth = True np.set_printoptions(precision=3) np.set_printoptions(threshold=np.inf) saver = tf.train.Saver() with tf.Session(config=config) as sess: train_writer = tf.summary.FileWriter(opt.log_path + '/train', sess.graph) test_writer = tf.summary.FileWriter(opt.log_path + '/test', sess.graph) sess.run(tf.global_variables_initializer()) if opt.restore: try: t_vars = tf.trainable_variables() save_keys = tensors_key_in_file(opt.save_path) ss = set([var.name for var in t_vars]) & set([s + ":0" for s in save_keys.keys()]) cc = {var.name: var for var in t_vars} # only restore variables with correct shape ss_right_shape = set([s for s in ss if cc[s].get_shape() == save_keys[s[:-2]]]) loader = tf.train.Saver(var_list=[var for var in t_vars if var.name in ss_right_shape]) loader.restore(sess, opt.save_path) print("Loading variables from '%s'." % opt.save_path) print("Loaded variables:" + str(ss)) except: print("No saving session, using random initialization") sess.run(tf.global_variables_initializer()) try: for epoch in range(opt.max_epochs): print("Starting epoch %d" % epoch) kf = get_minibatches_idx(len(train), opt.batch_size, shuffle=True) for _, train_index in kf: uidx += 1 sents = [train[t] for t in train_index] G1 = [G_train[t] for t in train_index] x_labels = [train_lab[t] for t in train_index] x_labels = np.array(x_labels) x_labels = x_labels.reshape((len(x_labels), opt.num_class)) x_batch, x_batch_mask, G_batch, seq_len_batch = prepare_data_for_emb(sents, G1, opt) _, loss, step, = sess.run([train_op, loss_, global_step], feed_dict={x_: x_batch, x_mask_: x_batch_mask, y_: x_labels, keep_prob: opt.dropout, class_penalty_:opt.class_penalty, G_our:G_batch, seq_len:seq_len_batch}) if uidx % opt.valid_freq == 0: train_correct = 0.0 # sample evaluate accuaccy on 500 sample data kf_train = get_minibatches_idx(500, opt.batch_size, shuffle=True) for _, train_index in kf_train: train_sents = [train[t] for t in train_index] train_G = [G_train[t] for t in train_index] train_labels = [train_lab[t] for t in train_index] train_labels = np.array(train_labels) train_labels = train_labels.reshape((len(train_labels), opt.num_class)) x_train_batch, x_train_batch_mask, G_train_batch, x_train_seq_len = prepare_data_for_emb(train_sents, train_G, opt) train_accuracy = sess.run(accuracy_, feed_dict={x_: x_train_batch, x_mask_: x_train_batch_mask, y_: train_labels, keep_prob: 1.0, class_penalty_:0.0, G_our:G_train_batch, seq_len:x_train_seq_len}) train_correct += train_accuracy * len(train_index) train_accuracy = train_correct / 500 print("Iteration %d: Training loss %f " % (uidx, loss)) print("Train accuracy %f " % train_accuracy) if not os.path.exists(opt.dataset + '_Train_message.csv'): with open(opt.dataset + '_Train_message.csv', 'a', newline='') as out: # 设定写入模式 csv_write = csv.writer(out, dialect='excel') # 写入具体内容 csv_write.writerow(["epoch", "Training loss", "Train accuracy"]) csv_write.writerow([epoch, loss, train_accuracy]) else: with open(opt.dataset + '_Train_message.csv', 'a', newline='') as out: # 设定写入模式 csv_write = csv.writer(out, dialect='excel') csv_write.writerow([epoch, loss, train_accuracy]) val_correct = 0.0 kf_val = get_minibatches_idx(len(val), opt.batch_size, shuffle=True) for _, val_index in kf_val: val_sents = [val[t] for t in val_index] val_Gs = [G_val[t] for t in val_index] val_labels = [val_lab[t] for t in val_index] val_labels = np.array(val_labels) val_labels = val_labels.reshape((len(val_labels), opt.num_class)) x_val_batch, x_val_batch_mask, G_val_batch, x_val_seq_len = prepare_data_for_emb(val_sents, val_Gs, opt) val_accuracy = sess.run(accuracy_, feed_dict={x_: x_val_batch, x_mask_: x_val_batch_mask, y_: val_labels, keep_prob: 1.0, class_penalty_:0.0, G_our:G_val_batch, seq_len:x_val_seq_len}) val_correct += val_accuracy * len(val_index) val_accuracy = val_correct / len(val) print("Validation accuracy %f " % val_accuracy) #测试网络 test_correct = 0.0 kf_test = get_minibatches_idx(len(test), opt.batch_size, shuffle=True) for _, test_index in kf_test: test_sents = [test[t] for t in test_index] test_Gs = [G_test[t] for t in test_index] test_labels = [test_lab[t] for t in test_index] test_labels = np.array(test_labels) test_labels = test_labels.reshape((len(test_labels), opt.num_class)) x_test_batch, x_test_batch_mask, G_test_batch, x_test_seq_len = prepare_data_for_emb(test_sents, test_Gs, opt) test_accuracy = sess.run(accuracy_, feed_dict={x_: x_test_batch, x_mask_: x_test_batch_mask, y_: test_labels, keep_prob: 1.0, class_penalty_: 0.0, G_our: G_test_batch, seq_len:x_test_seq_len}) test_correct += test_accuracy * len(test_index) test_accuracy = test_correct / len(test) print("Test accuracy %f " % test_accuracy) # max_test_accuracy = test_accuracy if test_accuracy > max_test_accuracy: max_test_accuracy = test_accuracy val_acc = val_accuracy # max_test_accuracy = max(test_accuracy, max_test_accuracy) # val_acc = val_accuracy if val_accuracy > max_val_accuracy: max_val_accuracy = val_accuracy test_acc = test_accuracy if not os.path.exists(opt.dataset + '_Classification_Results.csv'): with open(opt.dataset + '_Classification_Results.csv', 'a', newline='') as out: # 设定写入模式 csv_write = csv.writer(out, dialect='excel') # 写入具体内容 csv_write.writerow(["epoch", "val_accuracy", "test_accuracy"]) csv_write.writerow([epoch, val_accuracy, test_accuracy]) else: with open(opt.dataset + '_Classification_Results.csv', 'a', newline='') as out: # 设定写入模式 csv_write = csv.writer(out, dialect='excel') csv_write.writerow([epoch, val_accuracy, test_accuracy]) print("Epoch %d: Max Test accuracy %f" % (epoch, max_test_accuracy)) saver.save(sess, opt.save_path, global_step=epoch) print("Max Test accuracy %f , val accuracy %f " % (max_test_accuracy, val_acc)) print("Max val accuracy %f , test accuracy %f" % (max_val_accuracy, test_acc)) with open(opt.dataset + '_Classification_Results.csv', 'a', newline='') as out: # 设定写入模式 csv_write = csv.writer(out, dialect='excel') csv_write.writerow(['Max Test accuracy:', max_test_accuracy, 'val accuracy', val_acc]) csv_write.writerow(['Max val accuracy:', max_val_accuracy, 'test accuracy', test_acc]) except KeyboardInterrupt: print('Training interupted') print("Max Test accuracy %f " % max_test_accuracy) with open(opt.dataset + '_Classification_Results.csv', 'a', newline='') as out: # 设定写入模式 csv_write = csv.writer(out, dialect='excel') csv_write.writerow(['Max Test accuracy:', max_test_accuracy, 'val accuracy', val_acc]) csv_write.writerow(['Max val accuracy:', max_val_accuracy, 'test accuracy', test_acc])