Tensorflow学习——搭建神经网络

基本概念

1、 基于 Tensorflow 的 NN：用张量表示数据，用计算图搭建神经网络，用会话执行计算图，优化线上的权重（参数），得到模型。

2、 张量：张量就是多维数组（列表），用“阶”表示张量的维度。
0 阶张量称作标量，表示一个单独的数；
如：S=123
1 阶张量称作向量，表示一个一维数组；
如：V=[1,2,3]
2 阶张量称作矩阵，表示一个二维数组，它可以有 i 行 j 列个元素，每个元素可以用行号和列号共同索引到；
如：m=[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
判断张量是几阶的，就通过张量右边的方括号数，0 个是 0 阶，n 个是 n 阶，张量可以表示 0 阶到 n 阶数组（列表）；
如：t=[ [ [… ] ] ]为 3 阶。

3、 数据类型：Tensorflow 的数据类型有 tf.float32、tf.int32 等。
例如：
实现 Tensorflow 的加法：

import tensorflow as tf       #引入模块 
a = tf.constant([1.0, 2.0])   #定义一个张量等于[1.0,2.0] 
b = tf.constant([3.0, 4.0])   #定义一个张量等于[3.0,4.0] 
result = a+b                  #实现 a 加 b 的加法 
print result                  #打印出结果 

可以打印出这样一句话：Tensor(“add:0”, shape=(2, ), dtype=float32)，意思为 result 是一个名称为 add:0 的张量，shape=(2,)表示一维数组长度为 2，dtype=float32 表示数据类型为浮点型。

4、 计算图（Graph）： 搭建神经网络的计算过程，是承载一个或多个计算节点的一张图，只搭建网络，不运算。
例如：
神经网络的基本模型是神经元，神经元的基本模型其实就是数学中的乘、加运算。搭建如下的计算图：

x1、x2 表示输入，w1、w2 分别是 x1 到 y 和 x2 到 y 的权重 y=x1w1+x2w2。
实现上述计算图：

import tensorflow as tf           #引入模块 
x = tf.constant([[1.0, 2.0]])     #定义一个 2 阶张量等于[[1.0,2.0]] 
w = tf.constant([[3.0], [4.0]])   #定义一个 2 阶张量等于[[3.0],[4.0]] 
y = tf.matmul(x, w)               #实现 xw 矩阵乘法 
print y                           #打印出结果 

可以打印出这样一句话：Tensor(“matmul:0”, shape(1,1), dtype=float32)，从这里可以看出，print 的结果显示 y 是一个张量，只搭建承载计算过程的计算图，并没有运算，如果想得到运算结果就要用到“会话 Session()”了。

5、 会话（Session）： 执行计算图中的节点运算。

用 with 结构实现，语法如下：

with tf.Session() as sess: 
    print sess.run(y) 

例如：
对于刚刚所述计算图，我们执行 Session()会话可得到矩阵相乘结果：

import tensorflow as tf           #引入模块 
x = tf.constant([[1.0, 2.0]])     #定义一个 2 阶张量等于[[1.0,2.0]] 
w = tf.constant([[3.0], [4.0]])   #定义一个 2 阶张量等于[[3.0],[4.0]] 
y = tf.matmul(x, w)               #实现 xw 矩阵乘法 
print y                           #打印出结果 
with tf.Session() as sess: 
    print sess.run(y)             #执行会话并打印出执行后的结果 

可以打印出这样的结果：

Tensor(“matmul:0”, shape(1,1), dtype=float32) 
[[11.]]  

可以看到，运行Session()会话前只打印出y是个张量的提示，运行Session()会话后打印出了 y 的结果 1.03.0 + 2.04.0 = 11.0。
注意：
1、我们以后会常用到 vim 编辑器，为了使用方便，我们可以更改 vim 的配置文件，使 vim 的使用更加便捷。我们在 vim ~/.vimrc 写入：
set ts=4 表示使 Tab 键等效为 4 个空格
set nu 表示使 vim 显示行号 nu 是 number 缩写
2、在 vim 编辑器中运行 Session()会话时，有时会出现“提示 warning”， 是因为有的电脑可以支持加速指令，但是运行代码时并没有启动这些指令。可以把这些“提示 warning”暂时屏蔽掉。屏蔽方法为进入主目录下的 bashrc 文件，在bashrc 文件中加入这样一句 export TF_CPP_MIN_LOG_LEVEL=2，从而把提示warning的等级降低。
这个命令可以控制 python 程序显示提示信息的等级，在 Tensorflow 里面一般设置成是"0"（显示所有信息）或者"1"（不显示 info）， "2"代表不显示warning，"3"代表不显示 error。一般不建议设置成 3。
source 命令用于重新执行修改的初始化文件，使之立即生效，而不必注销并重新登录。

神经网络

一、神经网络的参数：是指神经元线上的权重w，用变量表示，一般会先随机生成 这些参数。生成参数的方法是让w等于tf.Variable，把生成的方式写在括号里。

神经网络中常用的生成随机数/数组的函数有：

tf.random_normal()            生成正态分布随机数 
tf.truncated_normal()         生成去掉过大偏离点的正态分布随机数 
tf.random_uniform()           生成均匀分布随机数 
tf.zeros                      表示生成全 0 数组        
tf.ones                       表示生成全 1 数组       
tf.fill                       表示生成全定值数组     
tf.constant                   表示生成直接给定值的数组 

例如：
1、 w=tf.Variable(tf.random_normal([2,3],stddev=2, mean=0, seed=1))，表示生成正态分布随机数，形状两行三列，标准差是 2，均值是 0，随机种子是 1。
2、 w=tf.Variable(tf.Truncated_normal([2,3],stddev=2, mean=0, seed=1))，表示去掉偏离过大的正态分布，也就是如果随机出来的数据偏离平均值超过两个标准差，这个数据将重新生成。
3、 w=random_uniform(shape=7,minval=0,maxval=1,dtype=tf.int32，seed=1),表示从一个均匀分布[minval maxval)中随机采样，注意定义域是左闭右开，即包含 minval，不包含 maxval。
4、 除了生成随机数，还可以生成常量。tf.zeros([3,2],int32)表示生成[[0,0],[0,0],[0,0]]；tf.ones([3,2],int32)表示生成[[1,1],[1,1],[1,1]；tf.fill([3,2],6)表示生成[[6,6],[6,6],[6,6]]；tf.constant([3,2,1])表示生成[3,2,1]。
注意：
1.随机种子如果去掉每次生成的随机数将不一致。
2.如果没有特殊要求标准差、均值、随机种子是可以不写的。

二、神经网络的搭建
神经网络的实现过程：
1、准备数据集，提取特征，作为输入喂给神经网络（Neural Network，NN）
2、搭建 NN 结构，从输入到输出（先搭建计算图，再用会话执行）
（ NN 前向传播算法—>计算输出）
3、大量特征数据喂给 NN，迭代优化 NN 参数
（ NN 反向传播算法—>优化参数训练模型）
4、使用训练好的模型预测和分类

由此可见，基于神经网络的机器学习主要分为两个过程，即训练过程和使用过程。 训练过程是第一步、第二步、第三步的循环迭代，使用过程是第四步，一旦参数优化完成就可以固定这些参数，实现特定应用了。

三、前向传播
前向传播就是搭建模型的计算过程，让模型具有推理能力，可以针对一组输入给出相应的输出。
例如：
假如生产一批零件，体积为 x1，重量为 x2，体积和重量就是我们选择的特征，把它们喂入神经网络，当体积和重量这组数据走过神经网络后会得到一个输出。

假设输入的特征值是：体积 0.7 重量 0.5

由搭建的神经网络可得，隐藏层节点a11=x1w11+x2w21=0.14+0.15=0.29，同理算得节点 a12=0.32，a13=0.38，最终计算得到输出层 Y=-0.015，这便实现了前向传播过程。

前向传播过程的 tensorflow 描述：
变量初始化、计算图节点运算都要用会话（with 结构）实现。

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

变量初始化：在 sess.run 函数中用 tf.global_variables_initializer()汇总所有待优化变量。

init_op = tf.global_variables_initializer() 
    sess.run(init_op) 

计算图节点运算：在 sess.run 函数中写入待运算的节点 。

sess.run(y) 

用 tf.placeholder 占位，在 sess.run 函数中用 feed_dict 喂数据
喂一组数据：

x = tf.placeholder(tf.float32, shape=(1, 2)) 
sess.run(y, feed_dict={x: [[0.5,0.6]]}) 

喂多组数据：

x = tf.placeholder(tf.float32, shape=(None, 2)) 
sess.run(y, feed_dict={x: [[0.1,0.2],[0.2,0.3],[0.3,0.4],[0.4,0.5]]}) 

例如：
这是一个实现神经网络前向传播过程，网络可以自动推理出输出 y 的值。
①用 placeholder 实现输入定义（sess.run 中喂入一组数据）的情况
第一组喂体积 0.7、重量 0.5

#coding:utf-8 
import tensorflow as tf 
#定义输入和参数 
x=tf.placeholder(tf.float32,shape=(1,2)) 
w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1)) 
w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1)) 
#定义前向传播过程 
a=tf.matmul(x,w1) 
y=tf.matmul(a,w2) 
#用会话计算结果 
with tf.Session() as sess: 
init_op=tf.global_variables_initializer() 
sess.run(init_op) 
print ”y in tf3_3.py is:\n”,sess.run(y,feed_dict={x:[[0.7,0.5]]}) 

