50、经典CNN网络LeNet实战：手写数字识别(分类)_笔记

东方耀

50、经典CNN网络LeNet实战：手写数字识别(分类)_笔记

第一步：导入数据# 手写数字识别的数据集主要包含三个部分：训练集(5.5w, mnist.train)、测试集(1w, mnist.test)、验证集(0.5w, mnist.validation)
# 手写数字图片大小是28*28*1像素的图片(黑白)，也就是每个图片由784维的特征描述

第二步：设置超参并定义学习率调整策略

1. def learn_rate_func(epoch):
   
2.     """
   
3.     根据给定的迭代批次，更新产生一个学习率的值 均匀分布策略
   
4.     :param epoch:
   
5.     :return:
   
6.     """
   
7.     return max(0.001, learn_rate_base * (0.9 ** int(epoch / 10)))
   
8. 
   
9. # learn_rate = tf.train.exponential_decay() tf自带的学习率的

复制代码

第三步：开始构建模型 设置输入数据的占位符
第四步：构建LeNet网络（直接将网络结构翻译成为这个代码）

1. # 卷积
   
2.         # conv2d(input, filter, strides, padding, use_cudnn_on_gpu=True, data_format="NHWC", name=None) => 卷积的API
   
3.         # data_format: 表示的是输入的数据格式，两种：NHWC和NCHW，N=>样本数目，H=>Height, W=>Weight, C=>Channels
   
4.         # use_cudnn_on_gpu：设置GPU加速
   
5.         # name：设置操作的名字 与tf一样
   
6.         # input：输入数据，必须是一个4维格式的图像数据，具体格式和data_format有关，如果data_format是NHWC的时候，input的格式为: [batch_size, height, width, channels] => [批次中的图片数目，图片的高度，图片的宽度，图片的通道数]；如果data_format是NCHW的时候，input的格式为: [batch_size, channels, height, width] => [批次中的图片数目，图片的通道数，图片的高度，图片的宽度]
   
7.         # filter: 卷积核或过滤器，是一个4维格式的数据，shape: [height, width, in_channels, out_channels] => [窗口的高度，窗口的宽度，输入的channel通道数(上一层图片的深度)，输出的通道数(卷积核数目或深度，到底是几组w和b)]
   
8.         # strides：步长，是一个4维的数据，每一维数据必须和data_format格式匹配，表示的是在data_format每一维上的移动步长，当格式为NHWC的时候，strides的格式为: [batch, in_height, in_width, in_channels] => [样本上的移动大小，高度的移动大小，宽度的移动大小，深度的移动大小],API要求在样本上和在深度通道上的移动必须是1；当格式为NCHW的时候，strides的格式为: [batch,in_channels, in_height, in_width]
   
9.         # padding: 只支持两个参数"SAME", "VALID"，当取值为SAME的时候，表示进行填充，"有个特例(特别强调)：在TensorFlow中，如果步长为1，并且padding为SAME的时候，经过卷积之后的图像大小是不变的"；当VALID的时候，表示多余的特征会丢弃；
   
10.         w = get_variable('w', [5, 5, 1, 20])

复制代码

第五步：构建模型的损失函数
第六步：构建梯度下降的优化方法（一般用Adam 动量GD）
第七步：计算模型正确率
第八步：会话中执行阶段（模型的训练与迭代）

1. # -*- coding: utf-8 -*-
   
2. __author__ = 'dongfangyao'
   
3. __date__ = '2019/1/9 下午9:05'
   
4. __product__ = 'PyCharm'
   
5. __filename__ = 'tf27'
   
6. 
   
7. 
   
8. # 手写数字的图片数据 LeNet
   
9. 
   
10. import tensorflow as tf
    
11. from tensorflow.examples.tutorials.mnist import input_data
    
12. 
    
13. # 手写数字的图片 数据
    
14. mnist = input_data.read_data_sets('data/lenet', one_hot=True)
    
15. # 55000
    
16. print(mnist.train.num_examples)
    
17. # (55000, 784)
    
18. print(mnist.train.images.shape)
    
19. # (55000, 10)
    
