Tensorflow入门

1. 概述

　　TensorFlow是Google开发的一款用于深度学习的python库，TensorFlow用图来表示计算任务，数据在创建的数据流图中被处理。节点（operation，op）在图中表示数学操作，图中的线表示节点间相互联系的多维数据数组，即张量（tensor）。训练模型的过程中 tensor 会在几点之间传递，由此也可以更好的理解TensorFlow这个名字。图必须在会话里被启动，会话（Session）将图的 op 分发到CPU或GPU之类的计算设备上，同时执行op的方法，计算过后将产生的 tensor 返回。

张量（Tensor): * 张量有多种. 零阶张量为 纯量或标量 (scalar) 也就是一个数值. 比如 [1] * 一阶张量为 向量 (vector), 比如 一维的 [1, 2, 3] * 二阶张量为 矩阵 (matrix), 比如 二维的 [[1, 2, 3],[4, 5, 6],[7, 8, 9]] * 以此类推, 还有 三阶 三维的 ...

2. 基本用法

环境：python3.7   tensorflow1.15

　　使用一个简单拟合二维线性函数的例子来解释TensorFlow的基本用法，这样更容易理解和记忆。整体代码如下：

import tensorflow as tf
import numpy as np

# 针对线性方程 y = 0.1*x + 0.3，生成100个数据
x_data = np.random.rand(100).astype(np.float32)
y_data = x_data*0.1 + 0.3

#构建一个线性模型
Weights = tf.Variable(tf.random_uniform([1],-1.0,1.0))
biases = tf.Variable(tf.zeros([1]))
y = Weights*x_data + biases

# 最小化方差
loss = tf.reduce_mean(tf.square(y-y_data))
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)

# 初始化变量
init = tf.initialize_all_variables()

# 启动图
sess = tf.Session()
sess.run(init)

# 拟合线性方程
for step in range(201):
    sess.run(train)
    if step%20 == 0:
        print(step,sess.run(Weights),sess.run(biases))

　　首先需要构建我们的数据集，生成随机数据时使用numpy这个库比较方便，然后就是构建一个线性模型， tf.Variable用来在模型构建过程中定义一个变量，这里定义一个权重 Weights，可以理解为y = a*x + b 中的参数 a，还定义了一个偏量 biases，可以理解为参数 b。定义完变量之后需要计算方差，并且使用优化器 tf.train.GradientDescentOptimizer(0.5)将方差降低至最小，使得预测数据和样本数据尽量拟合。然后就是初始化变量，通过会话来启动计算模型，最后训练201回合，并每20回合输出一次参数。下面我们从构件图、会话、变量、传入值、添加层、构建神经网络等部分讲解TensorFlow的使用。

2.1 构建图

　　使用两个矩阵相乘这个简单的例子来解释怎样构建一个图：

import tensorflow as tf

# 创建一个 常量 op, 返回值 'matrix1' 代表这个 1x2 矩阵.
matrix1 = tf.constant([[3., 3.]])

# 创建另外一个 常量 op, 返回值 'matrix2' 代表这个 2x1 矩阵.
matrix2 = tf.constant([[2.]
　　　　　　　　　　　　　,[2.]])

# 创建一个矩阵乘法 matmul op , 把 'matrix1' 和 'matrix2' 作为输入.
# 返回值 'product' 代表矩阵乘法的结果.
product = tf.matmul(matrix1, matrix2)

　　图中有三个节点，两个矩阵常量使用 tf.constant()来定义，最后矩阵相乘得出结果，用tf.matmul(matrix1,matrix2)计算两个矩阵相乘，并返回计算结果。这里只是定义了矩阵如何计算并没有执行，计算的过程必须在会话中启动，这部分在之后的会话中讲解。

2.2 会话控制Session

　　Session是 Tensorflow 为了控制和输出文件的执行的语句. 运行 session.run() 可以获得你要得知的运算结果, 或者是你所要运算的部分。之前在矩阵相乘的例子中已经构建好了变量和常量，但是定义的计算方法并不是实际的运算过程，真正的运算过程要是用Session来激活product，并得到计算结果，使用会话控制Session的方法有两种：