②用 placeholder 实现输入定义（sess.run 中喂入多组数据）的情况
第一组喂体积 0.7、重量 0.5，第二组喂体积 0.2、重量 0.3，第三组喂体积 0.3 、重量 0.4，第四组喂体积 0.4、重量 0.5.

#coding:utf-8 
import tensorflow as tf 
#定义输入和参数 
x=tf.placeholder(tf.float32,shape=(None,2)) 
w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1)) 
w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1)) 
#定义前向传播过程 
a=tf.matmul(x,w1) 
y=tf.matmul(a,w2) 
#用会话计算结果 
with tf.Session() as sess: 
init_op=tf.global_variables_initializer() 
sess.run(init_op) 
print”y in tf3_4.py is:\n”,sess.run(y,feed_dict={x:[[0.7,0.5], 
[0.2,0.3],[0.3,0.4]，[0.4,0.5]]}) 

四、反向传播
反向传播：训练模型参数，在所有参数上用梯度下降，使 NN 模型在训练数据上的损失函数最小。

损失函数（loss）：计算得到的预测值 y 与已知答案 y_的差距。损失函数的计算有很多方法，均方误差 MSE 是比较常用的方法之一。

均方误差 MSE：求前向传播计算结果与已知答案之差的平方再求平均。

用 tensorflow 函数表示为：

