神经网络的搭建

一、神经网络的搭建

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

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

二、前向传播

前向传播：搭建模型的计算过程，让模型具有推理能力，可以针对一组输入给出相应的输出。 

举例：

假如生产一批零件，体积为 x1，重量为 x2，体积和重量就是我们选择的特征，把它们喂入神经网络，当体积和重量这组数据走过神经网络后会得到一个输出。假如输入的特征值是：体积 0.7  重量 0.5   

   

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

推导过程：

第一层

X 是输入为 1X2 矩阵 ：用 x 表示输入，是一个 1 行 2 列矩阵，表示一次输入一组特征，这组特征包含了体积和重量两个元素。

W_{（前结点参数，后结点参数）}^(层数)为待优化的参数 ：对于第一层的w 前面有两个节点，后面有三个节点 w应该是个两行三列矩阵，我们这样表示：

                                                             

神经网络共有几层（或当前是第几层网络）都是指的计算层，输入不是计算层，

所以 a 为第一层网络，a 是一个一行三列矩阵。我们这样表示： 

                                                                a(1)=[a11, a12, a13]=XW(1) 

第二层 

参数要满足前面三个节点，后面一个节点，所以 W(2) 是三行一列矩阵。

                                                             

我们把每层输入乘以线上的权重 w，这样用矩阵乘法可以计算出输出 y 了。 
a= tf.matmul(X, W1) 

y= tf.matmul(a, W2) 

由于需要计算结果，就要用 with 结构实现，所有变量初始化过程、计算过程都要放到 sess.run 函数中。对于变量初始化，我们在 sess.run 中写入tf.global_variables_initializer 实现对所有变量初始化，也就是赋初值。对于计算图中的运算，我们直接把运算节点填入 sess.run 即可，比如要计算输出y，直接写 sess.run(y) 即可

在实际应用中，我们可以一次喂入一组或多组输入，让神经网络计算输出 y，可以先用 tf.placeholder 给输入占位。如果一次喂一组数据 shape 的第一维位置写 1，第二维位置看有几个输入特征；如果一次想喂多组数据，shape 的第一维位置可以写 None 表示先空着，第二维位置写有几个输入特征。这样在 feed_dict 中可以喂入若干组体积重量了。 

总结：前向传播过程的 tensorflow 描述：

1.变量初始化、计算图节点运算都要用会话（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) 

2.√用 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]]}) 

下面是例子完整的代码：

下面是是只喂一组数据：

#coding:utf-8
import tensorflow as tf   #引入模块
#利用placeholder占位，shape(None,2)表示输入数据的不确定，其中包含两个变量
x=tf.placeholder(tf.float32,shape=(1,2))
#利用random_normal生成一组正态分布的数据，标准差为1，随机种子为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)
#用会话计算结果
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]]}))

结果：

下面是喂多组数据，其中只是shape的参数以及feed_dict的参数改变了

#coding:utf-8
import tensorflow as tf   #引入模块
#利用placeholder占位，shape(1,2)表示输入一组数据，其中包含两个变量
x=tf.placeholder(tf.float32,shape=(None,2))
#利用random_normal生成一组正态分布的数据，标准差为1，随机种子为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)
#用会话计算结果
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：求前向传播计算结果与已知答案之差的平方再求平均。

                                                    

用 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) 

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

                                                         

参数更新公式是：                                                          

                                                        

其中，J(θ)为损失函数，θ为参数，α为学习率。 

②tf.train.MomentumOptimizer()在更新参数时，利用了超参数，参数更新公式是：

                                                            di= βdi-1 +g(θi-1)

                                                             θi=θi-1-αdi

其中，α为学习率,超参数为β,θ为参数，g(θi-1)为损失函数的梯度。 

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

学习率：决定每次参数更新的幅度。 

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

四：总结搭建神经网络的八股

神经网络的搭建分四步完成：准备工作、前向传播、反向传播和循环迭代。 

0.导入模块，生成模拟数据集； 
                import 
                常量定义 
                生成数据集     
1.前向传播：定义输入、参数和输出 
                 x=       y_= 
                 w1=      w2= 
                 a=       y= 
2. 反向传播：定义损失函数、反向传播方法 
                 loss= 
                 train_step= 
√3. 生成会话，训练 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列的矩阵，代表32组体积和重量，作为输入集
X=rng.rand(32,2)
#从X中取出一组值，若两者和小于1，则赋值给Y为1，若大于1则为0，
# 将其作为数据集的标签(即训练结果，正确答案)
Y=[[int(x0+x1<1)] for (x0,x1) in X]
print("X:\n",X)
print("Y:\n",Y)
#1.定义神经网络的输入、参数和输出，定义前向传播的过程
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)

#2.定义损失函数及反向传播方法
#这里用的损失函数为均方误差
loss=tf.reduce_mean(tf.square(y-y_))
#这里使用的是梯度下降反传播训练方法
train_step=tf.train.GradientDescentOptimizer(0.001).minimize(loss)
#train_step=tf.train.MomentumOptimizer(0.001,0.9).minimize(loss)
#train_step=tf.train.AdamOptimizer(0.001).minimize(loss)


#3.生成会话，训练多少轮

with tf.Session() as sess:
    init_op=tf.global_variables_initializer()
    sess.run(init_op)
    #输出当前(未经训练)的参数取值
    print("w1:\n",sess.run(w1))
    print("w2:\n",sess.run(w2))
    print("\n")

    #训练模型
    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.run(loss,feed_dict={x:X,y_:Y})
            print("After %d training step(s),loss on all data is %d",(i,total_loss))
    #训练后输出各参数取值
    print("\n")
    print("w1:\n",sess.run(w1))
    print("w2:\n",sess.run(w2))