20. print(mnist.train.labels.shape)
    
21. # 7
    
22. print(mnist.train.labels[0])
    
23. 
    
24. print('测试集shape:{}'.format(mnist.test.images.shape))
    
25. print('验证集shape:{}'.format(mnist.validation.images.shape))
    
26. 
    
27. # 784 = 28*28*1 黑白
    
28. train_img = mnist.train.images
    
29. train_label = mnist.train.labels
    
30. 
    
31. test_img = mnist.test.images
    
32. test_label = mnist.test.labels
    
33. 
    
34. train_sample_number = mnist.train.num_examples
    
35. 
    
36. # 设置超参
    
37. learn_rate_base = 0.1
    
38. batch_size = 64
    
39. display_step = 1
    
40. 
    
41. input_dim = train_img.shape[1]
    
42. n_classes = train_label.shape[1]
    
43. 
    
44. # 1、设置占位符
    
45. x = tf.placeholder(tf.float32, shape=[None, input_dim], name='x')
    
46. y = tf.placeholder(tf.float32, shape=[None, n_classes], name='y')
    
47. learn_rate = tf.placeholder(tf.float32, name='learn_rate')
    
48. 
    
49. 
    
50. def learn_rate_func(epoch):
    
51.     return max(0.001, learn_rate_base * (0.9 ** int(epoch / 10)))
    
52. 
    
53. 
    
54. def get_variable(name, shape=None, dtype=tf.float32, initializer=tf.random_normal_initializer(mean=0, stddev=0.1)):
    
55.     return tf.get_variable(name, shape, dtype, initializer)
    
56. 
    
57. 
    
58. # 2、构建网络 预测值
    
59. def le_net(x, y):
    
60.     # 1、输入层
    
61.     with tf.variable_scope('input1'):
    
62.         # [None, input_dim] --> [None, height, width, channels]
    
63.         net = tf.reshape(x, shape=[-1, 28, 28, 1])
    
64.     # 2、conv+relu
    
65.     with tf.variable_scope('conv2'):
    
66.         w = get_variable(name='w', shape=[5, 5, 1, 20])
    
67.         # data_format NHWC NCHW
    
68.         # conv2d(input, filter, strides, padding, use_cudnn_on_gpu=True, data_format="NHWC", name=None):
    
69.         net = tf.nn.conv2d(input=net, filter=w, strides=[1, 1, 1, 1], padding='SAME', data_format='NHWC')
    
70.         net = tf.nn.bias_add(net, get_variable('b', shape=[20]))
    
71.         print('conv2之后的shape:{}'.format(net.shape))
    
72.         net = tf.nn.relu(net)
    
73.     # 3、pool
    
74.     with tf.variable_scope('pool3'):
    
75.         net = tf.nn.max_pool(value=net, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME', data_format='NHWC')
    
76.         print('pool3之后的shape:{}'.format(net.shape))
    
77.     # 4、conv
    
78.     with tf.variable_scope('conv4'):
    
79.         net = tf.nn.conv2d(input=net, filter=get_variable(name='w', shape=[5, 5, 20, 50]), strides=[1, 1, 1, 1], padding='SAME', data_format='NHWC')
    
80.         net = tf.nn.bias_add(net, get_variable('b', shape=[50]))
    
81.         print('conv4之后的shape:{}'.format(net.shape))
    
82.         net = tf.nn.relu(net)
    
83.     # 5、pool
    
84.     with tf.variable_scope('pool5'):
    
85.         net = tf.nn.max_pool(value=net, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME', data_format='NHWC')
    
86.         print('pool5之后的shape:{}'.format(net.shape))
    
87.     # 6、fc
    
88.     with tf.variable_scope('fc6'):
    
89.         # 28 -> 14 --> 7
    
90.         size = 7*7*50
    
91.         net = tf.reshape(net, shape=[-1, size])
    
92.         net = tf.add(tf.matmul(net, get_variable('w', shape=[size, 500])), get_variable('b', shape=[500]))
    
93.         print('fc6之后的shape:{}'.format(net.shape))
    
94.         net = tf.nn.relu(net)
    
95.     # 7 fc
    
96.     with tf.variable_scope('fc7'):
    
97.         net = tf.add(tf.matmul(net, get_variable('w', shape=[500, n_classes])), get_variable('b', shape=[n_classes]))
    
98.         print('fc7之后的shape:{}'.format(net.shape))
    
99. 
    
100.     return net
     
101. 
     
102. 
     
103. act = le_net(x, y)
     
104. 
     
105. # 模型的损失函数
     
106. cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=act, labels=y))
     
