def test(test_dir): print("Loading test data...") start_time = time.time() x_test, y_test = process_file(test_dir, word_to_id, cat_to_id, config.seq_length) session = tf.Session(config=tfconfig) session.run(tf.global_variables_initializer()) saver = tf.train.Saver() saver.restore(sess=session, save_path=save_path) # 读取保存的模型 print('Testing...') loss_test, acc_test = evaluate(session, x_test, y_test) msg = 'Test Loss: {0:>6.2}, Test Acc: {1:>7.2%}' print(msg.format(loss_test, acc_test)) batch_size = 128 data_len = len(x_test) num_batch = int((data_len - 1) / batch_size) + 1 y_pred_cls = np.zeros(shape=len(x_test), dtype=np.int32) # 保存预测结果 for i in range(num_batch): # 逐批次处理 start_id = i * batch_size end_id = min((i + 1) * batch_size, data_len) feed_dict = { model.input_x: x_test[start_id:end_id], model.keep_prob: 1.0 } y_pred_cls[start_id:end_id] = session.run(model.y_pred_cls, feed_dict=feed_dict) time_dif = get_time_dif(start_time) print("Time usage:", time_dif) return y_pred_cls
def train(): print("Configuring TensorBoard and Saver...") # 配置 Tensorboard,重新训练时,请将tensorboard文件夹删除,不然图会覆盖 tensorboard_dir = 'tensorboard/rnn' if not os.path.exists(tensorboard_dir): os.makedirs(tensorboard_dir) merged = tf.summary.merge_all() writer = tf.summary.FileWriter(tensorboard_dir) # 配置 Saver saver = tf.train.Saver() if not os.path.exists(save_dir): os.makedirs(save_dir) # 创建session sess = tf.Session() sess.run(tf.global_variables_initializer()) writer.add_graph(sess.graph) # 读取数据 print("Loading training data: %.1f.csv" % f) tarin_dir = os.path.join(base_dir, data_dir) x_train, y_train = process_file(tarin_dir, config) x_normlize = x_train y_normlize = y_train # 开始训练 print('Training and evaluating...') for epoch in range(config.epoches): x_batch, y_batch = batch_iter(x_normlize, y_normlize, config) for iteration in range(config.num_iterations): # print('Epoch: ', epoch + 1) # batch_train = batch_iter(x_train, y_train, config.batch_size) feed_dict = { model.xs: x_batch, model.ys: y_batch, # create initial state } _, cost, state, pred = sess.run([ model.train_op, model.cost, model.cell_final_state, model.pred ], feed_dict=feed_dict) # plotting # if v % 20 == 0: # plt.figure(v) # plt.plot(t[0, :], (v/10)*y_batch[0].flatten(), 'r', t[0, :], (v/10)*pred.flatten()[:config.time_steps], 'b--', # t[0, :], (v/10) *x_batch[0].flatten(), 'k-.') # plt.ylim((-16, 16)) # plt.draw() # plt.pause(0.3) if iteration % 20 == 0: print('cost: ', round(cost, 4)) result = sess.run(merged, feed_dict) writer.add_summary(result, iteration) # 保存网络 saver.save(sess=sess, save_path=save_path)
def test(): print("Loading test data...") start_time = time.time() x_test, y_test = process_file(test_dir, cat_to_id, config.seq_length) session = tf.Session() session.run(tf.global_variables_initializer()) saver = tf.train.Saver() print('save_path', save_path) saver.restore(sess=session, save_path=save_path) print('Testing...') loss_test, acc_test = evaluate(session, x_test, y_test) msg = 'Test Loss: {0:>6.4}, Test Acc: {1:>7.4%}' print(msg.format(loss_test, acc_test)) batch_size = 128 data_len = len(x_test) num_batch = int((data_len - 1) / batch_size) + 1 y_test_cls = np.argmax(y_test, 1) y_pred_cls = np.zeros(shape=len(x_test), dtype=np.int32) auc_score = [] for i in range(num_batch): start_id = i * batch_size end_id = min((i + 1) * batch_size, data_len) feed_dict = { model.input_x: x_test[start_id:end_id], model.keep_prob: 1.0 } y_pred_cls[start_id:end_id] = session.run(model.y_pred_cls, feed_dict=feed_dict) ##add for auc softmax_score = session.run(model.softmax_score, feed_dict=feed_dict) for line in softmax_score: auc_score.append(line[1]) auc_score = np.array(auc_score) #auc = round(metrics.auc(y_test_cls,auc_score),4) auc = round(roc_auc_score(y_test_cls, auc_score), 4) print('Test Auc:', str(auc * 100) + '%') brier_score = brier_score_loss(y_test_cls, auc_score) print('Brierscore', brier_score) print("Precision, Recall and F1-Score...") print( metrics.classification_report(y_test_cls, y_pred_cls, target_names=categories)) print("Confusion Matrix...") cm = metrics.confusion_matrix(y_test_cls, y_pred_cls) print(cm)
def test(): """ 测试模型 :return: """ print("Loading test data...") start_time = time.time() x_test, y_test = process_file(test_dir, word_to_id, cat_to_id, config.seq_length) session = tf.Session() session.run(tf.global_variables_initializer()) saver = tf.train.Saver() saver.restore(sess=session, save_path=save_path) # 读取保存的模型 print('Testing...') loss_test, acc_test = evaluate(session, x_test, y_test) msg = 'Test Loss: {0:>6.2}, Test Acc: {1:>7.2%}' print(msg.format(loss_test, acc_test)) batch_size = 128 data_len = len(x_test) num_batch = int((data_len - 1) / batch_size) + 1 y_test_cls = np.argmax(y_test, 1) y_pred_cls = np.zeros(shape=len(x_test), dtype=np.int32) # 保存预测结果 for i in range(num_batch): # 逐批次处理 start_id = i * batch_size end_id = min((i + 1) * batch_size, data_len) feed_dict = { model.input_x: x_test[start_id:end_id], model.keep_prob: 1.0 } y_pred_cls[start_id:end_id] = session.run(model.y_pred_cls, feed_dict=feed_dict) # 评估 print("Precision, Recall and F1-Score...") print( metrics.classification_report(y_test_cls, y_pred_cls, target_names=categories)) # 混淆矩阵 print("Confusion Matrix...") cm = metrics.confusion_matrix(y_test_cls, y_pred_cls) print(cm) time_dif = get_time_dif(start_time) print("Time usage:", time_dif)
def test(): print("Loading test data...") start_time = time.time() x_test, y_test = process_file(test_dir, word_to_id, cat_to_id, config.seq_length) gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.1) session = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) session.run(tf.global_variables_initializer()) saver = tf.train.Saver() saver.restore(sess=session, save_path=save_path) # 读取保存的模型 print('Testing...') loss_test, acc_test = evaluate(session, x_test, y_test) msg = 'Test Loss: {0:>6.2}, Test Acc: {1:>7.2%}' print(msg.format(loss_test, acc_test)) batch_size = 128 data_len = len(x_test) num_batch = int((data_len - 1) / batch_size) + 1 y_test_cls = np.argmax(y_test, 1) y_pred_cls = np.zeros(shape=len(x_test), dtype=np.int32) # 保存预测结果 for i in range(num_batch): # 逐批次处理 start_id = i * batch_size end_id = min((i + 1) * batch_size, data_len) feed_dict = { model.input_x: x_test[start_id:end_id], model.keep_prob: 1.0 } y_pred_cls[start_id:end_id] = session.run(model.y_pred_cls, feed_dict=feed_dict) # Error print for i in range(len(y_pred_cls)): if y_pred_cls[i] != y_test_cls[i]: print('Predict:',categories[y_pred_cls[i]],'True:',categories[y_test_cls[i]]) print('Sentence:',''.join([words[id] for id in x_test[i] if id != 0])) # 评估 print("Precision, Recall and F1-Score...") print(metrics.classification_report(y_test_cls, y_pred_cls, target_names=categories)) # 混淆矩阵 print("Confusion Matrix...") cm = metrics.confusion_matrix(y_test_cls, y_pred_cls) print(cm) time_dif = get_time_dif(start_time) print("Time usage:", time_dif)
def test(): # v = random.randint(start, end) # 读取数据 print("Loading test data: ") # tarin_data = os.path.join(base_dir, dir) tarin_dir = os.path.join(base_dir, data_dir) x_data, y_data = process_file(tarin_dir, config) # x_max = max(abs(x_test)) # y_max = max(y_train) # x_max = max(x_test) x_normlize = x_data y_normlize = y_data # 创建session sess = tf.Session() sess.run(tf.global_variables_initializer()) saver = tf.train.Saver() saver.restore(sess=sess, save_path=save_path) # 读取保存的模型 print('Testing...') x_batch, y_batch = batch_iter(x_normlize, y_normlize, config) x_test = x_batch[1].reshape(1, 1000, 1) y_test = y_batch[1].reshape(1, 1000, 1) feed_dict = { model.xs: x_test, model.ys: y_test, # create initial state } state, pred = sess.run([model.cell_final_state, model.pred], feed_dict=feed_dict) # plotting # plt.figure(v) plt.plot(x_test.flatten(), 'r', y_test.flatten(), 'b--', state.flatten(), 'k-.') plt.ylim((-16, 16)) plt.draw() plt.pause(0.3) os.system("pause")
import torch from torch import nn import torch.nn.functional as f from torch.autograd import Variable ##查看GPU是否可用 print(torch.cuda.is_available()) categories, cat_to_id = read_category() print(categories) words, word_to_id = read_vocab('cnews_vocab.txt') print(words) ##加载训练集 x_train, y_train = process_file('cnews_small_sample.txt', word_to_id, cat_to_id, 600) print('x_train=', x_train) ##加载验证集 x_val, y_val = process_file('cnews_val.txt', word_to_id, cat_to_id, 600) ###验证集上进行准确率评估 def evaluate(model, Loss, optimizer, x_val, y_val): batch_val = data_load(x_val, y_val, 32) acc = 0 los = 0 for x_batch, y_batch in batch_val: size = len(x_batch) x = np.array(x_batch) y = np.array(y_batch)
def train(): print("Configuring TensorBoard and Saver...") # 配置 Tensorboard,重新训练时,请将tensorboard文件夹删除,不然图会覆盖 tensorboard_dir = 'tensorboard/textcnn' if not os.path.exists(tensorboard_dir): os.makedirs(tensorboard_dir) tf.summary.scalar("loss", model.loss) tf.summary.scalar("accuracy", model.acc) merged_summary = tf.summary.merge_all() writer = tf.summary.FileWriter(tensorboard_dir) # 配置 Saver saver = tf.train.Saver() if not os.path.exists(save_dir): os.makedirs(save_dir) if not os.path.exists(save_dir_bak): os.makedirs(save_dir_bak) print("Loading training and validation data...") # 载入训练集与验证集 start_time = time.time() x_train, y_train = process_file(train_dir, word_to_id, cat_to_id, config.seq_length) # 不需要验证集 # x_val, y_val = process_file(val_dir, word_to_id, cat_to_id, config.seq_length) x_test, y_test = process_file(test_dir, word_to_id, cat_to_id, config.seq_length) time_dif = get_time_dif(start_time) print("Time usage:", time_dif) # 创建session gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.1) session = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) session.run(tf.global_variables_initializer()) writer.add_graph(session.graph) print('Training and evaluating...') start_time = time.time() total_batch = 0 # 总批次 # best_acc_val = 0.0 # 最佳验证集准确率 best_acc_test = 0.0 last_improved = 0 # 记录上一次提升批次 require_improvement = 1500 # 如果超过1000轮未提升,提前结束训练 flag = False for epoch in range(config.num_epochs): print('Epoch:', epoch + 1) batch_train = batch_iter(x_train, y_train, config.batch_size) for x_batch, y_batch in batch_train: feed_dict = feed_data(x_batch, y_batch, config.dropout_keep_prob) if total_batch % config.save_per_batch == 0: # 每多少轮次将训练结果写入tensorboard scalar s = session.run(merged_summary, feed_dict=feed_dict) writer.add_summary(s, total_batch) if total_batch % config.print_per_batch == 0: # 每多少轮次输出在训练集和验证集上的性能 feed_dict[model.keep_prob] = 1.0 loss_train, acc_train = session.run([model.loss, model.acc], feed_dict=feed_dict) # loss_val, acc_val = evaluate(session, x_val, y_val) # todo loss_test, acc_test = evaluate(session, x_test, y_test) if acc_test > best_acc_test: # 保存最好结果 best_acc_test = acc_test last_improved = total_batch saver.save(sess=session, save_path=save_path_bak) improved_str = '*' else: improved_str = '' time_dif = get_time_dif(start_time) msg = 'Iter: {0:>6}, Train Loss: {1:>6.2}, Train Acc: {2:>7.2%},' \ + ' Test Loss: {3:>6.2}, Test Acc: {4:>7.2%}, Time: {5} {6}' print(msg.format(total_batch, loss_train, acc_train, loss_test, acc_test, time_dif, improved_str)) feed_dict[model.keep_prob] = config.dropout_keep_prob session.run(model.optim, feed_dict=feed_dict) # 运行优化 total_batch += 1 if total_batch - last_improved > require_improvement: # 验证集正确率长期不提升,提前结束训练 print("No optimization for a long time, auto-stopping...") flag = True break # 跳出循环 if flag: # 同上 break
for i in normal_num: get_train_data(i) config = TCNNConfig() if not os.path.exists(vocab_dir): # 如果不存在词汇表,重建 build_vocab(train_dir, vocab_dir, config.vocab_size) categories, cat_to_id = read_category(train_dir) words, word_to_id = read_vocab(vocab_dir) config.vocab_size = len(words) config.num_classes = len(categories) model = TextCNN(config) # 训练模型并保存到bak train() print("Loading test data...") start_time = time.time() x_test, y_test = process_file(test_dir, word_to_id, cat_to_id, config.seq_length) gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.1) session = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) session.run(tf.global_variables_initializer()) saver = tf.train.Saver() saver.restore(sess=session, save_path=save_path_bak) # 读取保存的模型 print('Testing...') loss_test, acc_test = evaluate(session, x_test, y_test) if acc_test > max_acc and loss_test < 5: print('GET GREATEST MODEL!') max_acc = acc_test greatest_normal_num = i saver.save(sess=session, save_path=save_path)
def train(): print("Configuring TensorBoard and Saver...") # 配置 Tensorboard,重新训练时,请将tensorboard文件夹删除,不然图会覆盖 tensorboard_dir = 'tensorboard/tb30641000v01/' if not os.path.exists(tensorboard_dir): os.makedirs(tensorboard_dir) train_loss_summ = tf.summary.scalar("train_loss", model.loss) train_acc_summ = tf.summary.scalar("trian_accuracy", model.acc) val_loss_summ = tf.summary.scalar("validation_loss", model.loss) val_acc_summ = tf.summary.scalar("validation_accuracy", model.acc) writer = tf.summary.FileWriter(tensorboard_dir) # 配置 Saver saver = tf.train.Saver() if not os.path.exists(save_dir): os.makedirs(save_dir) print("Loading training and validation data...") # 载入训练集与验证集 start_time = time.time() x_train, y_train = process_file(train_txt_dirs, seq_length, word_to_id, cat_to_id, config.seq_length) print "训练样本总数是{}".format(len(x_train)) x_val, y_val = process_file(test_txt_dirs, seq_length, word_to_id, cat_to_id, config.seq_length) print "测试集样本总数是{}".format(len(x_val)) time_dif = get_time_dif(start_time) print("Time usage:", time_dif) # 创建session session = tf.Session() session.run(tf.global_variables_initializer()) writer.add_graph(session.graph) print('Training and evaluating...') start_time = time.time() total_batch = 0 # 总批次 best_acc_val = 0.0 # 最佳验证集准确率 last_improved = 0 # 记录上一次提升批次 require_improvement = 1000 # 如果超过1000轮未提升,提前结束训练 # flag = False for epoch in range(config.num_epochs): print('Epoch:', epoch + 1) batch_train = batch_iter(x_train, y_train, config.batch_size) for x_batch, y_batch in batch_train: feed_dict = feed_data(x_batch, y_batch, config.dropout_keep_prob) if total_batch % config.print_per_batch == 0: # 每多少轮次输出在训练集和验证集上的性能 # feed_dict[model.keep_prob] = 1.0 loss_train, acc_train = session.run([model.loss, model.acc], feed_dict=feed_dict) train_loss_summ_, train_acc_summ_ = session.run([train_loss_summ, train_acc_summ], feed_dict=feed_dict) writer.add_summary(train_loss_summ_, total_batch) writer.add_summary(train_acc_summ_, total_batch) loss_val, acc_val = evaluate(session, x_val, y_val) # todo val_loss_summ_, val_acc_summ_ = session.run([val_loss_summ, val_acc_summ], feed_dict={model.input_x: x_val, model.input_y: y_val, model.keep_prob: 1.0}) writer.add_summary(val_loss_summ_, total_batch) writer.add_summary(val_acc_summ_, total_batch) if acc_val > best_acc_val: # 保存最好结果 best_acc_val = acc_val last_improved = total_batch saver.save(sess=session, save_path=save_path) improved_str = '*' else: improved_str = '' time_dif = get_time_dif(start_time) msg = 'Iter: {0:>6}, Train Loss: {1:>6.2}, Train Acc: {2:>7.2%},' \ + ' Val Loss: {3:>6.2}, Val Acc: {4:>7.2%}, Time: {5} {6}' print(msg.format(total_batch, loss_train, acc_train, loss_val, acc_val, time_dif, improved_str)) session.run(model.optim, feed_dict=feed_dict) # 运行优化 total_batch += 1
def test(): print("Loading test data...") start_time = time.time() contents = read_file(test_dir)[0] x_test, y_test = process_file(test_dir, word_to_id, cat_to_id, config.seq_length) tf_config = tf.ConfigProto() tf_config.gpu_options.allow_growth = True session = tf.Session(config=tf_config) session.run(tf.global_variables_initializer()) saver = tf.train.Saver(tf.global_variables()) saver.restore(sess=session, save_path=save_path) # 读取保存的模型 print('Testing...') loss_test, acc_test = evaluate(session, x_test, y_test) msg = 'Test Loss: {0:>6.2}, Test Acc: {1:>7.2%}' print(msg.format(loss_test, acc_test)) batch_size = 128 data_len = len(x_test) num_batch = int((data_len - 1) / batch_size) + 1 y_test_cls, y_pred_cls = [], [] for r_y in y_test: m = [] for k in range(len(r_y)): if r_y[k] >= 0.5: m.append(k) y_test_cls.append(m) #y_test_cls = sorted(y_test_cls,reverse=True) #y_test_cls = np.argmax(y_test, 1) #y_pred_cls = np.zeros(shape=len(x_test), dtype=np.int32) # 保存预测结果 pred_prob = np.zeros(shape=[len(x_test), config.num_classes], dtype=np.float32) #sorted_pred_prob = np.zeros(shape=[len(x_test),config.num_classes],dtype=np.float32) for i in range(num_batch): # 逐批次处理 start_id = i * batch_size end_id = min((i + 1) * batch_size, data_len) feed_dict = { model.input_x: x_test[start_id:end_id], model.keep_prob: 1.0, model.batch_size: len(x_test[start_id:end_id]), model.real_length: get_real_seq_length(x_test[start_id:end_id]) } pred_prob[start_id:end_id] = session.run(model.pred_prob, feed_dict=feed_dict) #sorted_pred_prob[start_id:end_id]=[np.argsort(pred_prob[i]) for i in range(start_id,end_id)] ''' for i in range(start_id,end_id): if pred_prob[i][int(sorted_pred_prob[i][-1])]>0.85: y_pred_cls[i] = sorted_pred_prob[i][-1] else: y_pred_cls[i] = sorted_pred_prob[i][-2] ''' #print('a') for p_y in pred_prob: m = [] for k in range(len(p_y)): if p_y[k] >= 0.5: m.append(k) if len(m) < 1: m.append(np.argmax(p_y)) y_pred_cls.append(m) res = [] res_indexs = [] for i in range(len(y_test_cls)): res.append([ contents[i], '#'.join([id_to_cat[_] for _ in y_test_cls[i]]), '#'.join([id_to_cat[_] for _ in y_pred_cls[i]]) ]) res = pd.DataFrame(res, columns=['content', 'real_label', 'pred_label']) res.to_excel('result.xlsx', index=False, encoding='utf-8') for i in range(len(y_test_cls)): res_indexs.append([ contents[i], '#'.join([str(_) for _ in y_test_cls[i]]), '#'.join([str(_) for _ in y_pred_cls[i]]) ]) res_indexs = pd.DataFrame(res_indexs, columns=['content', 'real_label', 'pred_label']) res_indexs.to_excel('result_index.xlsx', index=False, encoding='utf-8') #y_pred_cls[start_id:end_id] = session.run(model.y_pred_cls, feed_dict=feed_dict) # TP = defaultdict(int) # FP = defaultdict(int) # TN = defaultdict(int) # FN = defaultdict(int) # for i in range(len(y_test_cls)): # for j in range(len(y_test_cls[i])): # for n in range(len(cat_to_id)): # if y_pred_cls[i][j] == n and y_test_cls[i][j] == n: # TP[n] += 1 # elif y_pred_cls[i][j] == n and y_test_cls[i][j] != n: # FP[n] += 1 # elif y_pred_cls[i][j] != n and y_test_cls[i][j] == n: # FN[n] += 1 # else: # TN[n] += 1 # 评估 print("Precision, Recall and F1-Score...") report_labels = unique_labels(y_test_cls, y_pred_cls) p, r, f1, s = metrics.precision_recall_fscore_support(y_test_cls, y_pred_cls, labels=report_labels, average='micro') #print(p) report = pd.DataFrame( [[report_labels[i], p[i], r[i], f1[i], s[i]] for i in range(len(report_labels))], columns=['label', 'precision', 'recall', 'f1', 'support']) #report = pd.DataFrame([p,r,f1,s],columns=['precision','recall','f1','support']) report.to_csv('../data/temp/confuse_report.csv', index=False) print( metrics.classification_report(y_test_cls, y_pred_cls, target_names=categories)) # 混淆矩阵 print("Confusion Matrix...") cm = metrics.confusion_matrix(y_test_cls, y_pred_cls) df = pd.DataFrame(metrics.confusion_matrix(y_test_cls, y_pred_cls)) df.to_csv('../data/temp/cm.csv', encoding='utf-8') ''' wb = xlwt.Workbook() ws = wb.add_sheet('Sheet1') for i in range(len(cm)): for j in range(len(cm[i])): ws.write(i,j,cm[i][j]) wb.save('../data/temp/cm.xls') ''' print(cm) time_dif = get_time_dif(start_time) print("Time usage:", time_dif)
def train(): print("Configuring TensorBoard and Saver...") # 配置 Tensorboard,重新训练时,请将tensorboard文件夹删除,不然图会覆盖 tensorboard_dir = 'tensorboard/textcnn' if not os.path.exists(tensorboard_dir): os.makedirs(tensorboard_dir) tf.summary.scalar("loss", model.loss) #tf.summary.scalar("accuracy", model.acc) merged_summary = tf.summary.merge_all() writer = tf.summary.FileWriter(tensorboard_dir) print("Loading training and validation data...") # 载入训练集与验证集 start_time = time.time() x_train, y_train = process_file(train_dir, word_to_id, cat_to_id, config.seq_length) x_val, y_val = process_file(val_dir, word_to_id, cat_to_id, config.seq_length) time_dif = get_time_dif(start_time) print("Time usage:", time_dif) tf_config = tf.ConfigProto() tf_config.gpu_options.allow_growth = True # 创建session session = tf.Session(config=tf_config) session.run(tf.global_variables_initializer()) writer.add_graph(session.graph) # 配置 Saver saver = tf.train.Saver(tf.global_variables()) if not os.path.exists(save_dir): os.makedirs(save_dir) else: saver.restore(session, save_path=save_path) print('Training and evaluating...') start_time = time.time() total_batch = 0 # 总批次 best_acc_val = 0.0 # 最佳验证集准确率 last_improved = 0 # 记录上一次提升批次 require_improvement = 1000 # 如果超过1000轮未提升,提前结束训练 flag = False for epoch in range(config.num_epochs): print('Epoch:', epoch + 1) batch_train = batch_iter(x_train, y_train, config.batch_size) for x_batch, y_batch in batch_train: feed_dict = feed_data(x_batch, y_batch, config.dropout_keep_prob, True) session.run(model.optim, feed_dict=feed_dict) # 运行优化 #ot = session.run(model.rnn_output,feed_dict=feed_dict) #aot = session.run(model.att_out,feed_dict=feed_dict) #pools = session.run(model.pools,feed_dict=feed_dict) #pools2 = session.run(model.pool2, feed_dict=feed_dict) #alls = session.run(model.all,feed_dict=feed_dict) #convs = session.run(model.convs,feed_dict=feed_dict) if total_batch % config.save_per_batch == 0: # 每多少轮次将训练结果写入tensorboard scalar s = session.run(merged_summary, feed_dict=feed_dict) writer.add_summary(s, total_batch) if total_batch % config.print_per_batch == 0: # 每多少轮次输出在训练集和验证集上的性能 feed_dict[model.keep_prob] = 1.0 # feed_dict[model.istraining] = False loss_train, pred_prob_train = session.run( [model.loss, model.pred_prob], feed_dict=feed_dict) train_acc = get_acc(pred_prob_train, y_batch) loss_val, acc_val = evaluate(session, x_val, y_val) # todo if acc_val > best_acc_val: # 保存最好结果 best_acc_val = acc_val last_improved = total_batch saver.save(sess=session, save_path=save_path) improved_str = '*' else: improved_str = '' time_dif = get_time_dif(start_time) msg = 'Iter: {0:>6}, Train Loss: {1:>6.2}, Train Acc: {2:>7.2%},' \ + ' Val Loss: {3:>6.2}, Val Acc: {4:>7.2%}, Time: {5} {6}' print( msg.format(total_batch, loss_train, train_acc, loss_val, acc_val, time_dif, improved_str)) total_batch += 1 if total_batch - last_improved > require_improvement: config.decay_steps = total_batch + 1 config.decay_rate = config.decay_rate * 0.1
def train(net='cnn', epoch=20): # 读取训练集 x_train, y_train = None, None for i in range(1, 6): x, y = process_file('data_batch_%d' % i) if x_train is None: x_train = x y_train = y else: x_train = np.append(x_train, x, axis=0) y_train = np.append(y_train, y, axis=0) del x, y x_dev, y_dev = process_file('test_batch') x = tf.placeholder(tf.float32, [ None, config.image_width * config.image_height * config.image_channel ]) x_reshape = tf.reshape( x, [-1, config.image_channel, config.image_height, config.image_width]) # [batch, depth, height, width] => [batch, height, width, depth] x_reshape = tf.transpose(x_reshape, [0, 2, 3, 1]) if net == 'cnn': model = CNN() elif net == 'vgg': model = VGG() else: pass out = model.output(input=x_reshape) y_ = tf.placeholder(tf.float32, [None, config.classes]) loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=out, labels=y_)) tf.summary.scalar('loss', loss) correct_prediction = tf.equal(tf.argmax(out, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) tf.summary.scalar('accuracy', accuracy) optimizer = tf.train.AdamOptimizer(config.learning_rate).minimize(loss) with tf.Session() as sess: writer = tf.summary.FileWriter("logs/", sess.graph) merged = tf.summary.merge_all() sess.run(tf.global_variables_initializer()) ''' variable_names = [v.name for v in tf.trainable_variables()] values = sess.run(variable_names) for k, v in zip(variable_names, values): print("Variable: ", k) print("Shape: ", v.shape) print_num_of_total_parameters() ''' step = 1 best_acc = 0. start_time = time.time() for e in range(1, epoch + 1): for x_batch, y_batch in batch_iter(x=x_train, y=y_train, batch_size=config.batch_size): step = step + 1 _, trainloss, train_acc = sess.run( [optimizer, loss, accuracy], feed_dict={ x: x_batch, y_: y_batch, model.keep_prob: 0.5, model.is_training: True }) if step % 20 == 0: pass # print('Iterator:%d loss:%f train acc:%f' % (step, trainloss, train_acc)) if step % 781 == 0: train_acc, summary = sess.run( [accuracy, merged], feed_dict={ x: x_train[:10000], y_: y_train[:10000], model.keep_prob: 1., model.is_training: False }) writer.add_summary(summary, e) acc = sess.run(accuracy, feed_dict={ x: x_dev, y_: y_dev, model.keep_prob: 1., model.is_training: False }) print('Iterator:%d loss:%f train acc:%f' % (step, trainloss, train_acc)) elapsed_time = time.time() - start_time print('\033[1;32mepoch:%d/%d' % (e, config.epoch)) print('\033[1;32mvalidation accuracy:%f\033[0m' % acc, end='') if acc > best_acc: best_acc = acc print('\033[1;35m(new best acc!)\033[0m') else: print('')
def train(): print("Configuring TensorBoard and Saver...") # tensorboard_dir = 'tensorboard/cnn' if not os.path.exists(tensorboard_dir): os.makedirs(tensorboard_dir) tf.summary.scalar("loss", model.loss) tf.summary.scalar("accuracy", model.acc) merged_summary = tf.summary.merge_all() writer = tf.summary.FileWriter(tensorboard_dir) # saver = tf.train.Saver() if not os.path.exists(save_dir): os.makedirs(save_dir) print("Loading training and validation data...") # start_time = time.time() x_train, y_train = process_file(train_dir, cat_to_id, config.seq_length) x_val, y_val = process_file(val_dir, cat_to_id, config.seq_length) # session = tf.Session() session.run(tf.global_variables_initializer()) writer.add_graph(session.graph) print('Training and evaluating...') start_time = time.time() total_batch = 0 # best_acc_val = 0.0 # last_improved = 0 # require_improvement = 10000 # flag = False for epoch in range(config.num_epochs): print('Epoch:', epoch + 1) batch_train = batch_iter(x_train, y_train, config.batch_size) for x_batch, y_batch in batch_train: feed_dict = feed_data(x_batch, y_batch, config.dropout_keep_prob) if total_batch % config.save_per_batch == 0: #print(feed_dict) s = session.run(merged_summary, feed_dict=feed_dict) writer.add_summary(s, total_batch) if total_batch % config.print_per_batch == 0: # feed_dict[model.keep_prob] = 1.0 loss_train, acc_train = session.run([model.loss, model.acc], feed_dict=feed_dict) loss_val, acc_val = evaluate(session, x_val, y_val) # todo if acc_val > best_acc_val: # best_acc_val = acc_val last_improved = total_batch saver.save(sess=session, save_path=save_path) improved_str = '*' else: improved_str = '' time_dif = get_time_dif(start_time) msg = 'Iter: {0:>6}, Train Loss: {1:>6.2}, Train Acc: {2:>7.2%},' \ + ' Val Loss: {3:>6.2}, Val Acc: {4:>7.2%}, Time: {5} {6}' print( msg.format(total_batch, loss_train, acc_train, loss_val, acc_val, time_dif, improved_str)) session.run(model.optim, feed_dict=feed_dict) total_batch += 1 if total_batch - last_improved > require_improvement: # print("No optimization for a long time, auto-stopping...") flag = True break # if flag: # break