mnist(softmax、NN、CNN)

预处理

  • tensorflow库内包含mnist,直接加载mnist数据并转为一维数组形式。直接加载的是.gz格式。
1
2
3
import tensorflow as tf
import tensorflow.examples.tutorials.mnist.input_data as input_data # 加载mnist数据
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) # one_hot为是否将标签转为一维数组形式

逻辑回归

  • 加载数据
  • 图片转为一维数组
  • 建立模型:softmax回归模型
  • w为可变n*784二维矩阵,b为10数组
  • w、b变量初始化为0
  • y=w*x+b
  • 损失函数:交叉熵
  • 训练模型
  • 模型评估
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# -*- coding: utf-8 -*-


# 读取数据图片,预处理
import tensorflow as tf
import tensorflow.examples.tutorials.mnist.input_data as input_data # 加载mnist数据
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) # one_hot为是否将标签转为一维数组形式


# 构建softmax回归模型
sess = tf.InteractiveSession() # 交互作用类(不需用在计算前构建整个图)


# 占位符(x和y_)
x = tf.placeholder("float", shape=[None, 784]) # 浮点数,二维数组(第一维大小不定,第二维是784)
y_ = tf.placeholder("float", shape=[None, 10]) # 用于代表对应某一MNIST图片的类别


# 变量(w权重和b偏置)
w = tf.Variable(tf.zeros([784, 10])) # 784*10的可变参数值二维矩阵
b = tf.Variable(tf.zeros([10])) # 10维的向量
sess.run(tf.initialize_all_variables()) # 初始化所有变量为0


# 类别预测与损失函数
y = tf.nn.softmax(tf.matmul(x, w) + b) # 计算每个分类的softmax概率值
cross_entropy = -tf.reduce_sum(y_ * tf.log(y)) # 损失函数(目标类别和预测类别之间的交叉熵)


# 训练模型
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy) # 最速下降法,步长为0.01
for i in range(1000):
batch = mnist.train.next_batch(50) # 每步加载50个样本
train_step.run(feed_dict={x: batch[0], y_: batch[1]}) # feed_dict被每次训练的数据替代


# 模型评估
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) # 检测预测值与实际值是否匹配
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) # 将布尔数组转化为正确率
print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels})) # 输出最终正确率

神经网络

  • 加载数据集
  • 定义函数:
    • 初始化函数
    • 神经元模型:mlp、逻辑回归、s函数
  • 照片转一维数组、确定测试、训练的照片、标签
  • 占位符:定义张量
  • 调用神经元模型函数
  • 计算代价函数、构造优化器、求行最值
  • 初始化变量、迭代100次
  • 打印正确率
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
# -*- coding: utf-8 -*-


# 神经网络
import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data # 加载数据


def init_weight(shape): # 初始化
return tf.Variable(tf.random_normal(shape, stddev=0.01)) # (stddev是标准差,random_normal是正态分布的随机输出值)张量的可变随机值


def model(X, w_h, w_o): # 神经元模型
h = tf.nn.sigmoid(tf.matmul(X, w_h)) # 这是一个基本的mlp,两个堆栈逻辑回归 # X和w_h矩阵相乘,s函数
return tf.matmul(h, w_o) # 在最后不使用softmax,因为代价函数 # 返回h和w_o的两矩阵之积


mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) # 把数据转换为一位数组的格式
trX = mnist.train.images # 训练的图片
trY = mnist.train.labels # 训练的标签
teX = mnist.test.images # 测试的图片
teY = mnist.test.labels # 测试的标签


# 占位符
X = tf.placeholder("float", [None, 784]) # 第一维长度不定,第二维长度为784的二维矩阵 浮点数 784=28*28
Y = tf.placeholder("float", [None, 10]) # 输出的10种情况


w_h = init_weight([784, 625]) # 创建特征变量 # 调用上边自定义的函数,对矩阵进行初始化
w_o = init_weight([625, 10]) # 初始化


