| 一、Lenet-5的结构 点击此处返回总目录 二、lenet-5在Mnist上的应用 一、Lenet-5结构 Lenet-5是LeCun等人在1998年提出。结构如下：  或：  （C1）Lenet-5首先使用了6个5*5*1的核对输入的32*32*1的图片进行卷积计算。卷积计算后的结果通过激活函数。由于不使用0填充，步长为1，用padding公式计算得到，输出图片长为28。由于用了6个核，所以深度是6。参数个数为(5*5*1+1)*6 = 156个。 （S2）随后，使用了2*2的核对输出的28*28*6的图片进行池化，步长是2。输入长28除以步长2等于14。可见通过池化操作，减少了75%的图片信息。池化操作不改变图片的深度，所以输出是14*14*6。 （C3）使用16个5*5*6的核。核的深度要和输入的深度一致，所以核的深度是6。一个卷积核会把6张图变成一张图。参数的个数为(5*5*6+1)*16 = 2416个。不使用0填充，步长为1。输出尺寸大小为(14-5+1)/1 = 10。输出图片的深度等于使用卷积核的个数，所以输出为16个10*10的特征图。卷积计算的结果通过激活函数。
| 注意，这里简化了，其实并不都是5*5*6的核。16个Feature Map不是全部连接到6个Feature Map的输出的，有些只连接了其中几个Feature Map，这样增加了模型的多样性。其连接图为：  如果这样算，参数的个数为：(5*5*3+1) + (5*5*3+1) + (5*5*3+1) + (5*5*3+1) + (5*5*3+1) + (5*5*3+1) + (5*5*4+1) + (5*5*4+1) + (5*5*4+1) + (5*5*4+1) + (5*5*4+1) + (5*5*4+1) + (5*5*4+1) + (5*5*4+1) + (5*5*4+1) + (5*5*6+1) =(5*5*3+1)*6 + (5*5*4+1)*9 +(5*5*6+1)*1 = 76*6 + 101*9 + 151*1 = 1516个。 |
（S4）使用2*2的池化核，对16个10*10的图片进行池化，步长为2。池化不改变图片的深度。输出16个5*5的图片。 （C5）最后把16个5*5的图片拉成一维数组，再送到全连接网络。 C5层的一种解释是：使用120个5*5*16的卷积核进行卷积。每个卷积核的大小跟图片大小相同，所以使用一个卷积核生成的一个图片只包含一个像素点。120个卷积核产生120个像素点。卷积核参数有(5*5*16+1)*120=48120个。 C5层的另一种解释是：首先把16张5*5的图片拉成一维数组，再送到全连接神经网络。输入5*5*16个点，经过一层的全连接神经网络，生成了120个点。全连接神经网络的参数有(5*5*16)*120个w+120个b = 48120个参数。 （F6）1层的全连接网络。参数有120*84个w+84个b=10164个。 二、Lenet-5在Mnist数据集上的应用 由于MNIST数据集存放的是28*28*1的灰度图片，我们把Lenet-5进行更改，让他匹配28*28*1的输入图片。 先用32个5*5*1的卷积核对输入的28*28*1的图片做卷积，过激活函数。由于使用全0填充，所以输出图片的分辨率和输入图片的一致，是28*28。由于使用了32个卷积核，输出深度是使用卷积核的个数，所以输出32个28*28的图片。 有2*2的核对图片进行池化操作，得到32个14*14的图片。 由于深度是32，所以使用了5*5*32的卷积核对图片进行卷积操作。全0填充，步长为1，所以输出图片也是14*14。使用了64个卷积核，所以输出深度是64。 再用2*2的核对它进行池化，得到64个7*7的图片。 拉直之后就是卷积神经网络提取的特征，再喂给全连接神经网络。  我们来看一下代码， //mnist_lenet5_forward.py
| #coding:utf-8
import tensorflow as tf #首先给出搭建神经网络使用的常数
IMAGE_SIZE = 28 #MNIST数据集每张图片的分辨率是28
NUM_CHANNELS = 1 #是灰度图，所以通道数是1
CONV1_SIZE = 5 #第一层卷积核的大小是5
CONV1_KERNEL_NUM = 32 #第一层使用了32个卷积核
CONV2_SIZE = 5 #第二层卷积核的大小是5
CONV2_KERNEL_NUM = 64 #第二层使用了64个卷积核
FC_SIZE = 512 #第一个全连接网络有512个神经元
OUTPUT_NODE = 10 #第二个全连接神经网络有10个神经元，对应了10分类的输出 def get_weight(shape, regularizer): #权重生成函数。shape表示生成张量的维度。regularizer表示正则化权重。
w = tf.Variable(tf.truncated_normal(shape,stddev=0.1)) #生成去掉过大偏离点的正太分布随机数。
if regularizer != None: tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
return w #返回随机初试化的权重w def get_bias(shape): #偏置生成函数。shape表示生成张量的维度。
b = tf.Variable(tf.zeros(shape)) #生成初始值为0的偏置b
return b def conv2d(x,w): #卷积计算函数.要给出输入图片x,和所用卷积核w
#x是对输入的描述，是一个4阶张量。第一阶给出一次喂入多少张图片，也就是batch，第二阶给出图片行 #分辨率，第三阶给出图片列分辨率，第四阶给出输入的通道数。
#w是对卷积核的描述，也是个四阶张量。第一阶第二阶分别给出核的行列分辨率，第三阶是通道数，第四阶 #是有多少个卷积核。
return tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME') #滑动步长为1.使用0填充。 def max_pool_2x2(x): #最大池化计算函数
#x是对输入的描述，是个四阶张量。第一阶给出一次喂入多少张图片，也就是batch。 #第二三阶给出行列分辨率。第四阶给出输入通道数。
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME') #池化核大小是2*2的。行列步长都是2. def forward(x, train, regularizer): #forward()函数给出了前向传播的网络结构， #初始化第一层卷积核。[5*5*1*32]
conv1_w = get_weight([CONV1_SIZE, CONV1_SIZE, NUM_CHANNELS, CONV1_KERNEL_NUM], regularizer)
conv1_b = get_bias([CONV1_KERNEL_NUM]) #初始化第一层偏置。[32]
conv1 = conv2d(x, conv1_w) #卷积计算，输入是x,卷积核conv1_w
relu1 = tf.nn.relu(tf.nn.bias_add(conv1, conv1_b)) #对卷积后的输出conv1添加偏置，通过relu()函数.
pool1 = max_pool_2x2(relu1) #将激活后的输出，进行最大池化。 #第二层卷积核的深度等于上层卷积核的个数。 conv2_w = get_weight([CONV2_SIZE, CONV2_SIZE, CONV1_KERNEL_NUM, CONV2_KERNEL_NUM],regularizer)
conv2_b = get_bias([CONV2_KERNEL_NUM])
conv2 = conv2d(pool1, conv2_w) #卷积的输入是上层的输出pool1.
relu2 = tf.nn.relu(tf.nn.bias_add(conv2, conv2_b)) #过激活函数。
pool2 = max_pool_2x2(relu2) #过最大池化。pool2是第二层卷积的输出。需要把它从三维张量变为二维张量。 pool_shape = pool2.get_shape().as_list() #pool2的维度存入list中。
nodes = pool_shape[1] * pool_shape[2] * pool_shape[3] #提取特征的长度宽度深度，他们相乘就是所有特征点的个数。 #pool_shape[0]是一个batch的值。把pool2变为batch行，nodes列的二维形状。再把reshape喂到全连接网络里。
reshaped = tf.reshape(pool2, [pool_shape[0], nodes]) fc1_w = get_weight([nodes, FC_SIZE], regularizer)
fc1_b = get_bias([FC_SIZE])
fc1 = tf.nn.relu(tf.matmul(reshaped, fc1_w) + fc1_b) #把上层的输出reshaped乘以本层线上的权重fc1_w,加上权重，过relu函数。
if train: fc1 = tf.nn.dropout(fc1, 0.5) #如果是训练阶段，则对该层的输出使用50%的dropout. fc2_w = get_weight([FC_SIZE, OUTPUT_NODE], regularizer) #第二层全连接神经网络。初始化w
fc2_b = get_bias([OUTPUT_NODE]) #初始化b
y = tf.matmul(fc1, fc2_w) + fc2_b #得到输出y
return y |
//mnist_lenet5_backward.py
| #coding:utf-8
#基本与fc2相同，只增加了对输入数据的形状调整。
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_lenet5_forward
import os
import numpy as np BATCH_SIZE = 100
LEARNING_RATE_BASE = 0.005
LEARNING_RATE_DECAY = 0.99
REGULARIZER = 0.0001
STEPS = 50000
MOVING_AVERAGE_DECAY = 0.99
MODEL_SAVE_PATH="./model/"
MODEL_NAME="mnist_model" def backward(mnist):
x = tf.placeholder(tf.float32,[ #由于卷积的输入要求是4阶张量，所以x的placeholder占位用这种方法给出。指定x是32位浮点型。
BATCH_SIZE, #第一阶给出每轮喂入多少张特征图片，也就是batch_size
mnist_lenet5_forward.IMAGE_SIZE, #第二阶是行分辨率。
mnist_lenet5_forward.IMAGE_SIZE, #第三阶是列分辨率。
mnist_lenet5_forward.NUM_CHANNELS]) #第4阶是输入的通道数。
y_ = tf.placeholder(tf.float32, [None, mnist_lenet5_forward.OUTPUT_NODE])
y = mnist_lenet5_forward.forward(x,True, REGULARIZER) #由于反向传播计算y时，在训练网络参数，所以写True，表示训练参数时，使用dropout
global_step = tf.Variable(0, trainable=False) ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
cem = tf.reduce_mean(ce)
loss = cem + tf.add_n(tf.get_collection('losses')) learning_rate = tf.train.exponential_decay(
LEARNING_RATE_BASE,
global_step,
mnist.train.num_examples / BATCH_SIZE,
LEARNING_RATE_DECAY,
staircase=True)
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step) ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
ema_op = ema.apply(tf.trainable_variables())
with tf.control_dependencies([train_step, ema_op]):
train_op = tf.no_op(name='train') saver = tf.train.Saver() with tf.Session() as sess:
init_op = tf.global_variables_initializer()
sess.run(init_op) ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path) for i in range(STEPS):
xs, ys = mnist.train.next_batch(BATCH_SIZE)
reshaped_xs = np.reshape(xs,( #用np.reshape()实现了从数据集中取出的xs,进行reshape()操作。
BATCH_SIZE,
mnist_lenet5_forward.IMAGE_SIZE,
mnist_lenet5_forward.IMAGE_SIZE,
mnist_lenet5_forward.NUM_CHANNELS))
_, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={x: reshaped_xs, y_: ys}) #用sess.run把喂入神经网络的x做了同样的修改。
if i % 100 == 0:
print("After %d training step(s), loss on training batch is %g." % (step, loss_value))
saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=global_step) def main():
mnist = input_data.read_data_sets("./data/", one_hot=True)
backward(mnist) if __name__ == '__main__':
main() |
//mnist_lenet5_test.py
| #coding:utf-8
#在测试程序中，会输出识别准确率，也仅对x的形状做了调整。
import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_lenet5_forward
import mnist_lenet5_backward
import numpy as np TEST_INTERVAL_SECS = 5 def test(mnist):
with tf.Graph().as_default() as g:
x = tf.placeholder(tf.float32,[
mnist.test.num_examples,
mnist_lenet5_forward.IMAGE_SIZE,
mnist_lenet5_forward.IMAGE_SIZE,
mnist_lenet5_forward.NUM_CHANNELS])
y_ = tf.placeholder(tf.float32, [None, mnist_lenet5_forward.OUTPUT_NODE])
y = mnist_lenet5_forward.forward(x,False,None) #由于测试是使用训练好的网络，所以不使用dropout,所有神经元都要参加运算。 ema = tf.train.ExponentialMovingAverage(mnist_lenet5_backward.MOVING_AVERAGE_DECAY)
ema_restore = ema.variables_to_restore()
saver = tf.train.Saver(ema_restore)
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) while True:
with tf.Session() as sess:
ckpt = tf.train.get_checkpoint_state(mnist_lenet5_backward.MODEL_SAVE_PATH)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
reshaped_x = np.reshape(mnist.test.images,(
mnist.test.num_examples,
mnist_lenet5_forward.IMAGE_SIZE,
mnist_lenet5_forward.IMAGE_SIZE,
mnist_lenet5_forward.NUM_CHANNELS))
accuracy_score = sess.run(accuracy, feed_dict={x:reshaped_x,y_:mnist.test.labels})
print("After %s training step(s), test accuracy = %g" % (global_step, accuracy_score))
else:
print('No checkpoint file found')
return
time.sleep(TEST_INTERVAL_SECS) def main():
mnist = input_data.read_data_sets("./data/", one_hot=True)
test(mnist) if __name__ == '__main__':
main() |
运行结果： 
最后准确率跑出来为98.81% 运行的比较漫长，看来应该用GPU来跑了~~ |
