TensorFlow详解猫狗识别（二）--定义神经网络

r囧r小猫 2022-05-15 03:50 435阅读 0赞

**这里附上亲测的两个神经网络模型Lenet5&AlexNet7以及损失函数loss，优化器反向传播，评估函数evaluation**

## 介绍 ##

LeNet5：LeNet5诞生于1994年，是最早的卷积神经网络之一， 并且推动了深度学习领域的发展。自从1988年开始，在许多次成功的迭代后，这项由Yann LeCun完成的开拓性成果被命名为LeNet5。

AlexNet：AlexNet是2012年ImageNet竞赛冠军获得者Hinton和他的学生Alex Krizhevsky设计的。也是在那年之后，更多的更深的神经网路被提出，比如优秀的vgg,GoogleLeNet。其官方提供的数据模型，准确率达到57.1%,top 1-5 达到80.2%. 这项对于传统的机器学习分类算法而言，已经相当的出色。

下面贴出神经网络代码

## model01（LeNet5） ##

import tensorflow as tf
    
    def inference(images, batch_size, n_classes):
        # 一个简单的卷积神经网络，卷积+池化层x2，全连接层x2，最后一个softmax层做分类。
        # 卷积层1
        # 16个3x3的卷积核（3通道），padding=’SAME’，表示padding后卷积的图与原图尺寸一致，激活函数relu()
        with tf.variable_scope('conv1') as scope:
            #tf.tuncated_normal从截断的正态分布中输出随机值,
            # 生成的值服从具有指定平均值和标准偏差的状态分布，如果生成的值大于平均值两个标准偏差的值，则丢弃
            #stddev正太分布的标准差
            weights = tf.Variable(tf.truncated_normal(shape=[3, 3, 3, 16], stddev=0.1, dtype=tf.float32),
                                  name='weights', dtype=tf.float32)
            #tf.constant初始化常量
            biases = tf.Variable(tf.constant(value=0.1, dtype=tf.float32, shape=[16]),
                                 name='biases', dtype=tf.float32)
            #nn.conv2d，第一个参数为input,指需要做卷积的输入图像，第二个参数，卷积核，第三个参数步长，
            # 第四个设置为SAME表示可以停留在图像边上
            conv = tf.nn.conv2d(images, weights, strides=[1, 1, 1, 1], padding='SAME')
            pre_activation = tf.nn.bias_add(conv, biases)
            conv1 = tf.nn.relu(pre_activation, name=scope.name)
        # 池化层1
        # 3x3最大池化，步长strides为2，池化后执行lrn()操作，局部响应归一化，对训练有利。
        with tf.variable_scope('pooling1_lrn') as scope:
            #第一个参数，需要池化的输入
            #第二个参数池化窗口的大小
            #第三个参数步长
            #第四个参数同上
            pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1], padding='SAME', name='pooling1')
            #
            norm1 = tf.nn.lrn(pool1, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm1')
        # 卷积层2
        # 16个3x3的卷积核（16通道），padding=’SAME’，表示padding后卷积的图与原图尺寸一致，激活函数relu()
        with tf.variable_scope('conv2') as scope:
            weights = tf.Variable(tf.truncated_normal(shape=[3, 3, 16, 16], stddev=0.1, dtype=tf.float32),
                                  name='weights', dtype=tf.float32)
            biases = tf.Variable(tf.constant(value=0.1, dtype=tf.float32, shape=[16]),
                                 name='biases', dtype=tf.float32)
    
            conv = tf.nn.conv2d(norm1, weights, strides=[1, 1, 1, 1], padding='SAME')
            pre_activation = tf.nn.bias_add(conv, biases)
            conv2 = tf.nn.relu(pre_activation, name='conv2')
        # 池化层2
        # 3x3最大池化，步长strides为2，池化后执行lrn()操作，
        # pool2 and norm2
    
        with tf.variable_scope('pooling2_lrn') as scope:
            norm2 = tf.nn.lrn(conv2, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm2')
            pool2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1], strides=[1, 1, 1, 1], padding='SAME', name='pooling2')
        # 全连接层3
        # 128个神经元，将之前pool层的输出reshape成一行，激活函数relu()
    
        with tf.variable_scope('local3') as scope:
            reshape = tf.reshape(pool2, shape=[batch_size, -1])
            dim = reshape.get_shape()[1].value
            weights = tf.Variable(tf.truncated_normal(shape=[dim, 128], stddev=0.005, dtype=tf.float32),
                                  name='weights', dtype=tf.float32)
            biases = tf.Variable(tf.constant(value=0.1, dtype=tf.float32, shape=[128]),
                                 name='biases', dtype=tf.float32)
            local3 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)
        # 全连接层4
    
        # 128个神经元，激活函数relu()
    
        with tf.variable_scope('local4') as scope:
            weights = tf.Variable(tf.truncated_normal(shape=[128, 128], stddev=0.005, dtype=tf.float32),
                                  name='weights', dtype=tf.float32)
            biases = tf.Variable(tf.constant(value=0.1, dtype=tf.float32, shape=[128]),
                                 name='biases', dtype=tf.float32)
            local4 = tf.nn.relu(tf.matmul(local3, weights) + biases, name='local4')
    
        # dropout层
        #    with tf.variable_scope('dropout') as scope:
        #        drop_out = tf.nn.dropout(local4, 0.8)
        # Softmax回归层
    
        # 将前面的FC层输出，做一个线性回归，计算出每一类的得分，在这里是2类，所以这个层输出的是两个得分。
        with tf.variable_scope('softmax_linear') as scope:
            weights = tf.Variable(tf.truncated_normal(shape=[128, n_classes], stddev=0.005, dtype=tf.float32),
                                  name='softmax_linear', dtype=tf.float32)
            biases = tf.Variable(tf.constant(value=0.1, dtype=tf.float32, shape=[n_classes]),
                                 name='biases', dtype=tf.float32)
            softmax_linear = tf.add(tf.matmul(local4, weights), biases, name='softmax_linear')
        return softmax_linear
    
    # -----------------------------------------------------------------------------
    # loss计算
    # 传入参数：logits，网络计算输出值。labels，真实值，在这里是0或者1
    # 返回参数：loss，损失值
    
    
    
    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
    
    # --------------------------------------------------------------------------
    # loss损失值优化
    # 输入参数：loss。learning_rate，学习速率。
    # 返回参数：train_op，训练op，这个参数要输入sess.run中让模型去训练。
    def trainning(loss, learning_rate):
        with tf.name_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
    
    # -----------------------------------------------------------------------
    
    # 评价/准确率计算
    
    # 输入参数：logits，网络计算值。labels，标签，也就是真实值，在这里是0或者1。
    
    # 返回参数：accuracy，当前step的平均准确率，也就是在这些batch中多少张图片被正确分类了。
    
    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