py_x = model(X, w_h, w_o) # 调用上边的自定义函数,


cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=py_x, labels=Y)) # 计算代价
train_op = tf.train.GradientDescentOptimizer(0.05).minimize(cost) # 构造优化器 # 0.05的学习率使代价函数最小
predict_op = tf.argmax(py_x, 1) # 求行中最大值


# 在会话中启动图表
with tf.Session() as sess:
# 初始化所有变量
tf.global_variables_initializer().run() # 添加用于初始化变量的节点,

for i in range(100): # 迭代100次
for start, end in zip(range(0, len(trX)), range(128, len(trX)+1, 128)): # zip函数是将两个列表打包为元组的列表,元素个数与最短列表一致
sess.run(train_op, feed_dict={X: trX[start: end], Y: trY[start:end]}) # 跑
print(i, np.mean(np.argmax(teY, axis=1) ==
sess.run(predict_op, feed_dict={X: teX}))) # mean函数是求平均值,打印预测和实际相同时的概率

# for i in range(100):
# for start, end in zip(range(0, 1000), range(128, 1000+1, 128)):
# sess.run(train_op, feed_dict={X: trX[start: end], Y: trY[start:end]})
# print(i, np.mean(np.argmax(teY, axis=1) ==
# sess.run(predict_op, feed_dict={X: teX})))

卷积神经网络

  • CNN
    • 输入层
    • 卷积层
    • 激活函数
    • 池化层
    • 全连接层

卷积就是为了降维

池化就是数据压缩,特征压缩(提取主要特征)

  • 加载数据
  • 定义初始化函数、定义模型函数(relu、max_pool、dropout)
  • 图片转一维数组
  • 张量、初始化
  • 调用模型函数
  • 训练的下降率
  • argmax
  • 迭代10次
  • 测试集是打乱的(np.random.shuffle)
  • 打印准确率
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
-*- coding: utf-8 -*-


# # 读取数据图片,预处理
# import tensorflow as tf
# import tensorflow.examples.tutorials.mnist.input_data as input_data # 加载mnist数据
# mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) # one_hot为是否将标签转为一维数组形式


# 构建一个多层卷积神经网络
import tensorflow as tf


# 权重初始化
def weight_variable(shape): # 权重
initial = tf.truncated_normal(shape, stddev=0.01)
return tf.Variable(initial)


def bias_variable(shape): # 偏置
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)


# 卷积和池化
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME') # 1步长的卷积,0边距的模板(用0填充边界)


def max_pool_2x2(x): # 池化使用2*2的模板
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding='SAME')


# 第一层卷积
W_conv1 = weight_variable([5, 5, 1, 32]) # 卷积在每个5*5的patch中算出32个特征
b_conv1 = bias_variable([32]) # 每个输出的通道都有一个的对应的偏置量

x_image = tf.reshape(x, [-1, 28, 28, 1]) # x变为一个4d向量,第2、3维是图片的宽、高,第4维是图片的颜色通道数

h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) # 把x_image和权值向量进行卷积,加上偏置项,然后使用RELU函数
h_pool1 = max_pool_2x2(h_conv1) # 最后进行max_pooling(四个像素点中选取最大的)


# 第二层卷积
W_conv2 = weight_variable([5, 5, 32, 64]) # 每个5*5的patch中算出64个特征
b_conv2 = bias_variable([64])

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)


# 密集层网络
W_fc1 = weight_variable([7*7*64, 1024]) # 图片尺寸减少到了7*7,加入一个有1024个神经元的全连接层
b_fc1 = bias_variable([1024])

h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64]) # 把池化层输出的张量reshape为一些向量
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1) # 乘上权重矩阵,加上偏置,然后使用RELU


# Droput(减少过拟合)
keep_prob = tf.placeholder("float") # 训练中启用dropout,测试中关闭的dropout
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)


