话不多说,直接上干货。
猫狗大战数据集地址:链接: https://pan.baidu.com/s/1aUd29tHbfN0MLdWlgCGCCw 密码: 2pqv
下载完数据集以后,将文件解压后复制到分别下面的类似的目录中,注意这里我的图片的格式,格式不对,可能会导致代码不能运行。(格式的话,利用系统下的命名吧,我的实在是在Ubuntu下做的)
这里的train是我要训练的图片的目录。你可以设置其他的名字。
log目录是记载训练模型参数的地方。
test目录是验证集的地方。
code目录则是我的代码所在地。
目录介绍完毕以后,下面开始介绍代码了。
第一个代码块input_data.py,用于对数据集进行预处理。 由于代码注释的时候比较详细,这里就不在一一介绍了。
import tensorflow as tf
import os
import numpy as np
def get_files(file_dir):
cats = []
label_cats = []
dogs = []
label_dogs = []
for file in os.listdir(file_dir):
name = file.split(sep='.')
if 'cat' in name[0]:
cats.append(file_dir + file)
label_cats.append(0)
else:
if 'dog' in name[0]:
dogs.append(file_dir + file)
label_dogs.append(1)
image_list = np.hstack((cats, dogs))
label_list = np.hstack((label_cats, label_dogs))
# print('There are %d cats\nThere are %d dogs' %(len(cats), len(dogs)))
# 多个种类分别的时候需要把多个种类放在一起,打乱顺序,这里不需要
# 把标签和图片都放倒一个 temp 中 然后打乱顺序,然后取出来
temp = np.array([image_list, label_list])
temp = temp.transpose()
# 打乱顺序
np.random.shuffle(temp)
# 取出第一个元素作为 image 第二个元素作为 label
image_list = list(temp[:, 0])
label_list = list(temp[:, 1])
label_list = [int(i) for i in label_list]
return image_list, label_list
# 测试 get_files
# imgs , label = get_files('/Users/yangyibo/GitWork/pythonLean/AI/猫狗识别/testImg/')
# for i in imgs:
# print("img:",i)
# for i in label:
# print('label:',i)
# 测试 get_files end
# image_W ,image_H 指定图片大小,batch_size 每批读取的个数 ,capacity队列中 最多容纳元素的个数
def get_batch(image, label, image_W, image_H, batch_size, capacity):
# 转换数据为 ts 能识别的格式
image = tf.cast(image, tf.string)
label = tf.cast(label, tf.int32)
# 将image 和 label 放倒队列里
input_queue = tf.train.slice_input_producer([image, label])
label = input_queue[1]
# 读取图片的全部信息
print(input_queue[0])
image_contents = tf.read_file(input_queue[0])
# 把图片解码,channels =3 为彩色图片, r,g ,b 黑白图片为 1 ,也可以理解为图片的厚度
image = tf.image.decode_jpeg(image_contents, channels=3)
# 将图片以图片中心进行裁剪或者扩充为 指定的image_W,image_H
image = tf.image.resize_image_with_crop_or_pad(image, image_W, image_H)
# 对数据进行标准化,标准化,就是减去它的均值,除以他的方差
image = tf.image.per_image_standardization(image)
# 生成批次 num_threads 有多少个线程根据电脑配置设置 capacity 队列中 最多容纳图片的个数 tf.train.shuffle_batch 打乱顺序,
image_batch, label_batch = tf.train.batch(
[image, label], batch_size=batch_size, num_threads=64, capacity=capacity)
# 重新定义下 label_batch 的形状
label_batch = tf.reshape(label_batch, [batch_size])
# 转化图片
image_batch = tf.cast(image_batch, tf.float32)
return image_batch, label_batch
下面是model.py,卷积神经网络的框架
#coding=utf-8
import tensorflow as tf
#结构
#layer1_conv1 卷积层1
#Layer2_pooling1_lrn 池化层1
#layer3_conv2 卷积层2
#layer4_pooling2_lrn 池化层2
#layer5_local1 全连接层1
#layer6_local2 全连接层2
#softmax_linear 全连接层3
def inference(images, batch_size, n_classes, keep_prob=0.5):
#conv1
with tf.variable_scope('layer1_conv1') as scope:
#卷积核的大小为3*3,图片的通道是3,输出是16个featuremap
conv1_weights = tf.get_variable('weights',
shape=[3, 3, 3, 16],
dtype=tf.float32,
initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
conv1_biases = tf.get_variable('biases',
shape=[16],
dtype= tf.float32,
initializer=tf.constant_initializer(0.1))
##第一个和第四个只能为1,因为步长只对矩阵的长和宽有效
conv = tf.nn.conv2d(images, conv1_weights, strides=[1, 1, 1 ,1], padding='SAME')
pre_activation = tf.nn.bias_add(conv, conv1_biases)
conv1 = tf.nn.relu(pre_activation, name=scope.name)
#pooling1
with tf.variable_scope('layer2_pooling1_lrn') as scope:
#卷积核的大小为3*3,步长为2,输出是16个featuremap
#第一个和第四个只能为1,因为步长只对矩阵的长和宽有效
pooling1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides= [1, 2, 2, 1],padding='SAME', name= 'pooling1')
norm1 = tf.nn.lrn(pooling1, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm1')
#conv2
with tf.variable_scope('layer3_conv2') as scope:
#卷积核的大小是3*3,输入是16个featuremap,输出为16个featuremap
conv2_weights = tf.get_variable("weights",
shape=[3, 3, 16, 16],
dtype=tf.float32,
initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
conv2_biases = tf.get_variable('biases',
shape=[16],
dtype=tf.float32,
initializer=tf.constant_initializer(0.1))
conv = tf.nn.conv2d(norm1, conv2_weights, strides=[1, 1, 1, 1], padding='SAME')
pre_activation = tf.nn.bias_add(conv, conv2_biases)
conv2 = tf.nn.relu(pre_activation, name='conv2')
#pooling2
with tf.variable_scope('layer4_pooling2') as scope:
#卷积核的大小为3×3,步长为1
norm2 = tf.nn.lrn(conv2, depth_radius=4, bias=0.75, alpha=0.001/9.0,beta=0.75, name='norm2')
pooling2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1], strides=[1, 1, 1, 1], padding='SAME', name='pooling2')
#local1
with tf.variable_scope('layer5_local1') as scope:
reshaped = tf.reshape(pooling2, shape=[batch_size, -1])
dim = reshaped.get_shape()[1].value
local1_weights = tf.get_variable('weights',
shape=[dim, 128],
dtype=tf.float32,
initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
local1_biases = tf.get_variable('biases',
shape=[128],
dtype=tf.float32,
initializer=tf.constant_initializer(0.1))
local1 = tf.nn.relu(tf.matmul(reshaped, local1_weights) + local1_biases, name=scope.name)
# 添加dropout
local1 = tf.nn.dropout(local1, keep_prob)
#local2
with tf.variable_scope('layer6_local2') as scope:
local2_weights = tf.get_variable('weights',
shape=[128, 128],
dtype=tf.float32,
initializer=tf.truncated_normal_initializer(stddev=0.1,dtype=tf.float32))
local2_biases = tf.get_variable('biases',
shape=[128],
dtype=tf.float32,
initializer=tf.constant_initializer(0.1))
local2 = tf.nn.relu(tf.matmul(local1, local2_weights) + local2_biases, name='local2')
#softmax
with tf.variable_scope('softmax_linear') as scope:
weights = tf.get_variable('softmax_linear',
shape=[128, n_classes],
dtype=tf.float32,
initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
biases = tf.get_variable('biases',
shape=[n_classes],
dtype=tf.float32,
initializer=tf.constant_initializer(0.1))
softmax_linear = tf.add(tf.matmul(local2, weights), biases, name='softmax_line')
return softmax_linear
def losses(logits, labels):
with tf.variable_scope('loss') as scope:
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=labels, name='xentropy_per_example')
loss = tf.reduce_mean(cross_entropy, name='loss')
tf.summary.scalar(scope.name + '/loss', loss)
return loss
def training(loss, learning_rate):
with tf.variable_scope('optimizer'):
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
global_step = tf.Variable(0,name='global_step', trainable=False)
train_op = optimizer.minimize(loss, global_step=global_step)
return train_op
def evaluation(logits, labels):
with tf.variable_scope('accuracy') as scope:
correct = tf.nn.in_top_k(logits, labels, 1)
correct = tf.cast(correct, tf.float16)
accuracy = tf.reduce_mean(correct)
tf.summary.scalar(scope.name + '/accuracy', accuracy)
return accuracy
下面是train.py,用于开始训练。注意如果你的电脑配置不是很高的话可以适当降低batch_size,如果你觉得电脑配置还行,可以增大batch_size。代码如下:
import os
import numpy as np
import tensorflow as tf
import input_data
import model
N_CLASSES = 2 # 2个输出神经元,[1,0] 或者 [0,1]猫和狗的概率
IMG_W = 256 # 重新定义图片的大小,图片如果过大则训练比较慢
IMG_H = 256
BATCH_SIZE = 32 # 每批数据的大小
CAPACITY = 256
MAX_STEP = 10000 # 训练的步数,应当 >= 10000
learning_rate = 0.00005 # 学习率,建议刚开始的 learning_rate <= 0.0001
def run_training():
# 数据集
train_dir = "/home/tree/deeplearning/tflow/catAnddog/train1/" # My dir
# logs_train_dir 存放训练模型的过程的数据,在tensorboard 中查看
logs_train_dir = '/home/tree/deeplearning/tflow/catAnddog/log/'
# 获取图片和标签集
train, train_label = input_data.get_files(train_dir)
# 生成批次
train_batch, train_label_batch = input_data.get_batch(train,
train_label,
IMG_W,
IMG_H,
BATCH_SIZE,
CAPACITY)
# 进入模型
train_logits = model.inference(train_batch, BATCH_SIZE, N_CLASSES)
# 获取 loss
train_loss = model.losses(train_logits, train_label_batch)
# 训练
train_op = model.trainning(train_loss, learning_rate)
# 获取准确率
train__acc = model.evaluation(train_logits, train_label_batch)
# 合并 summary
summary_op = tf.summary.merge_all()
sess = tf.Session()
# 保存summary
train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph)
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
try:
for step in np.arange(MAX_STEP):
if coord.should_stop():
break
_, tra_loss, tra_acc = sess.run([train_op, train_loss, train__acc])
if step % 50 == 0:
print('Step %d, train loss = %.2f, train accuracy = %.2f%%' %
(step, tra_loss, tra_acc*100.0))
summary_str = sess.run(summary_op)
train_writer.add_summary(summary_str, step)
if step % 2000 == 0 or (step + 1) == MAX_STEP:
# 每隔2000步保存一下模型,模型保存在 checkpoint_path 中
checkpoint_path = os.path.join(logs_train_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
except tf.errors.OutOfRangeError:
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
sess.close()
# train
run_training()
训练完了以后你就会发现log下面有很多的文件,下面开始测试,evaluate.py:
# coding=utf-8
import tensorflow as tf
from PIL import Image
import matplotlib.pyplot as plt
import input_data
import numpy as np
import model
import os
# 从训练集中选取一张图片
def get_one_image(train):
files = os.listdir(train)
n = len(files)
ind = np.random.randint(0, n)
img_dir = os.path.join(train, files[ind])
image = Image.open(img_dir)
plt.imshow(image)
plt.show()
image = image.resize([256, 256])
image = np.array(image)
return image
def evaluate_one_image():
train = '/home/tree/deeplearning/tflow/catAnddog/test/'
# 获取图片路径集和标签集
image_array = get_one_image(train)
with tf.Graph().as_default():
BATCH_SIZE = 1 # 因为只读取一副图片 所以batch 设置为1
N_CLASSES = 2 # 2个输出神经元,[1,0] 或者 [0,1]猫和狗的概率
# 转化图片格式
image = tf.cast(image_array, tf.float32)
# 图片标准化
image = tf.image.per_image_standardization(image)
# 图片原来是三维的 [208, 208, 3] 重新定义图片形状 改为一个4D 四维的 tensor
image = tf.reshape(image, [1, 256, 256, 3])
logit = model.inference(image, BATCH_SIZE, N_CLASSES)
# 因为 inference 的返回没有用激活函数,所以在这里对结果用softmax 激活
logit = tf.nn.softmax(logit)
# 用最原始的输入数据的方式向模型输入数据 placeholder
x = tf.placeholder(tf.float32, shape=[256, 256, 3])
# 我门存放模型的路径
logs_train_dir = '/home/tree/deeplearning/tflow/catAnddog/log/'
# 定义saver
saver = tf.train.Saver()
with tf.Session() as sess:
print("Loding......")#从指定的路径中加载模型。。。。
# 将模型加载到sess 中
ckpt = tf.train.get_checkpoint_state(logs_train_dir)
if ckpt and ckpt.model_checkpoint_path:
global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
saver.restore(sess, ckpt.model_checkpoint_path)
print('Successfully loding...... the step of training is %s' % global_step)#模型加载成功, 训练的步数为
else:
print('unsuccessfully loding......can not fing the file')#模型加载失败,,,文件没有找到
# 将图片输入到模型计算
prediction = sess.run(logit, feed_dict={x: image_array})
# 获取输出结果中最大概率的索引
max_index = np.argmax(prediction)
if max_index == 0:
print(" The accu of cat is %.6f" % prediction[:, 0])#cat的概率
else:
print(" The accu of dog is %.6f" % prediction[:, 1])#dog的概率
# 测试
evaluate_one_image()
好了,做完这些你就应该符卷积神经网络训练过程有一个大致的把握了,这里有一点需要注意,windows下的文件路径需要设置为‘\\’。
经典的案例介绍完了,如果你对它理解的还算深刻的话,可以开始试着加入自己的训练集,训练一些你自己的图片了,这会让学习变的有趣一些。等你积累了足够多的经验以及知识后,你会有更加好的改进方法来提升准确率。
如果你还有什么不清楚的,可以给我留言。