TensorFlow（十）LeNet网络代码实现

最新推荐文章于 2021-02-04 22:02:47 发布

viafcccy

最新推荐文章于 2021-02-04 22:02:47 发布

阅读量385

点赞数 2

分类专栏： TensorFlow与深度学习智能算法

本文链接：https://blog.csdn.net/viafcccy/article/details/100564983

版权

智能算法同时被 2 个专栏收录

26 篇文章 23 订阅

订阅专栏

TensorFlow与深度学习

20 篇文章 8 订阅

订阅专栏

MNIST 数据集可在 http://yann.lecun.com/exdb/mnist/ 获取, 它包含了四个部分:

Training set images: train-images-idx3-ubyte.gz (9.9 MB, 解压后 47 MB, 包含 60,000 个样本)
Training set labels: train-labels-idx1-ubyte.gz (29 KB, 解压后 60 KB, 包含 60,000 个标签)
Test set images: t10k-images-idx3-ubyte.gz (1.6 MB, 解压后 7.8 MB, 包含 10,000 个样本)
Test set labels: t10k-labels-idx1-ubyte.gz (5KB, 解压后 10 KB, 包含 10,000 个标签)

MNIST 数据集来自美国国家标准与技术研究所, National Institute of Standards and Technology (NIST). 训练集 (training set) 由来自 250 个不同人手写的数字构成, 其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员. 测试集(test set) 也是同样比例的手写数字数据.

数据特点：

1.mnist.train.images是训练样本存放格式为一个55000 * 784 的矩阵 784是28*28 每张数据是28*28的单通道黑白图像

2.mnist.train.labels表示训练图像的标签 55000*10 代表0-9

例如： 0 对应（1,0,0,0,0,0,0,0,0,0,0）

3.而validation只是图像数不同但是是非常类似的是测试集

上图为获取的mnist数据集

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data #导入mnist手写数据集
import time #import time 引入py时间模块
from matplotlib import pyplot as plt # 引入绘图模块

#INPUT层-输入层
"""
 MNIST 数据集中的每张图片由 28 x 28 个像素点构成 , 但是这里的28 x 28 的像素展开为
一个一维的行向量, 这些行向量就是图片数组里的行(每行 784 个值, 或者说每行就是代表了一张图片)
"""

x = tf.placeholder('float' , [None , 784])#None代表这一维的大小是任意的
y_ = tf.placeholder('float' , [None , 10])

#将一维图像展开为二维图像矩阵
x_image = tf.reshape(x , [-1 , 28 , 28 , 1]) #28*28的单通道图像 
#-1代表数组新的shape属性应该要与原来的配套，如果等于-1的话，那么Numpy会根据剩下的维度计算出数组的另外一个shape属性值。
#也就是说很自动分成多少张28*28*1的图片 会根据原有的数据自动判断

#C1层-卷积层
"""
输入图片：28*28

卷积核大小：5*5

卷积核种类：6

输出featuremap大小：28*28 （32-5+1）=28

神经元数量：28*28*6

可训练参数：（5*5+1) * 6（每个滤波器5*5=25个unit参数和一个bias参数，一共6个滤波器）

连接数：（5*5+1）*6*28*28=122304

"""
filter1 = tf.Variable(tf.truncated_normal([ 5 , 5 , 1 , 6]))
bias1 = tf.Variable(tf.truncated_normal([6]))
conv1 = tf.nn.conv2d(x_image , filter1 , strides = [1 , 1 , 1 ,1] , padding = 'SAME')
h_conv1 = tf.nn.sigmoid(conv1 + bias1)

#S2层-池化层（下采样层）
"""
这里采用maxpooling对2*2的范围取最大值
输入：28*28

采样区域：2*2

采样方式：4个输入相加，乘以一个可训练参数，再加上一个可训练偏置。结果通过sigmoid

采样种类：6

输出featureMap大小：14*14（28/2）

神经元数量：14*14*6

连接数：（2*2+1）*6*14*14

S2中每个特征图的大小是C1中特征图大小的1/4

"""
maxPool2 = tf.nn.max_pool(h_conv1 , ksize = [1 , 2 , 2 , 1] , strides = [1 , 2 , 2 , 1] , padding = 'SAME')

#C3层-卷积层
"""
输入：S2中所有6个或者几个特征map组合

卷积核大小：5*5

卷积核种类：16

输出featureMap大小：10*10 (14-5+1)=10

C3中的每个特征map是连接到S2中的所有6个或者几个特征map的，表示本层的特征map是上一层提取到的特征map的不同组合

存在的一个方式是：C3的前6个特征图以S2中3个相邻的特征图子集为输入。接下来6个特征图以S2中4个相邻特征图子集为输入。然后的3个以不相邻的4个特征图子集为输入。最后一个将S2中所有特征图为输入。

则：可训练参数：6*(3*5*5+1)+6*(4*5*5+1)+3*(4*5*5+1)+1*(6*5*5+1)=1516

连接数：10*10*1516=151600

"""
filter2 = tf.Variable(tf.truncated_normal([ 5 , 5 , 6 , 16]))
bias2 = tf.Variable(tf.truncated_normal([16]))
conv2 = tf.nn.conv2d(maxPool2 , filter2 , strides = [1 , 1 , 1 ,1] , padding = 'SAME')
h_conv2 = tf.nn.sigmoid(conv2 + bias2)

