1. Inception-ResNet-v1简介
2.实验代码
import inception_resnet_v1
import tensorflow.contrib.slim as slim
import numpy as np
import cv2
import face_image_input
import tensorflow as tf
from datetime import datetime
import math
import time
import os
import matplotlib.pyplot as plt
# 配置神经网络的参数
BATCH_SIZE = 128
batch_size = 128
LEARNING_RATE_BASE = 0.01 #0.8 #
LEARNING_RATE_DECAY = 0.0005 # 0.99
REGULARAZTION_RATE = 0.0001
TRAIN_STEPS = 10000 #3000
MOVING_AVERAGE_DECAY = 0.99
MODEL_SAVE_PATH = "./model/"
MODEL_NAME = "model3.ckpt"
slim = tf.contrib.slim
DATA_DIR = './datasets/data/flowers'
# 输出类别
NUM_CLASSES = 5
# 获取图片大小
IMAGE_SIZE = 160
def face_fine_tuning():
'''
1.设置参数，并加载数据
'''
# 用于保存微调后的检查点文件和日志文件路径
train_log_dir = './finetune_face'
train_log_file = 'face_fine_tune.ckpt'
# 官方下载的检查点文件路径
checkpoint_file = './20180402-114759/model-20180402-114759.ckpt-275' # -275.index
# './20180402-114759/model-20180402-114759.ckpt-275'
learning_rate = 1e-4
# 设置batch_size
batch_size =32 # 32 #128 #256
# 训练集数据长度
n_train = 120 #3320
# 测试集数据长度
# n_test = 350
# 迭代轮数
training_epochs = 500 #100
display_epoch = 1
if not tf.gfile.Exists(train_log_dir):
tf.gfile.MakeDirs(train_log_dir)
# 加载数据
train_images, train_labels = face_image_input.distorted_inputs("",batch_size)
test_images, test_labels = face_image_input.inputs(eval_data=False, data_dir="", batch_size=batch_size)
# 获取模型参数的命名空间
#arg_scope = inception_resnet_v1.vgg_arg_scope()
#arg_scope = inception_resnet_v2_arg_scope()
# 创建网络
#with slim.arg_scope(""):
if 1==1:
'''
2.定义占位符和网络结构
'''
# 输入图片
input_images = tf.placeholder(dtype=tf.float32, shape=[None, IMAGE_SIZE, IMAGE_SIZE, 3])
# 图片标签
input_labels = tf.placeholder(dtype=tf.float32, shape=[None, 5])
#input_labels = tf.placeholder(dtype=tf.int32, shape=[batch_size])
label_holder = tf.placeholder(tf.int32, [batch_size], name='y-input')
# 训练还是测试？测试的时候弃权参数会设置为1.0
is_training = tf.placeholder(dtype=tf.bool)
# 创建vgg16网络 如果想冻结所有层，可以指定slim.conv2d中的 trainable=False
logits, end_points = inception_resnet_v1.inception_resnet_v1(input_images, is_training=is_training)
# print(end_points) 每个元素都是以vgg_16/xx命名
# Restore only the convolutional layers: 从检查点载入当前图除了fc8层之外所有变量的参数
params = slim.get_variables_to_restore(exclude=['Logits','InceptionResnetV1/Bottleneck'])
variables_to_restore = slim.get_variables_to_restore(exclude=['Logits','InceptionResnetV1/Bottleneck'])
#InceptionResnetV1/Bottleneck
print("输出变量000：")
print(variables_to_restore)
# 用于恢复模型 如果使用这个保存或者恢复的话，只会保存或者恢复指定的变量
restorer = tf.train.Saver(params)
init_assign_op, init_feed_dict = slim.assign_from_checkpoint(checkpoint_file, variables_to_restore,ignore_missing_vars=True)
# 预测标签
pred = tf.argmax(logits, axis=1)
'''
定义代价函数和优化器
'''
# 代价函数
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=input_labels, logits=logits))
# 设置优化器
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost) #全部参数重新训练
# 预测结果评估
correct = tf.equal(pred, tf.argmax(input_labels, 1)) # 返回一个数组 表示统计预测正确或者错误
accuracy = tf.reduce_mean(tf.cast(correct, tf.float32)) # 求准确率
num_batch = int(np.ceil(n_train / batch_size))
# 用于保存检查点文件
save = tf.train.Saver(max_to_keep=1)
# 恢复模型
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
variables_to_restore1 = sess.run(variables_to_restore)
#print("输出变量：")
#print(variables_to_restore1)
# 检查最近的检查点文件
ckpt = tf.train.latest_checkpoint(train_log_dir)
if ckpt != None:
save.restore(sess, ckpt)
print('从上次训练保存后的模型继续训练！')
else:
#restorer.restore(sess, checkpoint_file)
sess.run(init_assign_op, init_feed_dict) # 添加
print('从官方模型加载训练！')
# 创建一个协调器，管理线程
coord = tf.train.Coordinator()
# 启动QueueRunner, 此时文件名才开始进队。
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
'''
查看预处理之后的图片
imgs, labs = sess.run([train_images, train_labels])
print('原始训练图片信息：', imgs.shape, labs.shape)
print("lable:",labs)
labs = tf.one_hot(labs, depth=5, axis=-1)
print('原始测试图片信息：', imgs.shape, labs.shape)
print("lable:", labs)
show_img = np.array(imgs[0], dtype=np.uint8)
plt.imshow(show_img)
plt.title('Original train image')
plt.show()
imgs, labs = sess.run([test_images, test_labels])
print('原始测试图片信息：', imgs.shape, labs.shape)
labs = tf.one_hot(labs, depth=5, axis=-1)
print('原始测试图片信息：', imgs.shape, labs.shape)
show_img = np.array(imgs[0], dtype=np.uint8)
plt.imshow(show_img)
plt.title('Original test image')
plt.show()
'''
print('开始训练！')
for epoch in range(training_epochs):
total_cost = 0.0
print("训练111111！！！")
for i in range(num_batch):
print("批次："+str(i))
print("训练222222！！！")
imgs, labs = sess.run([train_images, train_labels])
labs = tf.one_hot(labs, depth=5, axis=-1)
print('原始训练图片信息,程序运行中：', imgs.shape, labs.shape)
labs = sess.run(labs)
#print(labs)
#print(type(labs))
_, loss = sess.run([optimizer, cost],
feed_dict={input_images: imgs, input_labels: labs, is_training: True})
total_cost += loss
print("训练ing！！！")
# 打印信息
if epoch % display_epoch == 0:
print('Epoch {}/{} average cost {:.9f}'.format(epoch + 1, training_epochs, total_cost / num_batch))
# 进行预测处理
imgs, labs = sess.run([test_images, test_labels])
labs = tf.one_hot(labs, depth=5, axis=-1)
labs = sess.run(labs)
print('原始测试图片信息，程序运行中：', imgs.shape, labs.shape)
#print(labs)
#labs = labs.eval()
#print(type(labs))
cost_values, accuracy_value = sess.run([cost, accuracy],
feed_dict={input_images: imgs, input_labels: labs,
is_training: False})
print('Epoch {}/{} Test cost {:.9f}'.format(epoch + 1, training_epochs, cost_values))
print('准确率:', accuracy_value)
# 保存模型
save.save(sess, os.path.join(train_log_dir, train_log_file), global_step=epoch)
print('Epoch {}/{} 模型保存成功'.format(epoch + 1, training_epochs))
print('训练完成')
# 终止线程
coord.request_stop()
coord.join(threads)
def face_test():
'''
使用微调好的网络进行测试
'''
'''
1.设置参数，并加载数据
'''
# 微调后的检查点文件和日志文件路径
save_dir = './finetune_face'
# 设置batch_size
batch_size = 64 #128
# 加载数据
train_images, train_labels = face_image_input.distorted_inputs("", batch_size)
test_images, test_labels = face_image_input.inputs(eval_data=False, data_dir="", batch_size=batch_size)
# 获取模型参数的命名空间
#arg_scope = inception_resnet_v1.vgg_arg_scope()
# 创建网络
#with slim.arg_scope(arg_scope):
if 1==1:
'''
2.定义占位符和网络结构
'''
# 输入图片
input_images = tf.placeholder(dtype=tf.float32, shape=[None, IMAGE_SIZE, IMAGE_SIZE, 3])
# 训练还是测试？测试的时候弃权参数会设置为1.0
is_training = tf.placeholder(dtype=tf.bool)
# 创建vgg16网络
logits, end_points = inception_resnet_v1.inception_resnet_v1(input_images, is_training=False)
# 预测标签
pred = tf.argmax(logits, axis=1)
restorer = tf.train.Saver()
# 恢复模型
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
ckpt = tf.train.latest_checkpoint(save_dir)
if ckpt != None:
# 恢复模型
restorer.restore(sess, ckpt)
print("Model restored.")
# 创建一个协调器，管理线程
coord = tf.train.Coordinator()
# 启动QueueRunner, 此时文件名才开始进队。
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
'''
查看预处理之后的图片
'''
imgs, labs = sess.run([test_images, test_labels])
print('原始测试图片信息：', imgs.shape, labs.shape)
show_img = np.array(imgs[0], dtype=np.uint8)
plt.imshow(show_img)
plt.title('Original test image')
plt.show()
pred_value = sess.run(pred, feed_dict={input_images: imgs, is_training: False})
print('预测结果为：', pred_value)
print('实际结果为：', labs)
correct = np.equal(pred_value, labs)
print('准确率为:', np.mean(correct))
# 终止线程
coord.request_stop()
coord.join(threads)
if __name__ == '__main__':
tf.reset_default_graph()
face_fine_tuning()
tf.reset_default_graph()
face_test()
3.实验结果
3.1
batch_size =16
# 训练集数据长度
n_train = 163
# 迭代轮数
training_epochs =10
（1）准确率为: 0.40625
3.2
batch_size =32
# 训练集数据长度
n_train = 163 #3320
# 迭代轮数
training_epochs = 50
（2）训练: Epoch 50/50 Test cost 3.713762522
准确率: 0.4375
Epoch 50/50 模型保存成功
准确率为: 0.390625
3.3 Epoch 100/100 Test cost 4.668624878
准确率: 0.46875
Epoch 100/100 模型保存成功
训练完成
原始测试图片信息： (64, 160, 160, 3) (64,)
预测结果为： [1 3 1 2 2 0 2 1 1 0 2 2 4 4 2 3 1 2 2 2 2 4 4 2 2 4 4 1 1 4 3 4 1 1 2 2 4
2 0 2 0 1 3 2 4 2 2 2 1 2 2 2 4 2 4 1 4 4 4 1 3 2 1 1]
实际结果为： [0 0 0 0 0 2 2 1 1 2 2 1 1 1 2 2 2 2 2 2 2 3 4 3 4 4 4 4 0 4 0 4 1 0 0 2 1
0 2 1 2 1 2 2 1 2 2 2 2 2 2 3 3 4 4 4 4 4 4 0 0 0 0 1]
准确率为: 0.4375
3.4 Epoch 500/500 average cost 0.000000050
原始测试图片信息，程序运行中： (32, 160, 160, 3) (32, 5)
Epoch 500/500 Test cost 6.768644810
准确率: 0.4375
Epoch 500/500 模型保存成功
训练完成
['./bin/face_train_160_tf']
开始读取lable：
Tensor("data_augmentation/Cast:0", shape=(?,), dtype=int32)
读取数据完成！
<class 'face_image_input.read_cifar10.<locals>.CIFAR10Record'>
Filling queue with 203 CIFAR images before starting to train. This will take a few minutes.
shuffle1111
开始读取lable：
Tensor("input/Cast:0", shape=(?,), dtype=int32)
shuffle0000
Model restored.
原始测试图片信息： (64, 160, 160, 3) (64,)
预测结果为： [1 2 1 1 2 3 4 2 1 1 2 0 3 2 0 4 4 2 2 1 4 2 2 2 1 4 4 2 2 1 1 2 4 1 2 1 1
2 3 4 2 1 0 2 2 3 0 4 2 2 1 1 4 4 1 2 4 2 4 4 4 2 2 2]
实际结果为： [0 0 1 0 0 0 1 2 1 1 2 2 2 1 2 2 3 3 2 2 4 2 2 2 4 4 4 0 1 1 1 2 4 4 4 0 0
0 0 1 2 1 2 2 2 2 2 2 3 2 4 2 4 3 4 4 4 1 4 4 1 2 2 0]
准确率为: 0.421875
3.5
Epoch 1000/1000 Test cost 20.401565552
准确率: 0.375
Epoch 1000/1000 模型保存成功
训练完成
['./bin/face_train_160_tf']
开始读取lable：
Tensor("data_augmentation/Cast:0", shape=(?,), dtype=int32)
读取数据完成！
<class 'face_image_input.read_cifar10.<locals>.CIFAR10Record'>
Filling queue with 203 CIFAR images before starting to train. This will take a few minutes.
shuffle1111
开始读取lable：
Tensor("input/Cast:0", shape=(?,), dtype=int32)
shuffle0000
Model restored.
原始测试图片信息： (64, 160, 160, 3) (64,)
预测结果为： [1 2 4 1 1 4 0 0 4 1 2 4 0 2 4 1 2 2 1 2 2 2 3 2 4 4 2 2 4 4 1 4 1 2 1 4 0
0 4 1 2 0 2 4 1 4 2 1 2 2 3 2 2 4 2 4 2 4 2 2 1 4 1 4]
实际结果为： [0 0 0 0 1 0 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3 2 4 4 4 4 4 4 4 0 0 0 0 1 0 1
1 1 1 2 2 2 2 2 2 2 2 2 2 2 3 3 4 4 4 4 4 0 4 0 4 0 0]
准确率为: 0.34375
参考资料
Inception-ResNet-v1
[1] 深度学习--Inception-ResNet-v1网络结构
[2] ResNet-V1-50卷积神经网络迁移学习进行不同品种的花的分类识别
[3] 【Tensorflow系列】使用Inception_resnet_v2训练自己的数据集并用Tensorboard监控
[4] 使用TensorFlow打造自己的图像识别模型
[5] tensorflow实现迁移学习 此例程出自《TensorFlow实战Google深度学习框架》6.5.2小节 卷积神经网络迁移学习
官方代码
[1] davidsandberg/facenet
[2] Classifier training of inception resnet v1
[3] facenet/src/models/inception_resnet_v1.py
