1.黑马课程案例
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
# 定义一个初始化权重的函数
def weight_variables(shape):
w = tf.Variable(tf.random_normal(shape=shape, mean=0.0, stddev=1.0))#返回随机正态分布的随机值
return w
# 定义一个初始化偏置的函数
def bias_variables(shape):
b = tf.Variable(tf.constant(0.0, shape=shape))#初值为0
return b
def model():
"""
自定义的卷积模型
:return:
"""
# 1、准备数据的占位符 x [None, 784] y_true [None, 10]
with tf.variable_scope("data"):
x = tf.placeholder(tf.float32, [None, 784]) #数据特征输入
y_true = tf.placeholder(tf.int32, [None, 10])#数据真实标签输入
# 2、一卷积层 卷积: 5*5*1，32个，strides=1 激活: tf.nn.relu 池化
with tf.variable_scope("conv1"):
# 随机初始化权重, 偏置[32]
w_conv1 = weight_variables([5, 5, 1, 32])
b_conv1 = bias_variables([32])
# 对x进行形状的改变[None, 784] ----> [None, 28, 28, 1]
x_reshape = tf.reshape(x, [-1, 28, 28, 1])
# [None, 28, 28, 1]-----> [None, 28, 28, 32] 卷积加激活
x_relu1 = tf.nn.relu(tf.nn.conv2d(x_reshape, w_conv1, strides=[1, 1, 1, 1], padding="SAME") + b_conv1)
# 池化 2*2 ,strides2 [None, 28, 28, 32]---->[None, 14, 14, 32]
x_pool1 = tf.nn.max_pool(x_relu1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")
# 3、二卷积层卷积: 5*5*32，64个filter，strides=1 激活: tf.nn.relu 池化：
with tf.variable_scope("conv2"):
# 随机初始化权重, 权重：[5, 5, 32, 64] 偏置[64]
w_conv2 = weight_variables([5, 5, 32, 64])
b_conv2 = bias_variables([64])
# 卷积，激活，池化计算
# [None, 14, 14, 32]-----> [None, 14, 14, 64]
x_relu2 = tf.nn.relu(tf.nn.conv2d(x_pool1, w_conv2, strides=[1, 1, 1, 1], padding="SAME") + b_conv2)
# 池化 2*2, strides 2, [None, 14, 14, 64]---->[None, 7, 7, 64]
x_pool2 = tf.nn.max_pool(x_relu2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")
# 4、全连接层 [None, 7, 7, 64]--->[None, 7*7*64]*[7*7*64, 10]+ [10] =[None, 10]
with tf.variable_scope("fc"):
# 随机初始化权重和偏置
w_fc = weight_variables([7 * 7 * 64, 10])
b_fc = bias_variables([10])
# 修改形状 [None, 7, 7, 64] --->None, 7*7*64]
x_fc_reshape = tf.reshape(x_pool2, [-1, 7 * 7 * 64])#展开进行全连接
# 进行矩阵运算得出每个样本的10个结果
y_predict = tf.matmul(x_fc_reshape, w_fc) + b_fc
return x, y_true, y_predict
def conv_fc():
# 获取真实的数据
mnist = input_data.read_data_sets("./minist/", one_hot=True)
# 定义模型，得出输出
x, y_true, y_predict = model()
# 进行交叉熵损失计算
# 3、求出所有样本的损失，然后求平均值
with tf.variable_scope("soft_cross"):
# 求平均交叉熵损失# 求平均交叉熵损失
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true, logits=y_predict))
# 4、梯度下降求出损失
with tf.variable_scope("optimizer"):
train_op = tf.train.GradientDescentOptimizer(0.0001).minimize(loss)
# 5、计算准确率
with tf.variable_scope("acc"):
equal_list = tf.equal(tf.argmax(y_true, 1), tf.argmax(y_predict, 1))
# equal_list None个样本 [1, 0, 1, 0, 1, 1,..........]
accuracy = tf.reduce_mean(tf.cast(equal_list, tf.float32))
# 定义一个初始化变量的op
init_op = tf.global_variables_initializer()
# 开启回话运行
with tf.Session() as sess:
sess.run(init_op)
# 循环去训练
for i in range(100):
# 取出真实存在的特征值和目标值
mnist_x, mnist_y = mnist.train.next_batch(50)
# 运行train_op训练
sess.run(train_op, feed_dict={x: mnist_x, y_true: mnist_y})
print("训练第%d步,准确率为:%f" % (i, sess.run(accuracy, feed_dict={x: mnist_x, y_true: mnist_y})))
return None
if __name__ == "__main__":
conv_fc()
2.书中教材案例（jupyter）
import tensorflow as tf
import tensorflow.examples.tutorials.mnist.input_data as input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
#建立共享函数
def weight(shape):
return tf.Variable(tf.truncated_normal(shape, stddev=0.1),
name ='W')#返回截断类型的随机值，连个方差之间的随机值
def bias(shape):
return tf.Variable(tf.constant(0.1, shape=shape)#初值为0.1
, name = 'b')
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1,1,1,1],
padding='SAME')
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1,2,2,1],
strides=[1,2,2,1],
padding='SAME')#大小减半
#数据输入占位符
with tf.name_scope('Input_Layer'):
x = tf.placeholder("float",shape=[None, 784]
,name="x")
x_image = tf.reshape(x, [-1, 28, 28, 1])#卷积运算分维度，必须分开
#卷积1
with tf.name_scope('C1_Conv'):
W1 = weight([5,5,1,16]) #窗口大小5*5，厚度为1， 数量为16
b1 = bias([16])#对16个卷积窗口进行偏置赋值
Conv1=conv2d(x_image, W1)+ b1
C1_Conv = tf.nn.relu(Conv1 )#非线性化
with tf.name_scope('C1_Pool'):
C1_Pool = max_pool_2x2(C1_Conv)#特征压缩14*14
#卷积2
with tf.name_scope('C2_Conv'):
W2 = weight([5,5,16,36])#窗口大小为5*5， 接上一层厚度为16， 数量为36
b2 = bias([36])
Conv2=conv2d(C1_Pool, W2)+ b2
C2_Conv = tf.nn.relu(Conv2)
with tf.name_scope('C2_Pool'):
C2_Pool = max_pool_2x2(C2_Conv) #7*7
#全连接
with tf.name_scope('D_Flat'):
D_Flat = tf.reshape(C2_Pool, [-1, 1764])#展开进行全连接
with tf.name_scope('D_Hidden_Layer'):
W3= weight([1764, 128])#加一个全连接隐藏层
b3= bias([128])
D_Hidden = tf.nn.relu(
tf.matmul(D_Flat, W3)+b3)
D_Hidden_Dropout= tf.nn.dropout(D_Hidden,
keep_prob=0.8)
#输出层
with tf.name_scope('Output_Layer'):
W4 = weight([128,10])
b4 = bias([10])
y_predict= tf.nn.softmax(
tf.matmul(D_Hidden_Dropout,
W4)+b4)
#模型优化步骤
with tf.name_scope("optimizer"):
y_label = tf.placeholder("float", shape=[None, 10],
name="y_label")
loss_function = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits
(logits=y_predict ,
labels=y_label))
optimizer = tf.train.AdamOptimizer(learning_rate=0.0001) \
.minimize(loss_function)
#模型评估
with tf.name_scope("evaluate_model"):
correct_prediction = tf.equal(tf.argmax(y_predict, 1),
tf.argmax(y_label, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
#训练
trainEpochs = 10
batchSize = 100
# totalBatchs = int(mnist.train.num_examples/batchSize)#将全部数据拿来进行训练，并且进行10遍，所以时间较长
totalBatchs = int(5)#时间太长了，所以只取前500个数据进行循环10次的训练
epoch_list=[];accuracy_list=[];loss_list=[];
from time import time #导入时间模块进行时间统计
startTime=time()
sess = tf.Session()#创建会话
sess.run(tf.global_variables_initializer())#初始化变量
for epoch in range(trainEpochs):
for i in range(totalBatchs):
batch_x, batch_y = mnist.train.next_batch(batchSize)
sess.run(optimizer,feed_dict={x: batch_x,
y_label: batch_y})
loss,acc = sess.run([loss_function,accuracy],
feed_dict={x: mnist.validation.images,
y_label: mnist.validation.labels})
epoch_list.append(epoch)
loss_list.append(loss);accuracy_list.append(acc)
print("Train Epoch:", '%02d' % (epoch+1), \
"Loss=","{:.9f}".format(loss)," Accuracy=",acc)
duration =time()-startTime
print("Train Finished takes:",duration)
- 显示准确率和损失值变化
- 准确率
plt.plot(epoch_list, accuracy_list,label="accuracy" )
fig = plt.gcf()
fig.set_size_inches(4,2)
# plt.ylim(0.8, 1) #因为训练数据太少所以准确度没有达到0.8以上所以一开始没哟显示
plt.ylim(0,1)#设置只查看的范围
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend()
plt.show()
* 损失值
%matplotlib inline
import matplotlib.pyplot as plt
fig = plt.gcf()
fig.set_size_inches(4,2)
plt.plot(epoch_list, loss_list, label = 'loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['loss'], loc='upper left')
- 检测模型准确率（加大数据量便可以提高）
print("Accuracy:",
sess.run(accuracy,feed_dict={x: mnist.test.images,
y_label: mnist.test.labels}))
- 查看softmax输出的概率预测
y_predict=sess.run(y_predict,
feed_dict={x: mnist.test.images[:5000]})#前5000个样本
y_predict[:5]#查看前五个样本对于10种分类分别得概率是多少
- 图像化的预测结果展示
prediction_result=sess.run(tf.argmax(y_predict,1),
feed_dict={x: mnist.test.images ,
y_label: mnist.test.labels})
#建立展示函数
import numpy as np
def show_images_labels_predict(images,labels,prediction_result):
fig = plt.gcf()
fig.set_size_inches(8, 10)
for i in range(0, 10):
ax=plt.subplot(5,5, 1+i)
ax.imshow(np.reshape(images[i],(28, 28)),
cmap='binary')
ax.set_title("label=" +str(np.argmax(labels[i]))+
",predict="+str(prediction_result[i])
,fontsize=9)
plt.show()
show_images_labels_predict(mnist.test.images,mnist.test.labels,prediction_result)
- 选出识别错误的样本
for i in range(500):
if prediction_result[i]!=np.argmax(mnist.test.labels[i]):
print("i="+str(i)+
" label=",np.argmax(mnist.test.labels[i]),
"predict=",prediction_result[i])
#将识别错误的样本进行展示
def show_images_labels_predict_error(images,labels,prediction_result):
fig = plt.gcf()
fig.set_size_inches(8, 10)
i=0;j=0
while i<10:
if prediction_result[j]!=np.argmax(labels[j]):
ax=plt.subplot(5,5, 1+i)
ax.imshow(np.reshape(images[j],(28, 28)),
cmap='binary')
ax.set_title("j="+str(j)+
",l=" +str(np.argmax(labels[j]))+
",p="+str(prediction_result[j])
,fontsize=9)
i=i+1
j=j+1
plt.show()
show_images_labels_predict_error(mnist.test.images,mnist.test.labels,prediction_result)#代表样本索引，真实值，预测值
1387
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
