猫狗大战实战经典卷积神经网络

话不多说，直接上干货。


猫狗大战数据集地址：链接: 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下的文件路径需要设置为‘\\’。
经典的案例介绍完了，如果你对它理解的还算深刻的话，可以开始试着加入自己的训练集，训练一些你自己的图片了，这会让学习变的有趣一些。等你积累了足够多的经验以及知识后，你会有更加好的改进方法来提升准确率。
如果你还有什么不清楚的，可以给我留言。