TensorFlow详解猫狗识别(二)--定义神经网络

这里附上亲测的两个神经网络模型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

下一篇:开始训练模型!

你可能感兴趣的:(tensorflow,LeNet,AlexNet,神经网络,TensorFlow)