def getHash(path): x = tf.placeholder(tf.float32, [batch_size, 227, 227, 3], name='x') model = DeepHashingNet(x, 1, hash_K, []) fch = model.fch print("Reading checkpoints...") ckpt = tf.train.get_checkpoint_state(checkpoint_path) saver = tf.train.Saver(tf.all_variables()) sess = tf.InteractiveSession() query_generator = ImageDataGenerator(path, horizontal_flip=False, shuffle=False) file_res = open('query_dhn.txt', 'w') # sys.stdout = file_res if ckpt and ckpt.model_checkpoint_path: ckpt_name = os.path.basename(ckpt.model_checkpoint_path) print(ckpt_name) global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1] saver.restore(sess, os.path.join(checkpoint_path, ckpt_name)) print('Loading success, global_step is %s' % global_step) k = 0 for i in range(query_generator.dataSize // batch_size): print( str(i) + "th batch in " + str(query_generator.dataSize // batch_size)) images, label = query_generator.next_batch(batch_size) eval_sess = sess.run(fch, feed_dict={x: images}) # print(eval_sess) w_res = toBinaryString(eval_sess) wzy = toString(eval_sess) for j in range(batch_size): file_res.write(wzy[j] + '\t' + w_res[j] + '\t' + str(query_generator.images[k]) + '\n') k += 1 file_res.close() sess.close()
def genrate_pre_result(): #获取需要预测结果的所有数据 img_ids, _, img_paths = get_img_infos("test", test_txt) test_dataset = pd.DataFrame({"img_id": img_ids, "img_path": img_paths}) with tf.device("/cpu:0"): test_data = ImageDataGenerator(test_dataset, mode="test", batch_size=batch_size, num_classes=num_classes) iterator = tf.data.Iterator.from_structure( test_data.data.output_types, test_data.data.output_shapes) next_batch = iterator.get_next() #初始化测试集中的图片数据 test_init_op = iterator.make_initializer(test_data.data) #创建一个加载模型文件的对象 saver = tf.train.Saver() #用来保存图片的id test_img_ids = [] #用来保存图片的预测结果 test_pred_labels = [] #计算需要迭代的次数 steps = (test_data.data_size - 1) // batch_size + 1 #设置模型文件的路径 model_path = "checkpoints/model_epoch37_0.9275.ckpt" print('加载完成') with tf.Session() as sess: sess.run(test_init_op) #加载模型文件 saver.restore(sess, model_path) for step in range(steps): #获取数据 image_data, image_id = sess.run(next_batch) #预测图片的标签 pred_label = sess.run(output_y, feed_dict={ x: image_data, keep_prob: 1.0 }) pred_prob = tf.nn.softmax(pred_label) #保存预测的结果 test_img_ids.extend(image_id) test_pred_labels.extend( np.round(sess.run(pred_prob)[:, 1], decimals=2)) data = pd.DataFrame({"id": test_img_ids, "label": test_pred_labels}) data.sort_values(by="id", ascending=True, inplace=True) #保存结果 data.to_csv("AlexNet_transfer2.csv", index=False)
def evaluation_eval_dataset(): #读取验证集的csv文件 data = pd.read_csv("txt/val.csv", index_col=False) with tf.device("/cpu:0"): val_data = ImageDataGenerator(data, mode="val", batch_size=batch_size, num_classes=num_classes) iterator = tf.data.Iterator.from_structure(val_data.data.output_types, val_data.data.output_shapes) next_batch = iterator.get_next() val_init_op = iterator.make_initializer(val_data.data) saver = tf.train.Saver() steps = (val_data.data_size - 1) // batch_size + 1 #用来保存预测的类标结果 val_pred_label = [] #用来保存真实的结果 val_real_label = [] #用来保存图片的路径 #设置模型文件的路径 model_path = "checkpoints/model_epoch18_0.9000.ckpt" with tf.Session() as sess: sess.run(val_init_op) saver.restore(sess, model_path) for step in range(steps): #获取数据 img_data, img_label = sess.run(next_batch) #预测类标 pred_label = sess.run(output_label, feed_dict={ x: img_data, keep_prob: 1.0 }) val_real_label.extend(np.argmax(img_label, axis=1)) val_pred_label.extend(pred_label) #展示部分图片的预测结果 # show_part_image(val_pred_label,val_real_label,data.img_path.tolist()) #展示预测结果的分布情况 val_pred_and_real_distribution(val_pred_label, val_real_label) #展示分类结果报告 classifiction_report_info(val_pred_label, val_real_label)
def train(): label_name_to_num = {"dog": 1, "cat": 0} #获取所有的训练数据 img_ids, img_labels, img_paths = get_img_infos("train", train_txt, label_name_to_num) train_dataset, val_dataset = split_dataset(img_ids, img_paths, img_labels) print(train_dataset) with tf.device("/cpu:0"): train_data = ImageDataGenerator(train_dataset, mode="train", batch_size=batch_size, num_classes=num_classes, shuffle=True) val_data = ImageDataGenerator(val_dataset, mode="val", batch_size=batch_size, num_classes=num_classes) #创建一个获取下一个batch的迭代器 iterator = tf.data.Iterator.from_structure( train_data.data.output_types, train_data.data.output_shapes) next_batch = iterator.get_next() #初始化训练集数据 training_init_op = iterator.make_initializer(train_data.data) #初始化测试集数据 val_init_op = iterator.make_initializer(val_data.data) #获取需要重新训练的变量 var_list = [ v for v in tf.trainable_variables() if v.name.split("/")[0] in train_layers ] #定义交叉熵损失值 with tf.name_scope("cross_entropy_loss"): loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=output_y, labels=y)) #更新变量 with tf.name_scope("train"): #计算需要更新变量的梯度 gradients = tf.gradients(loss, var_list) gradients = list(zip(gradients, var_list)) #更新权重 # optimizer = tf.train.GradientDescentOptimizer(learning_rate) # train_op = optimizer.apply_gradients(grads_and_vars=gradients) train_op = tf.train.AdamOptimizer(learning_rate).minimize(loss) for gradient, var in gradients: tf.summary.histogram(var.name + "/gradient", gradient) for var in var_list: tf.summary.histogram(var.name, var) tf.summary.scalar("cross_entropy", loss) #计算准确率 with tf.name_scope("accuracy"): correct_pred = tf.equal(tf.argmax(output_y, 1), tf.argmax(y, 1)) accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) tf.summary.scalar("accuracy", accuracy) merged_summary = tf.summary.merge_all() writer = tf.summary.FileWriter(filewrite_path) saver = tf.train.Saver() #计算每轮的迭代次数 train_batches_per_epoch = int(np.floor(train_data.data_size / batch_size)) val_batches_per_epoch = int(np.floor(val_data.data_size / batch_size)) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) writer.add_graph(sess.graph) model.load_initial_weights(sess) #记录最好的验证准确率 best_val_acc = 0.9 print('开始训练') #迭代训练 for epoch in range(num_epochs): sess.run(training_init_op) for step in range(train_batches_per_epoch): # print('0batch') img_batch, label_batch = sess.run(next_batch) sess.run(train_op, feed_dict={ x: img_batch, y: label_batch, keep_prob: dropout_rate }) if step % display_step == 0: s, train_acc, train_loss = sess.run( [merged_summary, accuracy, loss], feed_dict={ x: img_batch, y: label_batch, keep_prob: 1.0 }) writer.add_summary(s, epoch * train_batches_per_epoch + step) sess.run(val_init_op) #统计验证集的准确率 val_acc = 0 #统计验证集的损失值 val_loss = 0 test_count = 0 for _ in range(val_batches_per_epoch): img_batch, label_batch = sess.run(next_batch) acc, val_batch_loss = sess.run([accuracy, loss], feed_dict={ x: img_batch, y: label_batch, keep_prob: 1.0 }) val_acc += acc val_loss += val_batch_loss test_count += 1 val_acc /= test_count val_loss /= test_count print( "%s epoch:%d,train acc:%.4f,train loss:%.4f,val acc:%.4f,val loss:%.4f" % (datetime.now(), epoch + 1, train_acc, train_loss, val_acc, val_loss)) if val_acc > best_val_acc: checkpoint_name = os.path.join( checkpoint_path, "model_epoch%s_%.4f.ckpt" % (str(epoch + 1), val_acc)) saver.save(sess, checkpoint_name) best_val_acc = val_acc
def train(): # 创建检查点文件夹 if not os.path.isdir(checkpoint_path): os.mkdir(checkpoint_path) # TF place holder x = tf.placeholder(tf.float32, [batch_size, 227, 227, 3]) y = tf.placeholder(tf.float32, [None, num_classes]) keep_prob = tf.placeholder(tf.float32) # build model model = DeepHashingNet(x, keep_prob, hash_K, train_layers) score = model.fch # List of trainable variables of the layers we want to train var_list = [v for v in tf.trainable_variables() if v.name.split('/')[0] in train_layers] # var_list = tf.trainable_variables() with tf.name_scope('cross_ent'): # loss = pairwise_cross_entropy_loss(score, y, class_num=10) + lam * quantization_loss(score) loss = pairwise_cross_entropy_loss(score, y, class_num=10)+ tf.multiply(tf.Variable(lam), tf.reduce_mean(tf.square(tf.subtract(tf.abs(score), tf.constant(1.0))))) # tf.Print(loss, [loss]) # loss = pairwise_cross_entropy_loss(score, y, class_num=10) # Train op with tf.name_scope('train'): # 计算梯度 gradients = tf.gradients(loss, var_list) gradients = list(zip(gradients, var_list)) # Create optimizer and apply gradient descent to the trainable variables optimizer = tf.train.GradientDescentOptimizer(learning_rate) train_op = optimizer.apply_gradients(grads_and_vars=gradients) # # 添加一堆summary # # Add gradients to summary # for gradient, var in gradients: # tf.summary.histogram(var.name + '/gradient', gradient) # # Add the variables we train to the summary # for var in var_list: # tf.summary.histogram(var.name, var) # # Add the loss to summary # tf.summary.scalar('loss_func', loss) # Evaluation op: Accuracy of the model # with tf.name_scope("accuracy"): # correct_pred = tf.equal(tf.argmax(score, 1), tf.argmax(y, 1)) # accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) # Add the accuracy to the summary # tf.summary.scalar('accuracy', accuracy) # Merge all summaries together # merged_summary = tf.summary.merge_all() # Initialize the FileWriter writer = tf.summary.FileWriter(filewriter_path) # Initialize an saver for store model checkpoints saver = tf.train.Saver() # Initialize the data generator seperately for the training and validation set train_generator = ImageDataGenerator(train_path, horizontal_flip=True, shuffle=True) val_generator = ImageDataGenerator(var_path, shuffle=False) # Get the number of training/validation steps per epoch train_batches_per_epoch = np.floor(train_generator.dataSize / batch_size).astype(np.int16) val_batches_per_epoch = np.floor(val_generator.dataSize / batch_size).astype(np.int16) # Start Tensorflow session with tf.Session() as sess: # Initialize all variables sess.run(tf.global_variables_initializer()) # Add the model graph to TensorBoard writer.add_graph(sess.graph) # Load the pretrained weights into the non-trainable layer model.loadInitialWeights(sess) print("{} Start training...".format(datetime.now())) print("{} Open Tensorboard at --logdir {}".format(datetime.now(), filewriter_path)) # Loop over number of epochs for epoch in range(num_epochs): print("{} Epoch number: {}".format(datetime.now(), epoch + 1)) step = 1 while step < train_batches_per_epoch: # Get a batch of images and labels batch_xs, batch_ys = train_generator.next_batch(batch_size) # And run the training op sess.run(train_op, feed_dict={x: batch_xs, y: batch_ys, keep_prob: dropout_rate}) print("{} Epoch number: {}".format(datetime.now(), step)) # Generate summary with the current batch of data and write to file # if step % display_step == 0: # s = sess.run(merged_summary, feed_dict={x: batch_xs, # y: batch_ys, # keep_prob: 1.}) # writer.add_summary(s, epoch * train_batches_per_epoch + step) step += 1 # Validate the model on the entire validation set # print("{} Start validation".format(datetime.now())) # test_acc = 0. # test_count = 0 # for _ in range(val_batches_per_epoch): # batch_tx, batch_ty = val_generator.next_batch(batch_size) # acc = sess.run(accuracy, feed_dict={x: batch_tx, # y: batch_ty, # keep_prob: 1.}) # test_acc += acc # test_count += 1 # test_acc /= test_count # print("{} Validation Accuracy = {:.4f}".format(datetime.now(), test_acc)) # Reset the file pointer of the image data generator val_generator.reset() train_generator.reset() print("{} Saving checkpoint of model...".format(datetime.now())) # save checkpoint of the model checkpoint_name = os.path.join(checkpoint_path, 'model_epoch' + str(epoch + 1) + '.ckpt') save_path = saver.save(sess, checkpoint_name) print("{} Model checkpoint saved at {}".format(datetime.now(), checkpoint_name))