Tensorflow笔记——搭建神经网络

一、基本概念

基于Tensorflow的NN：

1.            用张量表示数据
2.            用计算图搭建神经网络
3.            用会话执行计算图
4.            优化线上的权重（参数），得到模型

 

1.张量：就是多维数组（列表），用“阶”表示张量的维度。

  0阶张量称作标量，表示一个单独的数： 比如 S=123

  1阶张量称作向量，表示一维数组： 比如 V=[1,2,3]

  2阶张量称作矩阵，表示二维数组： 比如 m=[ [1, 2, 3], [4, 5, 6], [7, 8, 9] ]

判断张量是几阶的，就通过张量右边的方括号数，0个是0阶，n个是n阶，张量可以表示0阶到n阶数组（列表）；

比如：t=[ [ [ ...] ] ] 为3阶

2.数据类型：Tensorflow的数据类型有tf.float32、tf.int32等。

  2.1加法模块

import tensorflow as tf

a = tf.constant([1.0, 2.0])
b = tf.constant([3.0, 4.0])
result = a + b
print(result)

结果：Tensor("add:0", shape=(2,), dtype=float32)

意思：名称：add:0 ， shape=(2,)为一维数组长度为2（也就是2行1列。shape=(2，2)表示2行2列），dtype=float32表示数据类型为浮点型

3.计算图：搭建神经网络的计算过程，是承载一个或多个计算节点的一张图，只搭建网络，不运算。

  神经网络的基本模型是神经元，神经元的基本模型其实就是数学中的乘、加运算。

  搭建如下的计算图：

  其中输入：X1、X2 ，W1、W2为权值，输出：y = X1*W1 + X2*W2。

  实现上述计算图：

import tensorflow as tf

x = tf.constant([[1.0, 2.0]])  # 定义一个2阶张量,表示1行2列
w = tf.constant([[3.0], [4.0]])  # 定义一个2阶张量,表示2行1列
y = tf.matmul(x, w)  # 实现xw矩阵乘法
print(y)

  结果：Tensor("MatMul:0", shape=(1, 1), dtype=float32) 显然是一个1行1列的张量

  但是由于只搭建承载计算过程的计算图，并没有运算，如果我们想得到运算结果就要用到“会话Session()”了。

4.会话（Session）：执行计算图中的节点运算

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

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

结果：[[11.]]

可以看到，运行会话之前只打印出y是张量，运行会话之后会打印出运算结果。

 二、神经网络

•   神经网络的参数
•   神经网络的搭建
•   前向传播
•   反向传播
•   搭建神经网络的八股

 1.神经网络的参数：指神经元线上的权重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，均值为1，随机种子为1.
w = tf.Variable(tf.truncated_normal([2, 3], stddev=2, mean=0, seed=1))	表示生成去掉过大偏离点的正态分布随机数，也就是如果随机出来的数据偏离平均值超过2个标准差，这个数据将重新生成
w = tf.Variable(tf.random_uniform(shape=7, minval=0, maxval=1, dtype=tf.int32, seed=1))	表示从一个均匀分布[minval,maxval]中随机采样，注意定义域是左闭右开，即包含minval, 不包含maxval.
除了生成随机数，还可以生成常量。 tf.zeros([3, 2], tf.int32) tf.ones([3, 2], tf.int32) tf.fill([3, 2], 6) tf.constant([3, 2, 1])	分别表示   生成[[0, 0], [0, 0], [0, 0]]   生成[[1, 1], [1, 1], [1, 1]]   生成[[6, 6], [6, 6], [6, 6]]   生成[3, 2, 1]
注意：1.随机种子如果去掉，每次生成随机数将不一致。            2.如果没有特殊要求标准差、均值、随机种子是可以不写的。

 

  2.神经网络的搭建

   了解了张量、计算图、会话和参数后，就可以开始动手搭建神经网络了。

• 准备数据集，提取特征，作为输出传送给神经网络
• 搭建NN结构，从输入到输出（先搭建计算图，再用会话执行）：NN前向传播算法——>计算输出
• 大量特征数据喂给NN，迭代优化NN参数 ：NN反向传播算法——>优化参数(权值w)训练模型
• 使用训练好的模型预测和分类

由此可见：基于神经网络的机器学习主要分为两个过程：训练过程和使用过程。

    训练过程：第一步、第二步、第三步的循环迭代。

    使用过程：第四步，一旦参数优化完成就可以固定这些参数，实现特定应用了。

  很多实际应用中，我们会先使用现有的成熟网络结构，喂给新的数据，训练相应模型，判断是否能对喂入的从未见过的新数据作出正确的响应，再适当更改网络结构，反复迭代，让机器自动训练参数找到最优结构和参数，以固定专用模型。

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

  假如生产一批零件，体积为 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]=XW1

 

•       第二层

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

      我们这样表示：

     我们把每层输入乘以线上的权重 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()

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

                             init_op = tf.global_variables_initializer()

                                         sess.run(init_op)

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

                                           sess.run(y)

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

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:", sess.run(y, feed_dict={x: [[0.7, 0.5]]}))

# 输出结果：y in tf3_3.py is: [[3.0904665]]

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

  第一组喂体积 0.7、重量 0.5，第二组喂体积 0.2、重量 0.3，第三组喂体积 0.3 、重量 0.4，第四组喂体积 0.4、重量 0.5.

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

# 输出结果：y in tf3_4.py is: [[3.0904665]  [1.2236414]  [1.7270732] [2.2305048]]

4.反向传播：训练模型参数，在所有参数上用梯度下降，使 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 + ?(??−1)

                                             ?? = ??−1 − ???

        其中，?为学习率，超参数为?，?为参数，?(??−1)为损失函数的梯度。

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

 

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

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

      

      符号说明： ??表示第l层隐藏层和输出层的输入值；

                          ??表示第l层隐藏层和输出层的输出值；

                          f(z)表示激活函数；

                         最后的输出层为第 L 层。

      推导过程：

 

5.搭建神经网络的八股

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

•  导入模块，生成模拟数据集； 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 轮输出一次损失函数。

     下面我们通过源代码进一步理解神经网络的实现过程：

      

# 导入模块，生成模拟数据集
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，否则给Y赋值0
# 作为输入数据集的标签（正确答案）
Y = [[int(x0 + x1 < 1)] for (x0, x1) in X]
print("X:", X)
print("Y:", 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:", sess.run(w1))
    print("w2:", sess.run(w2))
    
    # 训练模型
    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("w1:", sess.run(w1))
            print("w2:", sess.run(w2))

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

            这样四步就可以实现神经网络的搭建了。