107. 
     
108. # train = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(cost)
     
109. train = tf.train.AdadeltaOptimizer(learning_rate=learn_rate).minimize(cost)
     
110. 
     
111. pred = tf.equal(tf.argmax(act, axis=1), tf.argmax(y, axis=1))
     
112. acc = tf.reduce_mean(tf.cast(pred, dtype=tf.float32))
     
113. 
     
114. init_op = tf.global_variables_initializer()
     
115. 
     
116. with tf.Session() as sess:
     
117.     sess.run(init_op)
     
118. 
     
119.     saver = tf.train.Saver()
     
120.     epoch = 0
     
121.     while True:
     
122.         avg_cost = 0
     
123.         total_batch = int(train_sample_number / batch_size)
     
124.         for i in range(total_batch):
     
125.             batch_xs, batch_ys = mnist.train.next_batch(batch_size)
     
126.             feeds = {x: batch_xs, y: batch_ys, learn_rate: learn_rate_func(epoch)}
     
127.             sess.run(train, feed_dict=feeds)
     
128.             avg_cost += sess.run(cost, feed_dict=feeds)
     
129. 
     
130.         avg_cost = avg_cost / total_batch
     
131. 
     
132.         if (epoch + 1) % display_step == 0:
     
133.             print('批次: %03d 损失函数值：%.9f' % (epoch, avg_cost))
     
134.             train_acc = sess.run(acc, feed_dict={x: mnist.train.images[:1000], y: mnist.train.labels[:1000], learn_rate: learn_rate_func(epoch)})
     
135.             print('训练集的准确率:%0.3f' % train_acc)
     
136.             test_acc = sess.run(acc, feed_dict={x: mnist.test.images[:1000], y: mnist.test.labels[:1000], learn_rate: learn_rate_func(epoch)})
     
137.             print('测试集的准确率:%0.3f' % test_acc)
     
138. 
     
139.             if train_acc > 0.99 and test_acc > 0.98:
     
140.                 saver.save(sess, './data/lenet/model_{}_{}'.format(train_acc, test_acc), global_step=epoch)
     
141.                 break
     
142.         epoch += 1
     
143.     writer = tf.summary.FileWriter('./data/lenet/graph', tf.get_default_graph())
     
144.     writer.close()
     
145. 
     
146. print('end....')
     

复制代码

1. # -*- coding: utf-8 -*-
   
2. __author__ = 'dongfangyao'
   
3. __date__ = '2019/1/9 下午9:05'
   
4. __product__ = 'PyCharm'
   
5. __filename__ = 'tf27_注释完整版'
   
6. """
   
7. 手写数字识别的CNN网络 LeNet
   
8. 注意：一般情况下，我们都是直接将网络结构翻译成为这个代码，最多稍微的修改一下网络中的参数（超参数、窗口大小、步长等信息）
   
9. https://js.tensorflow.org/
   
10. https://js.tensorflow.org/#getting-started
    
11. 
    
12. """
    
13. 
    
14. import tensorflow as tf
    
15. from tensorflow.examples.tutorials.mnist import input_data
    
16. 
    
17. # 设置一个随机数种子
    
18. tf.set_random_seed(28)
    
19. 
    
20. # 数据加载
    
21. mnist = input_data.read_data_sets('data/lenet', one_hot=True)
    
22. # 样本数 55000
    
23. print(mnist.train.num_examples)
    
24. # images 特征矩阵 784个特征属性
    
25. print(mnist.train.images.shape)
    
26. # labels 目标属性10个 刚好是10个数字 进行了哑编码
    