# 输出层(添加一个softmax层)
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])

y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2) # softmax函数


# 训练和模型评估(ADAM优化器做梯度下降,每100次迭代输出一次日志)
cross_entropy = -tf.reduce_sum(y_ * tf.log(y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
sess.run(tf.initialize_all_variables())
for i in range(20000):
batch = mnist.train.next_batch(50)
if i % 100 == 0:
train_accuracy = accuracy.eval(feed_dict={
x: batch[0], y_: batch[1], keep_prob: 1.0
})
print('step %d, training accuracy %g' % i, train_accuracy)
train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})

print('test accuracy %g' % accuracy.eval(feed_dict={
x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0
}))


----------------------------------------------------------------------------------------------------------------------

# # -*- coding: utf-8 -*-


import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data


batch_size = 128
test_size = 256


def init_weights(shape):
return tf.Variable(tf.random_normal(shape, stddev=0.01))


def model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden):
l1a = tf.nn.relu(tf.nn.conv2d(X, w,
strides=[1, 1, 1, 1], padding='SAME'))
l1 = tf.nn.max_pool(l1a, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding='SAME')
l1 = tf.nn.dropout(l1, p_keep_conv)

l2a = tf.nn.relu(tf.nn.conv2d(l1, w2,
strides=[1, 1, 1, 1], padding='SAME'))
l2 = tf.nn.max_pool(l2a, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding='SAME')
l2 = tf.nn.dropout(l2, p_keep_conv)

l3a = tf.nn.relu(tf.nn.conv2d(l2, w3,
strides=[1, 1, 1, 1], padding='SAME'))
l3 = tf.nn.max_pool(l3a, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding='SAME')
l3 = tf.reshape(l3, [-1, w4.get_shape().as_list()[0]])
l3 = tf.nn.dropout(l3, p_keep_conv)

l4 = tf.nn.relu(tf.matmul(l3, w4))
l4 = tf.nn.dropout(l4, p_keep_conv)

pyx = tf.matmul(l4, w_o)
return pyx


mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels
trX = trX.reshape(-1, 28, 28, 1)
teX = teX.reshape(-1, 28, 28, 1)


X = tf.placeholder("float", [None, 28, 28, 1])
Y = tf.placeholder("float", [None, 10])


w = init_weights([3, 3, 1, 32])
w2 = init_weights([3, 3, 32, 64])
w3 = init_weights([3, 3, 64, 128])
w4 = init_weights([128 * 4 * 4, 625])
w_o = init_weights([625, 10])


p_keep_conv = tf.placeholder("float")
p_keep_hidden = tf.placeholder("float")
py_x = model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden)


cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=py_x, labels=Y))
train_op = tf.train.RMSPropOptimizer(0.001, 0.9).minimize(cost)
predict_op = tf.argmax(py_x, 1)


#
with tf.Session() as sess:
#
tf.global_variables_initializer().run()

for i in range(10):
train_batch = zip(range(0, len(trX), batch_size),
range(batch_size, len(trX) + 1, batch_size))
for start, end in train_batch:
sess.run(train_op, feed_dict={X: trX[start: end], Y: trY[start: end],
p_keep_conv: 0.8, p_keep_hidden: 0.5})

test_indices = np.arange(len(teX))
np.random.shuffle(test_indices)
test_indices = test_indices[0:test_size]

print(i, np.mean(np.argmax(teY[test_indices], axis=1) ==
sess.run(predict_op, feed_dict={X: teY[test_indices],
Y: teY[test_indices],
p_keep_conv: 1.0,
p_keep_hidden: 1.0})))


----------------------------------------------------------------------------------------------------------------------


import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data # 加载数据

batch_size = 128
test_size = 256


def init_weights(shape): # 初始化
return tf.Variable(tf.random_normal(shape, stddev=0.01))


