深度学习——神经网络

1、基本概念

基于Tensorflow的NN： 用张量表示数据，用计算图搭建神经网络，用会话执行计算图，优化线上的权重(参数)，得到模型。
张量： 张量就是多维数组（列表），用“阶”表示张量的维度。
0阶张量称为标量，表示一个单独的数：S=1；
1阶张量称为向量，表示一个一维数组：V=[1,2,3]；
2阶张量称为矩阵，表示一个二维数组，它可以有i行j列个元素，每个元素可以用行号和列好共同索引到：m=[[1,2,3],[4,5,6],[7,8,9]]；
判断张量是几阶的，就通过张量右边的方括号数，0个是0阶，n个是n阶，张量可以表示0阶到n阶数组(列表)；
数据类型： 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
print(result)

输出结果：

意思是result是一个名称为add:0的张量，shape=(2, )表示一维数组长度为2，dtype=float32表示数据类型为浮点型。
计算图：搭建神经网络的计算过程，是承载一个或多个计算节点的一张图，只搭建网络，不运算。如果想要得到运算结果就要用到“会话Session()”了。
会话(Session)：执行计算图中的节点运算。
用with结构实现，语法如下：

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

对于之前的计算图，计算结果如下：

import tensorflow as tf
x = tf.constant([[1.0, 2.0]])
w = tf.constant([[3.0], [4.0]])
y = tf.matmul(x, w)
print(y)
with tf.Session() as sess:
    print(sess.run(y))

输出结果：

2、神经网络的参数

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

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

举例：
① w=tf.Variable(tf.random_normal([2,3],stddev=2, mean=0, seed=1))，表示生成正态分布随机数，形状两行三列，标准差是 2，均值是 0，随机种子是 1。
② w=tf.Variable(tf.Truncated_normal([2,3],stddev=2, mean=0, seed=1))，表示去掉偏离过大的正态分布，也就是如果随机出来的数据偏离平均值超过两个标准差，这个数据将重新生成。
③ w=random_uniform(shape=7,minval=0,maxval=1,dtype=tf.int32，seed=1),表示从一个均匀分布[minval maxval)中随机采样，注意定义域是左闭右开，即包含 minval，不包含 maxval。

④ 除了生成随机数， 还可以生成常量。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、如果没有特殊哟啊求标准差、均值、随机种子是可以不写的。

3、神经网络的搭建

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

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 是一个一行三列矩阵。
表示为：

第二层 ：
参数要满足前面三个节点，后面一个节点，所以 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描述：
变量初始化、计算图节点运算都要用会话(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中喂入一组数据)的情况

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)

# 用会话计算结果
config = tf.ConfigProto(allow_soft_placement=True)
# 多占gpu资源的70%
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.7)
# 开始不会给tensorflow全部gpu资源 而是按需增加
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
# 如果使用的是CPU，则以上六行不用写（包括注释）
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    a = sess.run(y, feed_dict={x: [[0.7, 0.5]]})
    print(a)

输出结果：

②用placeholder实现输入定义(sess.run中喂入多组数据)的情况

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')
    a = sess.run(y, feed_dict={x:[[0.7,0.5], [0.2,0.3],[0.3,0.4], [0.4,0.5]]})
    print(a)

输出结果：

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) 

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

参数更新公式是

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

其中，?为学习率，超参数为?，?为参数，?(??−1)为损失函数的梯度。
③tf.train.AdamOptimizer()是利用自适应学习率的优化算法，Adam 算法和随机梯度下降算法不同。随机梯度下降算法保持单一的学习率更新所有的参数，学习率在训练过程中并不会改变。而 Adam 算法通过计算梯度的一阶矩估计和二阶矩估计而为不同的参数设计独立的自适应性学习率。 **
学习率：决定每次参数更新的幅度。
优化器中都需要一个叫做学习率的参数，使用时，如果学习率选择过大会出现震荡不收敛的情况，如果学习率选择过小，会出现收敛速度慢的情况。我们可以选个比较小的值填入，比如 0.01、0.001。
反向传播参数更新推导过程
符号说明：
??表示第l层隐藏层和输出层的输入值；
??表示第l层隐藏层和输出层的输出值；

f(z)表示激活函数；
最后的输出层为第 L 层。
推导过程：

6、搭建神经网络的八股

神经网络的搭建分四部分完成：准备工作、前向传播、反向传播和循环迭代。
1、导入模块，生成模拟数据集；
2、前向传播：定义输入、参数和输出
3、反向传播：定义损失函数、反向传播方法
4、生成会话，训练STEPS轮
举例：
随机产生32组生产出的零件的体积和重量，训练3000轮，每500轮输出一次损失函数。下面通过源代码进一步理解神经网络的实现过程：

# 导入模块，生成数据集。
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这个32行2列的矩阵中取出一行，判断如果和小于1给Y赋值1 如果和不小于1给Y赋值0
# 作为输入数据集的标签（正确答案）
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)

# 生成会话，训练STEPS轮
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 %g " %(i, total_loss))

    # 输出训练后的参数取值。
    print("\n")
    print("w1:\n", sess.run(w1))
    print("w2:\n", sess.run(w2))

总共训练3000轮，每轮从X的数据集和Y的标签中抽取相对应的从start开始到end结束个特征值和标签，喂入神经网络，用sess.run求出loss，每500轮打印一次loss值。经过3000轮后，打印出训练好的参数w1,w2。
输出结果：
训练前参数：

训练后：

如此即可实现神经网络的搭建。