# method 1
sess = tf.Session()
result = sess.run(product)
print(result)
sess.close()
# [[12]]

# method 2
with tf.Session() as sess:
    result2 = sess.run(product)
    print(result2)
# [[12]]

2.3 变量Variable

　　和python的变量不同，TensorFlow中变量需要进行提前定义才能使用。

定义语法：state = tf.Variable()

　　变量定义过后还需要对其进行初始化，这一步尤为关键，很容易被忽略。

init = tf.initialize_all_variables()

　　到这一步变量还是没有被激活，需要使用sess.run()来激活变量，TensorFlow中变量的使用必须要有定义、初始化、激活三个步骤之后才会在计算中被使用。下面是一个简单的计数器：

# －创建一个变量, 初始化为标量 0.  初始化定义初值
state = tf.Variable(0, name="counter")

# 创建一个 op, 其作用是使 state 增加 1
one = tf.constant(1)
new_value = tf.add(state, one)
update = tf.assign(state, new_value)

# 启动图后, 变量必须先经过`初始化` (init) op 初始化,
# 才真正通过Tensorflow的initialize_all_variables对这些变量赋初值
init_op = tf.initialize_all_variables()

# 启动默认图, 运行 op
with tf.Session() as sess:

  # 运行 'init' op
  sess.run(init_op)
  
  # 打印 'state' 的初始值
  # 取回操作的输出内容, 可以在使用 Session 对象的 run() 调用 执行图时, 
  # 传入一些 tensor, 这些 tensor 会帮助你取回结果. 
  # 此处只取回了单个节点 state，
  # 也可以在运行一次 op 时一起取回多个 tensor: 
  # result = sess.run([mul, intermed])
  print sess.run(state)
  
  # 运行 op, 更新 'state', 并打印 'state'
  for _ in range(3):
    sess.run(update)
    print sess.run(state)

# 输出:

# 0
# 1
# 2
# 3

2.4传入值 placeholder

　　placeholder是TensorFlow中的占位符，暂时存储变量，TensorFlow如果想要从外部传入data，那就需要使用 tf.placeholder()，然后以这种形式传输数据 sess.run(***，feed_dict={inputt:***}),下面代码是一个简单例子，传值的工作交给了sess.run()，需要传入的值放在了feed_dict={}，并一一对应的每一个input。placeholder和feed_dict={}是绑定在一起出现的。

import tensorflow as tf

#在 Tensorflow 中需要定义 placeholder 的 type ，一般为 float32 形式
input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)

# mul = multiply 是将input1和input2 做乘法运算，并输出为 output 
ouput = tf.multiply(input1, input2)

with tf.Session() as sess:
    print(sess.run(ouput, feed_dict={input1: [7.], input2: [2.]}))
# [ 14.]

2.5 添加层 def add_layer()

　　最基本的神经网络结构也包含输入层、隐藏层、输出层，在构建神经网络过程中我们需要构建一层又一层的神经元，神经层中常见的参数包含weights、biases和激励函数。

import tensorflow as tf

def add_layer(inputs,in_size,out_size,activation_function=None):
    Weights = tf.Variable(tf.random_normal([in_size,out_size]))
    biases = tf.Variable(tf.zeros([1,out_size]) + 0.1)
    Wx_plus_b = tf.matmul(inputs,Weights) + biases
    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    return outputs

　　上面代码是一个添加神经层的函数，参数包括该层输入数据：inputs，输入数据的大小：in_size、输出数据的大小：out_size、激活函数：activation_function，默认的激活函数为None。

　　首先是定义参数weights和biases。因为在生成初始参数时，随机变量(normal distribution)会比全部为0要好很多，所以我们这里的weights为一个in_size行, out_size列的随机变量矩阵。

Weights = tf.Variable(tf.random_normal([in_size, out_size]))

