深度学习之tensorflow的简单使用


最近在学习深度学习，本文记录了在学习时利用tensorflow敲的几个简单案例，将持续更新。

tensorflow简介

Tensorflow是一个编程系统，使用图来表示计算任务。使用图来表示计算任务. 图中的节点被称之为 op (operation 的缩写). 一个 op 获得 0 个或多个 Tensor, 执行计算, 产生 0 个或多个 Tensor. 每个 Tensor 是一个类型化的多维数组. TensorFlow 程序通常被组织成一个构建阶段和一个执行阶段. 在构建阶段, op 的执行步骤 被描述成一个图. 在执行阶段, 使用会话执行执行图中的 op。

环境配置

见链接：https://blog.csdn.net/candice5566/article/details/103773727

利用tensorflow处理简单的非线性回归问题

import tensorflow as tf
import numpy as np
#python中一个画图的工具包
import matplotlib.pyplot as plt
#生成样本点
#使用numpy生成200个随机点
#生成在-0.5到0.5均匀分布的200个点 一维数据 后面的是增加一个维度 200行一列的数据
x_data=np.linspace(-0.5,0.5,200)[:,np.newaxis]
noise=np.random.normal(0,0.02,x_data.shape)
y_data=np.square(x_data)+noise
 
#定义两个placeholder
#后面的属性是定义形状，行数不限定None，列数为1列 ps x，y和样本对应的
x=tf.placeholder(tf.float32,[None,1])
y=tf.placeholder(tf.float32,[None,1])
 
#构建神经网络
#输入一个x经过神经网络的计算输出y，我们期望预测值和真实的值比较接近
#输入时一个一个的点，只有一个神经元，中间层可以调节，输出层也是一个神经元
 
#定义神经网络中间层
#得到权值，起初赋随机值 1,10 1是输入有一个，中间层有10个神经元
Weights_L1=tf.Variable(tf.random_normal([1,10]))
#偏置值初始化为0
biases_L1=tf.Variable(tf.zeros([1,10]))
#计算信号的总和 矩阵的乘法
Wx_plus_b_L1=tf.matmul(x,Weights_L1)+biases_L1
#L1中间层的输出 
#用双曲正切函数作为激活函数
L1=tf.nn.tanh(Wx_plus_b_L1)
 
 
#定义神经网络输出层
Weights_L2=tf.Variable(tf.random_normal([10,1]))
#偏置值初始化为0\
#输出层有一个神经元偏置值只有一个
biases_L2=tf.Variable(tf.zeros([1,1]))
Wx_plus_b_L2=tf.matmul(L1,Weights_L2)+biases_L2
prediction=tf.nn.tanh(Wx_plus_b_L2)
 
#定义代价函数和训练的方法
 
#二次代价函数
loss=tf.reduce_mean(tf.square(y-prediction))
#使用梯度下降法
train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)
 
 
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for _ in range(2000):
        #训练，传样本值
        sess.run(train_step,feed_dict={
   x:x_data,y:y_data})
        
    #获得预测值
    prediction_value=sess.run(prediction,feed_dict={
   x:x_data})
    #画图
    plt.figure()
    #将样本点以散点图的方式打印出来
    plt.scatter(x_data,y_data)
    #预测的结果 红实线 
    plt.plot(x_data,prediction_value,'r-',lw=5)
    plt.show()
 
    
    #训练出来的结果的loss值是最小的

如代码所示，利用梯度下降方法来求loss的最小值，最终训练出来的结果如下图：

使用梯度下降法训练MNIST数据集并分类

首先下载MNIST数据集：

链接：https://pan.baidu.com/s/1Nn83ELVE1AbH89c-9THK4g
提取码：4m0x

这个神经网络比较简单，没有用中间层，直接输入输出层。建议先了解一下softmax函数。

import tensorflow as tf
#和手写数字相关的一个数据包
#这里一定要给input_data起个别名，不然下文会提示not defined
import tensorflow.examples.tutorials.mnist.input_data as input_data
#载入数据集合
mnist=input_data.read_data_sets("MINIST_data",one_hot=True)
 
#m每个批次的大小
#批次：训练模型的时候，将一个批次的数据放进网络进行训练，以一个矩阵的形式
batch_size=100
#计算一共有多少个批次 数量 整除
n_batch=mnist.train.num_examples//batch_size
 
#定义两个placeholder
#行与批次有关系，列784=28*28 
x=tf.placeholder(tf.float32,[None,784])
#数字从0到9一共10个标签
y=tf.placeholder(tf.float32,[None,10])
 