loss_mse = tf.reduce_mean(tf.square(y_ - y)) 

反向传播训练方法：以减小 loss 值为优化目标，有梯度下降、momentum 优化
器、adam 优化器等优化方法。
这三种优化方法用 tensorflow 的函数可以表示为：

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

train_step=tf.train.MomentumOptimizer(learning_rate,momentum).minimize(loss)
 
train_step=tf.train.AdamOptimizer(learning_rate).minimize(loss) 

三种优化方法区别如下：
1、tf.train.GradientDescentOptimizer()
使用随机梯度下降算法，使参数沿着梯度的反方向，即总损失减小的方向移动，实现更新参数。
参数更新公式为 ：

其中，?(?)为损失函数，?为参数，?为学习率。
2、tf.train.MomentumOptimizer()
在更新参数时，利用了超参数，参数更新公式为：

其中，?为学习率，超参数为?，?为参数，?(??−1)为损失函数的梯度。
3、tf.train.AdamOptimizer()是利用自适应学习率的优化算法，和随机梯度下降算法不同。随机梯度下降算法保持单一的学习率更新所有的参数，学习率在训练过程中并不会改变。而此算法通过计算梯度的一阶矩估计和二阶矩估计而为不同的参数设计独立的自适应性学习率。

学习率：决定每次参数更新的幅度。
优化器中都需要一个叫做学习率的参数，使用时，如果学习率选择过大会出现震荡不收敛的情况，如果学习率选择过小，会出现收敛速度慢的情况。可以选个比较小的值填入，比如 0.01、0.001。

搭建神经网络

神经网络的搭建可分为四步：准备工作、前向传播、反向传播和循环迭代。
第一步：导入模块，生成模拟数据集；

		import 
        常量定义 
        生成数据集

第二步：前向传播：定义输入、参数和输出

         x=        y_= 
         w1=       w2= 
         a=        y= 

第三步：反向传播：定义损失函数、反向传播方法

		loss= 
		train_step= 

第四步：生成会话，循环迭代，训练 STEPS 轮

with tf.session() as sess 
    Init_op=tf. global_variables_initializer() 
    sess_run(init_op) 
    STEPS=3000 
 for i in range(STEPS): 
    start= 
    end= 
    sess.run(train_step, feed_dict:) 

例：
随机产生 32 组生产出的零件的体积和重量，训练 3000 轮，每 500 轮输出一次损失函数。

#coding:utf-8
#第一步
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8
seed = 23455

#基于seed产生随机数
rng = np.random.RandomState(seed)
#随机数返回32行，2列的矩阵，作为输入数据集
X = rng.rand(32,2)
#从X这个矩阵中取出一行，判断是否和小于1，如果是，给Y赋值1，如果不是，给Y赋值0
#Y作为输入数据集的标签
Y = [[int(x0+x1<1)] for (x0,x1) in X]
print "X:\n",X
print "Y:\n",Y

#第二步
x  = tf.placeholder(tf.float32, shape=(None,2))
y_= tf.placeholder(tf.float32, shape=(None,1))
w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
a = tf.matmul(x,w1)
y = tf.matmul(a,w2)

#第三步
loss = tf.reduce_mean(tf.square(y-y_))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)

#第四步
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEPS = 3000
    for i in range(STEPS)
        start = (i*BATCH_SIZE) % 32
        end = start+BATCH_SIZE
        sess.run(train_step,feed_dict={x:X[start:end],y_:Y[start:end]})
        if i % 500 == 0
            total_loss = sess.rum(loss,feed_dict={x:X,y_:Y})
            print("在%d次训练后，损失为%g" % (i,total_loss))
#输出训练后的参数取值
print "\n"
print "w1:\n",sess.run(w1)
print "w2:\n",sess.run(w2)