def model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden): # 定义的模型函数
l1a = tf.nn.relu(tf.nn.conv2d(X, w,
strides=[1, 1, 1, 1], padding='SAME')) # l1a shape=(?, 28, 28, 32)
l1 = tf.nn.max_pool(l1a, ksize=[1, 2, 2, 1], # l1 shape=(?, 14, 14, 32)
strides=[1, 2, 2, 1], padding='SAME')
l1 = tf.nn.dropout(l1, p_keep_conv)

l2a = tf.nn.relu(tf.nn.conv2d(l1, w2,
strides=[1, 1, 1, 1], padding='SAME')) # l2a shape=(?, 14, 14, 64)
l2 = tf.nn.max_pool(l2a, ksize=[1, 2, 2, 1], # l2 shape=(?, 7, 7, 64)
strides=[1, 2, 2, 1], padding='SAME')
l2 = tf.nn.dropout(l2, p_keep_conv)

l3a = tf.nn.relu(tf.nn.conv2d(l2, w3,
strides=[1, 1, 1, 1], padding='SAME')) # l3a shape=(?, 7, 7, 128)
l3 = tf.nn.max_pool(l3a, ksize=[1, 2, 2, 1], # l3 shape=(?, 4, 4, 128)
strides=[1, 2, 2, 1], padding='SAME')
l3 = tf.reshape(l3, [-1, w4.get_shape().as_list()[0]]) # reshape to (?, 2048)
l3 = tf.nn.dropout(l3, p_keep_conv)

l4 = tf.nn.relu(tf.matmul(l3, w4))
l4 = tf.nn.dropout(l4, p_keep_hidden)

pyx = tf.matmul(l4, w_o)
return pyx


mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) # 将照片转一维数组
trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels # 定义训练、测试的图片、属性
trX = trX.reshape(-1, 28, 28, 1) # 28x28x1 input img
teX = teX.reshape(-1, 28, 28, 1) # 28x28x1 input img


X = tf.placeholder("float", [None, 28, 28, 1]) # 张量 浮点数 4维矩阵
Y = tf.placeholder("float", [None, 10])


w = init_weights([3, 3, 1, 32]) # 3x3x1 conv, 32 outputs
w2 = init_weights([3, 3, 32, 64]) # 3x3x32 conv, 64 outputs
w3 = init_weights([3, 3, 64, 128]) # 3x3x32 conv, 128 outputs
w4 = init_weights([128 * 4 * 4, 625]) # FC 128 * 4 * 4 inputs, 625 outputs
w_o = init_weights([625, 10]) # FC 625 inputs, 10 outputs (labels)


p_keep_conv = tf.placeholder("float") # 卷积核多项式乘法
p_keep_hidden = tf.placeholder("float") # 隐藏的
py_x = model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden) # 调用模型函数


cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=py_x, labels=Y)) # 准确率
train_op = tf.train.RMSPropOptimizer(0.001, 0.9).minimize(cost) # 训练的下降率
predict_op = tf.argmax(py_x, 1) # 求行中最大


#
with tf.Session() as sess:
# 初始化所有可变值
tf.global_variables_initializer().run() # 跑

for i in range(10): # 迭代10次
training_batch = zip(range(0, len(trX), batch_size),
range(batch_size, len(trX)+1, batch_size)) # 训练批次
for start, end in training_batch: # 训练
sess.run(train_op, feed_dict={X: trX[start:end], Y: trY[start:end],
p_keep_conv: 0.8, p_keep_hidden: 0.5})

test_indices = np.arange(len(teX)) # 得到一个测试批
np.random.shuffle(test_indices) # 打乱测试集
test_indices = test_indices[0:test_size]

print(i, np.mean(np.argmax(teY[test_indices], axis=1) ==
sess.run(predict_op, feed_dict={X: teX[test_indices],
Y: teY[test_indices],
p_keep_conv: 1.0,
p_keep_hidden: 1.0}))) # 打印预准率
Donate comment here