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

 '''

    
     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)