#S4层-池化层（下采样层）
"""
输入：10*10

采样区域：2*2

采样方式：4个输入相加，乘以一个可训练参数，再加上一个可训练偏置。结果通过sigmoid

采样种类：16

输出featureMap大小：5*5（10/2）

神经元数量：5*5*16=400

连接数：16*（2*2+1）*5*5=2000

S4中每个特征图的大小是C3中特征图大小的1/4

"""
maxPool3 = tf.nn.max_pool(h_conv2 , ksize = [1 , 2 , 2 , 1] , strides = [1 , 2 , 2 , 1] , padding = 'SAME')

#C5层-卷积层
"""
输入：S4层的全部16个单元特征map（与s4全相连）

卷积核大小：5*5

卷积核种类：120

输出featureMap大小：1*1（5-5+1）

可训练参数/连接：120*（16*5*5+1）=48120

"""
filter3 = tf.Variable(tf.truncated_normal([ 5 , 5 , 16 , 120]))
bias3 = tf.Variable(tf.truncated_normal([120]))
conv3 = tf.nn.conv2d(maxPool3 , filter3 , strides = [1 , 1 , 1 ,1] , padding = 'SAME')
h_conv3 = tf.nn.sigmoid(conv3 + bias3)

#F6层-全连接层
"""
输入：c5 120维向量

计算方式：计算输入向量和权重向量之间的点积，再加上一个偏置，结果通过sigmoid函数输出。

可训练参数:84*(120+1)=10164

"""
w_fc1 = tf.Variable(tf.truncated_normal([ 7 * 7 * 120 , 80])) #权值参数
b_fc1 = tf.Variable(tf.truncated_normal([80])) #偏置值
h_pool2_flat = tf.reshape(h_conv3 , [-1 , 7 * 7 * 120]) #将卷积得到的输出展开
h_fc1 = tf.nn.sigmoid(tf.matmul(h_pool2_flat , w_fc1 ) + b_fc1 ) #计算神经网络 sigmoid激活函数运算

#Output层-全连接层
"""
Output层也是全连接层，共有10个节点，分别代表数字0到9，且如果节点i的值为0，则网络识
别的结果是数字i。采用的是径向基函数（RBF）的网络连接方式。假设x是上一层的输入，y是
RBF的输出，则RBF输出的计算方式是：softmax
"""
w_fc2 = tf.Variable(tf.truncated_normal([ 80 , 10]))
b_fc2 = tf.Variable(tf.truncated_normal([10]))
y_conv = tf.nn.softmax(tf.matmul( h_fc1 , w_fc2 ) + b_fc2 )

##损失函数（此处函数也可以直接使用tf.softmax_cross_entropy_with_logits）
cross_entropy = - tf.reduce_sum(y_ * tf.log(y_conv))

#使用GDO优化算法来调整参数
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(cross_entropy)
sess = tf.InteractiveSession()

#测试正确率
correct_prediction = tf.equal(tf.argmax(y_conv , 1) , tf.argmax(y_ , 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction , "float"))
"""
关于正确率的测试
模型预测y的形状是（N ， 10） 实际标签也是（N ， 10） 
tf.argmax负责取出整个数组中的最大下标
而在制作数据集的标签时就如
0 对应【1 ， 0 ， 0 ，...】
1 对应【0 ， 1 ， 0 ，...】
于是就可以用tf.equal直接对比来完成 tf.reduce_mean计算出平均值 就是概率了
"""

#变量初始化，分配内存
sess.run(tf.global_variables_initializer())

#自动检测是否存在mnist数据集 若没有自动创建文件夹MNIST_data并存放进去
mnist_data_set = input_data.read_data_sets('MNIST_data' , one_hot = True)

#进行训练 这里是每次提取200个数据训练2000次
start_time = time.time()
x_axis = []
y_axis = []
all_time = 0
for i in range(2000):
    #获取数据集 从数据集中获取200个数据
    batch_xs , batch_ys = mnist_data_set.train.next_batch(200)
    
    #迭代100个batch进行一次测试 获取正确率
    if i % 2 == 0:
        train_accuracy = accuracy.eval(feed_dict= {x : batch_xs , y_: batch_ys})
        print("当前是第%d代 ， 训练正确率为 %g " % (i , train_accuracy))
        
        #计算间隔时间
        end_time  = time.time()
        print('消耗时间：' , (end_time - start_time))
        all_time = all_time + end_time - start_time
        start_time = end_time
        
        x_axis.append(i)
        y_axis.append(train_accuracy)
        
    #训练数据 将batch_xs填入x 将batch_ys填入y_
    train_step.run(feed_dict = {x:batch_xs , y_ : batch_ys})
    
#关闭会话
sess.close()

plt.figure()    # 定义一个图像窗口
plt.plot(x_axis , y_axis) # 绘制曲线 y1
plt.show()    

print('累计消耗总时间为：' , all_time)