27. print(mnist.train.labels.shape)
    
28. 
    
29. print('测试集shape：{}'.format(mnist.test.images.shape))
    
30. print('验证集shape：{}'.format(mnist.validation.images.shape))
    
31. 
    
32. # 手写数字识别的数据集主要包含三个部分：训练集(5.5w, mnist.train)、测试集(1w, mnist.test)、验证集(0.5w, mnist.validation)
    
33. # 手写数字图片大小是28*28*1像素的图片(黑白)，也就是每个图片由784维的特征描述
    
34. train_img = mnist.train.images
    
35. train_label = mnist.train.labels
    
36. test_img = mnist.test.images
    
37. test_label = mnist.test.labels
    
38. 
    
39. train_sample_number = mnist.train.num_examples
    
40. 
    
41. # 相关的参数、超参数的设置
    
42. # 学习率，一般学习率设置的比较小
    
43. learn_rate_base = 0.1
    
44. # 每次迭代的训练样本数量
    
45. batch_size = 64
    
46. # 展示信息的间隔大小
    
47. display_step = 1
    
48. 
    
49. # 输入的样本维度大小信息
    
50. input_dim = train_img.shape[1]
    
51. # 输出的维度大小信息
    
52. n_classes = train_label.shape[1]
    
53. 
    
54. # 模型构建
    
55. # 1. 设置数据输入的占位符
    
56. x = tf.placeholder(tf.float32, shape=[None, input_dim], name='x')
    
57. y = tf.placeholder(tf.float32, shape=[None, n_classes], name='y')
    
58. learn_rate = tf.placeholder(tf.float32, name='learn_rate')
    
59. 
    
60. 
    
61. def learn_rate_func(epoch):
    
62.     """
    
63.     根据给定的迭代批次，更新产生一个学习率的值 均匀分布策略
    
64.     :param epoch:
    
65.     :return:
    
66.     """
    
67.     return max(0.001, learn_rate_base * (0.9 ** int(epoch / 10)))
    
68. 
    
69. # learn_rate = tf.train.exponential_decay() tf自带的学习率的
    
70. 
    
71. 
    
72. def get_variable(name, shape=None, dtype=tf.float32, initializer=tf.random_normal_initializer(mean=0, stddev=0.1)):
    
73.     """
    
74.     返回一个对应的变量
    
75.     :param name:
    
76.     :param shape:
    
77.     :param dtype:
    
78.     :param initializer:
    
79.     :return:
    
80.     """
    
81.     return tf.get_variable(name, shape, dtype, initializer)
    
82. 
    
83. 
    
84. # 2. 构建网络
    
85. def le_net(x, y):
    
86.     # 1. 输入层
    
87.     with tf.variable_scope('input1'):
    
88.         # 将输入的x的格式转换为规定的格式
    
89.         # [None, input_dim] -> [None, height, width, channels]
    
90.         net = tf.reshape(x, shape=[-1, 28, 28, 1])
    
91.     # 2. 卷积层
    
92.     with tf.variable_scope('conv2'):
    
93.         # 卷积
    
94.         # conv2d(input, filter, strides, padding, use_cudnn_on_gpu=True, data_format="NHWC", name=None) => 卷积的API
    
95.         # data_format: 表示的是输入的数据格式，两种：NHWC和NCHW，N=>样本数目，H=>Height, W=>Weight, C=>Channels
    
96.         # use_cudnn_on_gpu：设置GPU加速
    
97.         # name：设置操作的名字 与tf一样
    
98.         # input：输入数据，必须是一个4维格式的图像数据，具体格式和data_format有关，如果data_format是NHWC的时候，input的格式为: [batch_size, height, width, channels] => [批次中的图片数目，图片的高度，图片的宽度，图片的通道数]；如果data_format是NCHW的时候，input的格式为: [batch_size, channels, height, width] => [批次中的图片数目，图片的通道数，图片的高度，图片的宽度]
    
99.         # filter: 卷积核或过滤器，是一个4维格式的数据，shape: [height, width, in_channels, out_channels] => [窗口的高度，窗口的宽度，输入的channel通道数(上一层图片的深度)，输出的通道数(卷积核数目或深度，到底是几组w和b)]
    
