【图像识别】猫狗识别（CNN）

水深无声 2021-11-01 13:22 974阅读 0赞

>  **数据集：**
> 
> 1.  共2000张图片，1000张狗，1000张猫；
> 2.  1400张用于训练，600张用于测试；
> 3.  图片均为 RGB 3 通道，尺寸大小不一。
> 
> 数据链接：[https://pan.baidu.com/s/15E9D6qztrY3bfZp5kil2Fw ][https_pan.baidu.com_s_15E9D6qztrY3bfZp5kil2Fw]  
> 提取码：8qin
> 
> **模型：**
> 
> 1.  卷积层：卷积核大小3\*3，个数64个；
> 2.  卷积层：卷积核大小3\*3，个数64个；
> 3.  卷积层：卷积核大小3\*3，个数128个；
> 4.  全连接层
> 5.  全连接层（输出层）

'''
        train.py
    '''
    import dataset
    import tensorflow as tf
    import numpy as np
    import time
    import math
    import random
    
    batch_size = 32         # 每批样本数
    
    validation_size = 0.3   # 测试集所占比例
    img_size = 64           # 图片尺寸大小
    num_channels = 3        # 图像通道数（RGB)
    train_path = 'training_data' # 训练数据集路径
    
    classes = ['dogs', 'cats']
    # ---1. 加载数据---
    data = dataset.read_train_sets(train_path, img_size, classes, validation_size=validation_size)
    
    session = tf.Session()
    x = tf.placeholder(tf.float32, shape=[None, img_size, img_size, num_channels], name='x')
    y_true = tf.placeholder(tf.float32, shape=[None, 2], name='y_true')
    
    y_true_class = tf.argmax(y_true, dimension=1)
    
    # ---2. 构建模型---
    def create_weight(shape):
        return tf.Variable(tf.random_normal(shape, stddev=0.05))
    
    def create_bias(size):
        return tf.Variable(tf.constant(0.05, shape=[size]))
    
    def create_flatten_layer(layer):
        layer_shape = layer.get_shape()
        num_features = layer_shape[1:4].num_elements()
        layer = tf.reshape(layer, [-1, num_features])
        return layer
    
    # 第一层卷积层，卷积核大小为3*3，个数为64
    weight1 = create_weight(shape=[3, 3, 3, 64])
    bias1 = create_bias(size=64)
    kernel1 = tf.nn.conv2d(input=x, filter=weight1, strides=[1, 1, 1, 1], padding='SAME')
    layer1 = tf.nn.relu(tf.nn.bias_add(kernel1, bias1))
    layer1 = tf.nn.max_pool(value=layer1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
    
    # 第二层卷积层，卷积核大小为3*3，个数为64
    weight2 = create_weight(shape=[3, 3, 64, 64])
    bias2 = create_bias(size=64)
    kernel2 = tf.nn.conv2d(input=layer1, filter=weight2, strides=[1, 1, 1, 1], padding='SAME')
    layer2 = tf.nn.relu(tf.nn.bias_add(kernel2, bias2))
    layer2 = tf.nn.max_pool(value=layer2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
    
    # 第三层卷积层，卷积核大小为3*3，个数为128
    weight3 = create_weight(shape=[3, 3, 64, 128])
    bias3 = create_bias(size=128)
    kernel3 = tf.nn.conv2d(input=layer2, filter=weight3, strides=[1, 1, 1, 1], padding='SAME')
    layer3 = tf.nn.relu(tf.nn.bias_add(kernel3, bias3))
    layer3 = tf.nn.max_pool(value=layer3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
    
    # 全连接层前的reshape
    layer_flat = create_flatten_layer(layer3)
    
    # 第四层全连接层
    weight4 = create_weight(shape=[layer_flat.get_shape()[1:4].num_elements(), 1024])
    bias4 = create_bias(size=1024)
    layer4 = tf.matmul(layer_flat, weight4) + bias4
    layer4 = tf.nn.dropout(layer4, keep_prob=0.7)
    layer4 = tf.nn.relu(layer4)
    
    # 第五层全连接层
    weight5 = create_weight(shape=[1024, 2])
    bias5 = create_bias(size=2)
    layer5 = tf.matmul(layer4, weight5) + bias5
    layer5 = tf.nn.dropout(layer5, keep_prob=0.7)
    
    y_pred = tf.nn.softmax(layer5, name='y_pred')
    
    y_pred_class = tf.arg_max(y_pred, dimension=1)
    
    session.run(tf.global_variables_initializer())
    cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=layer5,labels=y_true)
    
    cost = tf.reduce_mean(cross_entropy)
    optimizer = tf.train.AdamOptimizer(learning_rate=0.0005).minimize(cost)
    correct_prediction = tf.equal(y_pred_class, y_true_class)
    # 计算正确率
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    
    session.run(tf.global_variables_initializer()) 
    
    saver = tf.train.Saver()
    
    def train(num_iteration):
    
        for i in range(num_iteration):
            # train 训练集
            x_batch, y_true_batch, _, cls_batch = data.train.next_batch(batch_size)
            feed_dict_tr = {x: x_batch, y_true: y_true_batch}
    
            session.run(optimizer, feed_dict=feed_dict_tr)
    
            if i % 50 == 0: 
                #val_loss = session.run(cost, feed_dict=feed_dict_val)
                epoch = int(i / 50)
                
                # 打印信息
                acc = session.run(accuracy, feed_dict=feed_dict_tr)
                #val_acc = session.run(accuracy, feed_dict=feed_dict_val)
    
                msg = "Training Epoch {0}--- iterations: {1}--- Training Accuracy: {2:>6.1%}"
                print(msg.format(epoch, i, acc))
    
                # 保存模型
                saver.save(session, './dogs-cats-model/dog-cat.ckpt',global_step=i) 
    
    def test(num_iteration):
        ave_loss = 0.0
        ave_acc = 0.0
        for _ in range(num_iteration):
            x_valid_batch, y_valid_batch, _, valid_cls_batch = data.valid.next_batch(batch_size)
            feed_dict_val = {x: x_valid_batch, y_true: y_valid_batch}
            val_loss = session.run(cost, feed_dict=feed_dict_val)
            val_acc = session.run(accuracy, feed_dict=feed_dict_val)
            ave_acc += val_acc
            ave_loss += val_loss
        ave_acc = ave_acc / num_iteration
        ave_loss = ave_loss / num_iteration
        msg = "ave_acc = {0:>6.1%}, ave_loss = {1}"
        print(msg.format(ave_acc,ave_loss))
    
    train(num_iteration=7000)
    test(num_iteration=60)

> **output：** ave\_acc = 71.1%, ave\_loss = 1.8036026974519095
> 
> *训练之后准确率只有70%左右，后续学习再修改吧。*

参考资料：

[网易云课程——猫狗识别，代码讲的很清晰][Link 1]

[https_pan.baidu.com_s_15E9D6qztrY3bfZp5kil2Fw]: https://pan.baidu.com/s/15E9D6qztrY3bfZp5kil2Fw%C2%A0
[Link 1]: https://study.163.com/course/introduction/1006233017.htm