　　在机器学习中，biases的推荐值不为0，所以我们这里是在0向量的基础上又加了0.1。

biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)

　　下面，我们定义Wx_plus_b, 即神经网络未激活的值。其中，tf.matmul()是矩阵的乘法。

Wx_plus_b = tf.matmul(inputs, Weights) + biases

　　当activation_function——激励函数为None时，输出就是当前的预测值——Wx_plus_b，不为None时，就把Wx_plus_b传到activation_function()函数中得到输出。

if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)

　　最后，返回输出，添加一个神经层的函数——def add_layer()就定义好了。

return outputs

2.6 构建神经网络

　　在之前的基础上我们可以知道构建魔性的过程可以概括为：建图——启动图——运行取值。

1、建图

　　构建神经层想必是建图的核心部分，之前我们已经构造好了add_layer()函数，通过输入不同的参数我们可以构建不同的神经层。

def add_layer(inputs,in_size,out_size,activation_function=None):
    Weights = tf.Variable(tf.random_normal([in_size,out_size]))
    biases = tf.Variable(tf.zeros([1,out_size]) + 0.1)
    Wx_plus_b = tf.matmul(inputs,Weights) + biases
    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    return outputs

2、导入数据

　　这里构建一个方程 y = x^2 -0.5有噪声的数据，x_data 和 y_data，noise表示噪声，均值为o，方差为0.05

x_data = np.linspace(-1,1,300, dtype=np.float32)[:, np.newaxis]
noise = np.random.normal(0, 0.05, x_data.shape).astype(np.float32)
y_data = np.square(x_data) - 0.5 + noise

　　利用占位符定义我们所需的神经网络的输入。 tf.placeholder()就是代表占位符，这里的None代表无论输入有多少都可以，因为输入只有一个特征，所以这里是1。

xs = tf.placeholder(tf.float32, [None, 1])
ys = tf.placeholder(tf.float32, [None, 1])

3、搭建网络

　　神经网络的结构通常包含输入层、隐藏层和输出层。由于我们的输入数据比较简单，所以我们的输入层就是我们的导入数据部分；隐藏层我们可以根据具体情况自定义结构，这里我们设置神经元个数为10个，该层输入大小即输入层输出的大小为1，有十个神经元，所以输出数据大小为10。激活函数为None时使用的是TensorFlow自带的激活函数 tf.nn.relu 。

l1 = add_layer(xs, 1, 10, activation_function=tf.nn.relu)

　　输出层的输入就是隐藏层的输出，所以输入大小为10，输出大小为1，输出层的输出数据即为模型的预测值。

prediction = add_layer(l1, 10, 1, activation_function=None)

　　接下来求loss值，计算预测值 prediction 和真实值的误差，对二者差的平方求和再取平均。

loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction),reduction_indices=[1]))

　　然后就是使用优化函数让机器学习模型在训练过程中提升准确率，最基本的优化函数是  tf.train.GradientDescentOptimizer() 中的值通常都小于1，这里取的是 0.1，代表学习率为0.1，以0.1的效率最小化误差loss。

train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

　　设置完变量，神经层，误差计算，训练优化函数之后剩下的就是变量的初始化，定义session，对session进行初始化，最后运行session。

init = tf.global_variables_initializer()  # 初始化所有变量
sess = tf.Session()
sess.run(init)

4、训练模型

　　让之前构建好的神经网络模型训练1000回合，机器学习的内容已经设置好是train_step，用Session来run每一次的train，当运算要用到placeholder时，就需要feed_dict这个字典来指定输入。

for i in range(1000):
    # training
    sess.run(train_step, feed_dict={xs: x_data, ys: y_data})
    if i % 50 == 0:
        # to see the step improvement
        print(sess.run(loss, feed_dict={xs: x_data, ys: y_data}))

5、（数据可视化）

　　利用matplotlib.pyplot库将原本数据和训练好的数据可视化。

# 可视化数据
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.scatter(x_data,y_data)