100.         # strides：步长，是一个4维的数据，每一维数据必须和data_format格式匹配，表示的是在data_format每一维上的移动步长，当格式为NHWC的时候，strides的格式为: [batch, in_height, in_width, in_channels] => [样本上的移动大小，高度的移动大小，宽度的移动大小，深度的移动大小],API要求在样本上和在深度通道上的移动必须是1；当格式为NCHW的时候，strides的格式为: [batch,in_channels, in_height, in_width]
     
101.         # padding: 只支持两个参数"SAME", "VALID"，当取值为SAME的时候，表示进行填充，"有个特例(特别强调)：在TensorFlow中，如果步长为1，并且padding为SAME的时候，经过卷积之后的图像大小是不变的"；当VALID的时候，表示多余的特征会丢弃；
     
102.         w = get_variable('w', [5, 5, 1, 20])
     
103.         net = tf.nn.conv2d(input=net, filter=w, strides=[1, 1, 1, 1], padding='SAME')
     
104.         net = tf.nn.bias_add(net, get_variable('b', [20]))
     
105.         print('conv2之后的shape:{}'.format(net.shape))
     
106.         # 激励 ReLu
     
107.         # tf.nn.relu => max(fetures, 0)
     
108.         # tf.nn.relu6 => min(max(fetures,0), 6)
     
109.         net = tf.nn.relu(net)
     
110.     # 3. 池化
     
111.     with tf.variable_scope('pool3'):
     
112.         # 和conv2一样，需要给定窗口大小和步长
     
113.         # max_pool(value, ksize, strides, padding, data_format="NHWC", name=None)
     
114.         # avg_pool(value, ksize, strides, padding, data_format="NHWC", name=None)
     
115.         # 默认格式下：NHWC，value：输入的数据，必须是[batch_size, height, width, channels]格式
     
116.         # 默认格式下：NHWC，ksize：指定窗口大小，必须是[batch, in_height, in_width, in_channels]， 其中batch和in_channels必须为1
     
117.         # 默认格式下：NHWC，strides：指定步长大小，必须是[batch, in_height, in_weight, in_channels],其中batch和in_channels必须为1
     
118.         # padding： 只支持两个参数"SAME", "VALID"，当取值为SAME的时候，表示进行填充，；当VALID的时候，表示多余的特征会丢弃；
     
119.         net = tf.nn.max_pool(value=net, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
     
120.         print('pool3之后的shape:{}'.format(net.shape))
     
121.     # 4. 卷积
     
122.     with tf.variable_scope('conv4'):
     
123.         net = tf.nn.conv2d(input=net, filter=get_variable('w', [5, 5, 20, 50]), strides=[1, 1, 1, 1], padding='SAME')
     
124.         net = tf.nn.bias_add(net, get_variable('b', [50]))
     
125.         print('conv4之后的shape:{}'.format(net.shape))
     
126.         net = tf.nn.relu(net)
     
127.     # 5. 池化
     
128.     with tf.variable_scope('pool5'):
     
129.         net = tf.nn.max_pool(value=net, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
     
130.         print('pool5之后的shape:{}'.format(net.shape))
     
131.     # 6. 全连接
     
132.     with tf.variable_scope('fc6'):
     
133.         # 28 -> 14 -> 7(因为此时的卷积不改变图片的大小，只有池化会改变)
     
134.         size = 7 * 7 * 50
     
135.         net = tf.reshape(net, shape=[-1, size])
     
136.         net = tf.add(tf.matmul(net, get_variable('w', [size, 500])), get_variable('b', [500]))
     
137.         print('fc6之后的shape:{}'.format(net.shape))
     
138.         net = tf.nn.relu(net)
     
139.     # 7. 全连接
     
140.     with tf.variable_scope('fc7'):
     
141.         net = tf.add(tf.matmul(net, get_variable('w', [500, n_classes])), get_variable('b', [n_classes]))
     
142.         print('fc7之后的shape:{}'.format(net.shape))
     
143. 
     
144.     return net
     
145. 
     
146. 
     
147. # 构建网络
     
148. act = le_net(x, y)
     
149. 
     
150. # 构建模型的损失函数
     
151. # softmax_cross_entropy_with_logits: 计算softmax中的每个样本的交叉熵，logits指定预测值，labels指定实际值
     
152. cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=act, labels=y))
     