#创建一个简单的神经网络
#输入层 784 个神经元 输出层有10个神经元
#权值
W=tf.Variable(tf.zeros([784,10]))
#偏置值
b=tf.Variable(tf.zeros([10]))
#矩阵相乘 x*W+b 相当于信号的总和 经过softmax函数 ，将输出信号转化为概率值 存放到预测值里面
prediction=tf.nn.softmax(tf.matmul(x,W)+b)
 
#二次大家函数
loss=tf.reduce_mean(tf.square(y-prediction))
#使用梯度下降法
train_step=tf.train.GradientDescentOptimizer(0.2).minimize(loss)
 
#初始化变量
init=tf.global_variables_initializer()
 
#求准侧率的方法
#比较两个参数是否相同 返回值是true 和false
#argmax求标签里最大的值是在那个位置 返回概率最大的那个 和真实的值比较 参数1表示在行向量上搜索
#结果存放在一个bool型列表中
correct_prediction=tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))
#求准确率
#cast 将布尔类型转化为32位浮点型 再求平均值 将true转化为1.0 将false转化为0 即可达到准确率
accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
 
with tf.Session() as sess:
    sess.run(init)
    #迭代21个周期
    for epoch in range(21):
        for batch in range(n_batch):
            #获得100张图片 将图片的数据保存在xs里面，将标签保存在ys里面 下一次再执行这个函数时，获得下一个批次的图片
            batch_xs,batch_ys=mnist.train.next_batch(batch_size)
            #训练 将数据传入
            sess.run(train_step,feed_dict={
   x:batch_xs,y:batch_ys})
        #将测试集的图片和标签传进去 然后求准侧率
        acc=sess.run(accuracy,feed_dict={
   x:mnist.test.images,y:mnist.test.labels})
        print("ITer"+str(epoch)+",Test accuracy:"+str(acc))

经过21次迭代后，准确率维持在91%左右。

利用RNN训练MNIST数据集

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import  input_data
mnist=input_data.read_data_sets("MINIST_data",one_hot=True)
 
#输入图片是28*28
n_inputs=28 #输入一行，一行有28 个数据
max_time=28 #一共28行
lstm_size=100 #隐层单元
n_classes=10 #10个分类
batch_size=50 #每个批次50个样本
n_batch=mnist.train.num_examples//batch_size
 
x=tf.placeholder(tf.float32,[None,784])
#数字从0到9一共10个标签
y=tf.placeholder(tf.float32,[None,10])
 
#初始化权值
weights=tf.Variable(tf.truncated_normal([lstm_size,n_classes],stddev=0.1))
biases=tf.Variable(tf.constant(0.1,shape=[n_classes]))
 
#定义RNN网络
def RNN(X,weights,biases):
    # inputs=[batch_size,max_time,n_inputs] 把x转换为50个28列28行的数据格式 因为inputs在后面的调用，格式是固定的。
    inputs=tf.reshape(X,[-1,max_time,n_inputs])
    #定义LSTM基本CELL
    #lstm_cell=tf.contrib.rnn.core_run_cell.BasicLSTMCell(lstm_size) 
    lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(lstm_size)
    #final_state[0]是cell_state
    #final_state[1]是hidden_state
    outputs,final_state=tf.nn.dynamic_rnn(lstm_cell,inputs,dtype=tf.float32)
    results=tf.nn.softmax(tf.matmul(final_state[1],weights)+biases) #神经网络最终的输出 在经过softmax函数转化为概率 
    return results #得到结果 返回
 
#计算RNN的返回结果
prediction=RNN(x,weights,biases)
#损失函数
cross_entropy=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=prediction,labels=y))
#使用AdamOptimizer进行优化
train_step=tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction=tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))
#求准确率
#cast 将布尔类型转化为32位浮点型 再求平均值 将true转化为1.0 将false转化为0 即可达到准确率
accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
 
init=tf.global_variables_initializer()
 
with tf.Session() as sess:
    sess.run(init)
    for epoch in range(6):
        for batch in range(n_batch):
            #获得100张图片 将图片的数据保存在xs里面，将标签保存在ys里面 下一次再执行这个函数时，获得下一个批次的图片
            batch_xs,batch_ys=mnist.train.next_batch(batch_size)
            #训练 将数据传入
            sess.run(train_step,feed_dict={
   x:batch_xs,y:batch_ys})
        #将测试集的图片和标签传进去 然后求准侧率
        acc=sess.run(accuracy,feed_dict={
   x:mnist.test.images,y:mnist.test.labels})
        print("Iter " + str(epoch) + ",Testing Accuracy " + str(acc))

训练效果还是不错的，比之前用普通的神经网络效果好很多的。

参考视频：https://www.bilibili.com/video/av20542427?t=561&p=23