# 训练模型
for i in range(1000):
    sess.run(train_step,feed_dict={xs:x_data,ys:y_data})
    if i%50 == 0:
        print(sess.run(loss,feed_dict={xs:x_data,ys:y_data}))
prediction_value = sess.run(prediction,feed_dict={xs:x_data})
lines = ax.plot(x_data,prediction_value,'r-',lw=5)
plt.show()

 完整代码如下：

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

def add_layer(inputs,in_size,out_size,activation_function=None):
        Weights = tf.Variable(tf.random_normal([in_size,out_size]),name='w')
        biases = tf.Variable(tf.zeros([1,out_size]) + 0.1,name='b')
        Wx_plus_b = tf.matmul(inputs,Weights) + biases
        if activation_function is None:
            outputs = Wx_plus_b
        else:
            outputs = activation_function(Wx_plus_b)
        return outputs

x_data = np.linspace(-1,1,300)[:,np.newaxis]
noise = np.random.normal(0,0.05,x_data.shape)
y_data = np.square(x_data) - 0.5 + noise

xs = tf.placeholder(tf.float32,[None,1],name='x_input')
ys = tf.placeholder(tf.float32,[None,1],name='y_input')

# 添加隐藏层
L1 = add_layer(xs,1,10,activation_function=tf.nn.relu)
# 添加输出层
prediction = add_layer(L1,10,1,activation_function=None)

loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction),reduction_indices=[1]))
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)
init = tf.initialize_all_variables()
sess = tf.Session()
writer = tf.summary.FileWriter('./logs',sess.graph)
sess.run(init)

# 可视化数据
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.scatter(x_data,y_data)

# 训练模型
for i in range(1000):
    sess.run(train_step,feed_dict={xs:x_data,ys:y_data})
    if i%50 == 0:
        print(sess.run(loss,feed_dict={xs:x_data,ys:y_data}))
prediction_value = sess.run(prediction,feed_dict={xs:x_data})
lines = ax.plot(x_data,prediction_value,'r-',lw=5)
plt.show()

3.classification

任务：使用神经网络模型将一组代表0-9数字的图片按照数字进行分类，使用的数据为MNIST库，如果导入失败可以下载该数据，将tutorials文件夹放入python安装目录的 \python3.7\Lib\site-packages\tensorflow_core\examples\文件夹中，tensorflow官方github中不知道为什么已经没有这个文件夹了，所以我把这个文件夹的微云链接放在这里tutorials。分类模型的完整代码如下：

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

# 读取样本数据
mnist = input_data.read_data_sets('MNIST_data',one_hot=True)

# 定义添加层函数
def add_layer(inputs,in_size,out_size,activation_function=None):
    Weights = tf.Variable(tf.random_normal([in_size,out_size]))
    biases = tf.Variable(tf.zeros([1,out_size]) + 0.1)
    Wx_plus_b = tf.matmul(inputs,Weights) + biases
    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    return outputs

def compute_accuracy(v_xs,v_ys):
    global prediction
    y_pre = sess.run(prediction,feed_dict={xs:v_xs})
    correct_prediction = tf.equal(tf.argmax(y_pre,1),tf.argmax(v_ys,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
    result = sess.run(accuracy,feed_dict={xs:v_xs,ys:v_ys})
    return result

# 784 = 28*28个像素点
xs = tf.placeholder(tf.float32,[None,784])
# 10种数字类型
ys = tf.placeholder(tf.float32,[None,10])

# 添加输出层
prediction = add_layer(xs,784,10,activation_function=tf.nn.softmax)
# 计算loss
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys*tf.log(prediction),reduction_indices=[1]))
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
sess = tf.Session()
sess.run(tf.initialize_all_variables())

print('每一轮的准确率如下：')
for i in range(1000):
    batch_xs,batch_ys = mnist.train.next_batch(100)
    sess.run(train_step,feed_dict={xs:batch_xs,ys:batch_ys})
    if i % 50 == 0:
        print(compute_accuracy(mnist.test.images,mnist.test.labels))