153. 
     
154. # 使用Adam优化方式比较多 动量GD
     
155. # learning_rate: 要注意，不要过大，过大可能不收敛，也不要过小，过小收敛速度比较慢
     
156. train = tf.train.AdadeltaOptimizer(learning_rate=learn_rate).minimize(cost)
     
157. # train = tf.train.AdamOptimizer(learning_rate=learn_rate).minimize(cost)
     
158. 
     
159. 
     
160. # 得到预测的类别是那一个
     
161. # tf.argmax:对矩阵按行或列计算最大值对应的下标，和numpy中的一样
     
162. # tf.equal:是对比这两个矩阵或者向量的相等的元素，如果是相等的那就返回True，反正返回False，返回的值的矩阵维度和A是一样的
     
163. pred = tf.equal(tf.argmax(act, axis=1), tf.argmax(y, axis=1))
     
164. # 正确率（True转换为1，False转换为0）
     
165. acc = tf.reduce_mean(tf.cast(pred, tf.float32))
     
166. 
     
167. # 初始化
     
168. init = tf.global_variables_initializer()
     
169. 
     
170. with tf.Session() as sess:
     
171.     # 进行数据初始化
     
172.     sess.run(init)
     
173. 
     
174.     # 模型保存、持久化
     
175.     saver = tf.train.Saver()
     
176.     epoch = 0
     
177.     while True:
     
178.         avg_cost = 0
     
179.         # 计算出总的批次
     
180.         total_batch = int(train_sample_number / batch_size)
     
181.         # 迭代更新
     
182.         for i in range(total_batch):
     
183.             # 获取x和y
     
184.             batch_xs, batch_ys = mnist.train.next_batch(batch_size)
     
185.             feeds = {x: batch_xs, y: batch_ys, learn_rate: learn_rate_func(epoch)}
     
186.             # 模型训练
     
187.             sess.run(train, feed_dict=feeds)
     
188.             # 获取损失函数值
     
189.             avg_cost += sess.run(cost, feed_dict=feeds)
     
190. 
     
191.         # 重新计算平均损失(相当于计算每个样本的损失值)
     
192.         avg_cost = avg_cost / total_batch
     
193. 
     
194.         # DISPLAY  显示误差率和训练集的正确率以此测试集的正确率
     
195.         if (epoch + 1) % display_step == 0:
     
196.             print("批次: %03d 损失函数值: %.9f" % (epoch, avg_cost))
     
197.             # 这里之所以使用train_img[:1000]和train_label[:1000]，是因为我使用train_img会出现内存不够的情况，直接就会退出
     
198.             feeds = {x: train_img[:1000], y: train_label[:1000], learn_rate: learn_rate_func(epoch)}
     
199.             train_acc = sess.run(acc, feed_dict=feeds)
     
200.             print("训练集准确率: %.3f" % train_acc)
     
201.             feeds = {x: test_img[:1000], y: test_label[:1000], learn_rate: learn_rate_func(epoch)}
     
202.             test_acc = sess.run(acc, feed_dict=feeds)
     
203.             print("测试准确率: %.3f" % test_acc)
     
204. 
     
205.             if train_acc >= 0.99 and test_acc >= 0.98:
     
206.                 saver.save(sess, './data/lenet/model_{}_{}'.format(train_acc, test_acc), global_step=epoch)
     
207.                 break
     
208.         epoch += 1
     
209. 
     
210.     # 模型可视化输出
     
211.     writer = tf.summary.FileWriter('./data/lenet/graph', tf.get_default_graph())
     
212.     writer.close()
     
213. 
     
214. print("end....")
     

复制代码

Justfavor

挺厉害的蛤

Justfavor

挺厉害的蛤

EngyHui

好样的66666666666

wrt789

学习一下