## model02（AlexNet） ##

import tensorflow as tf
    import numpy as np
    
    
    def AlexNet(X, KEEP_PROB, NUM_CLASSES):
        """Create the network graph."""
        # 1st Layer: Conv (w ReLu) -> Lrn -> Pool
        conv1 = conv(X, [5, 5, 3, 64], [64], 1, 1, name='conv1')
        norm1 = lrn(conv1, 2, 1e-05, 0.75, name='norm1')
        pool1 = max_pool(norm1, 2, 2, 2, 2, name='pool1')  ##64*64*64
        # 2nd Layer: Conv (w ReLu)  -> Lrn -> Pool with 2 groups
        conv2 = conv(pool1, [5, 5, 64, 128], [128], 1, 1, name='conv2')
        norm2 = lrn(conv2, 2, 1e-05, 0.75, name='norm2')
        pool2 = max_pool(norm2, 2, 2, 2, 2, name='pool2')  ##32*32*128
        # 3rd Layer: Conv (w ReLu)
        conv3 = conv(pool2, [3, 3, 128, 256], [256], 1, 1, name='conv3')
        # 4th Layer: Conv (w ReLu) splitted into two groups
        conv4 = conv(conv3, [3, 3, 256, 512], [512], 1, 1, name='conv4')
        # 5th Layer: Conv (w ReLu) -> Pool splitted into two groups
        conv5 = conv(conv4, [3, 3, 512, 512], [512], 1, 1, name='conv5')
        pool5 = max_pool(conv5, 2, 2, 2, 2, name='pool5')
        # 6th Layer: Flatten -> FC (w ReLu) -> Dropout
        flattened = tf.reshape(pool5, [-1, 16 * 16 * 512])
        fc6 = fc(flattened, [16 * 16 * 512, 1024], [1024], name='fc6')
        fc6 = tf.nn.relu(fc6)
        dropout6 = dropout(fc6, KEEP_PROB)
        # 7th Layer: FC (w ReLu) -> Dropout
        fc7 = fc(dropout6, [1024, 2048], [2048], name='fc7')
        fc7 = tf.nn.relu(fc7)
        dropout7 = dropout(fc7, KEEP_PROB)
        # 8th Layer: FC and return unscaled activations
        fc8 = fc(dropout7, [2048, NUM_CLASSES], [NUM_CLASSES], name='fc8')
        return fc8
    
    
    def conv(x, kernel_size, bias_size, stride_y, stride_x, name):
        with tf.variable_scope(name) as scope:
            weights = tf.get_variable('weights',
                                      shape=kernel_size,
                                      dtype=tf.float32,
                                      initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
            biases = tf.get_variable('biases',
                                     shape=bias_size,
                                     dtype=tf.float32,
                                     initializer=tf.constant_initializer(0.1))
            conv = tf.nn.conv2d(x, weights, strides=[1, stride_y, stride_x, 1], padding='SAME')
            pre_activation = tf.nn.bias_add(conv, biases, name=scope.name)
        return pre_activation
    
    
    def fc(x, kernel_size, bias_size, name):
        """Create a fully connected layer."""
        with tf.variable_scope(name) as scope:
            weights = tf.get_variable('weights',
                                      shape=kernel_size,
                                      dtype=tf.float32,
                                      initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
            biases = tf.get_variable('biases',
                                     shape=bias_size,
                                     dtype=tf.float32,
                                     initializer=tf.constant_initializer(0.1))
            softmax_linear = tf.add(tf.matmul(x, weights), biases, name=scope.name)
        return softmax_linear
    
    
    def max_pool(x, filter_height, filter_width, stride_y, stride_x, name, padding='SAME'):
        """Create a max pooling layer."""
        return tf.nn.max_pool(x, ksize=[1, filter_height, filter_width, 1],
                              strides=[1, stride_y, stride_x, 1],
                              padding=padding, name=name)
    
    def lrn(x, radius, alpha, beta, name, bias=1.0):
        """Create a local response normalization layer."""
        return tf.nn.local_response_normalization(x, depth_radius=radius,
                                                  alpha=alpha, beta=beta,
                                                  bias=bias, name=name)
    
    def dropout(x, keep_prob):
        """Create a dropout layer."""
    
        return tf.nn.dropout(x, keep_prob)
    
    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
    
    # --------------------------------------------------------------------------
    # loss损失值优化
    # 输入参数：loss。learning_rate，学习速率。
    # 返回参数：train_op，训练op，这个参数要输入sess.run中让模型去训练。
    def trainning(loss, learning_rate):
        with tf.name_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
    
    # -----------------------------------------------------------------------
    
    # 评价/准确率计算
    
    # 输入参数：logits，网络计算值。labels，标签，也就是真实值，在这里是0或者1。
    
    # 返回参数：accuracy，当前step的平均准确率，也就是在这些batch中多少张图片被正确分类了。
    
    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

下一篇：[开始训练模型！][Link 1]

[Link 1]: https://blog.csdn.net/qq_41004007/article/details/82424306