博客

Tensorflow学习笔记 (基础-第一篇)—— 搭建神经网络，总结搭建八股

  • Post author:
  • Post category:其他


—- 内容

1、基本概念

2、神经网络的参数

3、神经网络的搭建

4、反向传播

5、搭建神经网络的八股

一、基本概念


计算机中的神经元模型：


· 庞大的神经网络是基于神经元结构的，是输入乘以权重，再求和，再过非线性函数的过程。


· 基于TensorFlow的NN(神经网络)：用张量表示数据，用计算图搭建神经网络，用会话执行计算图，优化线上的权重(参数)，得到想要的模型。

1、什么是张量?


张量：张量就是多维数组(列表)，用“阶”表示张量的维度。

— 0阶张量称为标量，表示一个单独的数： 

S = 123        # S 表示标量

— 1阶张量称为向量，表示一个一维数组： 

V = [1,2,3]     # V 表示一个向量

— 2阶张量称为矩阵，表示一个二维数组，可以有 i 行 j 列个元素，可用行号和列号共同索引到。 

m=[[1, 2], [4, 5], [7, 8]]        # m 表示一个矩阵


判断张量是几阶的，通过张量最左边连续的方括号数，0个为0阶，n个为n阶，张量可以表示0阶到n阶数组(列表)。
 

t=[ [ [… ] ] ]        # t为3阶张量
张量总结表
维数 阶数 名字 例子
0-D 0 标量(scalar) s=112
1-D 1 向量(vector) v=[1,2,3]
1-D 2 矩阵(matrix) m=[[1],[2],[3]]
n-D n 张量(tensor) t=[[[[[…(n个)

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

用tensorflow实现加法： 

import tensorflow as tf      # 引入模块
a = tf.constant([1.0, 2.0])  # 定义一个张量等于[1.0,2.0], tf.sonstant()表示常量
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 表示数据类型为浮点型。


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

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

有如上图简单的计算图：


x1、 x2 表示输入， w1、 w2 分别是 x1 到 y 和 x2 到 y 的权重(系数)， 其代表的运算为：y=x1*w1+x2*w2。

该计算图的代码实现为： 

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()”了。


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

一般我们使用with结构来实现，其语法为： 

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

对3中的计算图，执行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)    # Session前为张量
[[11.]]                                          # 会话后得到结果

可以看到，运行 Session()会话前只打印出 y 是个张量的提示，运行 Session()会话后打印出了y的结果

1.0*3.0 + 2.0*4.0 = 11.0。

二、神经网络的参数


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



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

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

请看下面的例子： 

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

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、神经网络的实现过程


· (1) 准备数据集，提取特征，作为输入喂入给神经网络(Neural Network, NN)


· (2) 搭建NN结构，从输入到输出(先搭建计算图，再用会话Session执行)


（NN前向传播算法 ==>  计算输出）


· (3) 大量特征数据喂给NN，迭代优化NN参数


(NN反向传播算法 ==> 优化参数，训练模型)


· (4) 使用训练好的模型预测和分类

由此可见 ，基于神经网络的机器学习主要分为两个过程，即训练练过程和使用过程。训练过程是(1)到(3)步的循环迭代；使用过程是第(4)步，一旦 参数的优化完成就可以把这些参数记录固定下来，实现特定的使用。

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

2、前向传播


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

请看下面例子：

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

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

有如上搭建的神经网络可得，隐藏层节点 a11=x1*w11+x2*w21=0.7*0.2+0.5*0.3=0.29，同理可得 a12=0.32，a13=0.38，最终计算的输出层 y=-0.015，而该过程就是实现前向传播的课程。

其推导过程：


  • 第一层：


X 是输入为1×2矩阵

用x表示输入，是一个1行2列的矩阵，表示一次输入一族特征，包含了体积和体重两个元素。



为待优化的参数

对于第一层的w前面有两个节点，后面后三个节点w应该是两行三列的矩阵：


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


所以a为第一层，这样表示：


  • 第二层


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

把每层输入乘以线上的权重 w，这样用矩阵乘法可以计算出输出 y 了。 

a = tf.matmul(X,W1)    # 得到第一层 a
y = tf.matmul(a,W2)    # 得到第二层 y

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


这里必须注意的是，对于变量，必须要执行sess.run来初始化。

在实际应用中， 我们可以一次喂入一组或多组输入， 让神经网络计算输出 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 中喂入一组数据）的情况
#第一组喂体积 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()在更新参数时，利用了超参数，参数更新公式是：

3、

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


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

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

五、搭建神经网络的八股


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


  • 0.导入模块，生成模拟数据集；
  1. import
  2. 常量定义
  3. 生成数据集

  • 1.前向传播：定义输入、参数和输出

  • 2. 反向传播：定义损失函数、反向传播方法
  1. loss= (损失)
  2. 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
#0导入模块，生成模拟数据集。
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8
SEED = 23455

#基于seed产生随机数
rdm = np.random.RandomState(SEED)
#随机数返回32行2列的矩阵 表示32组 体积和重量 作为输入数据集
X = rdm.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_)

#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_mse = tf.reduce_mean(tf.square(y-y_)) 
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss_mse)
#train_step = tf.train.MomentumOptimizer(0.001,0.9).minimize(loss_mse)
#train_step = tf.train.AdamOptimizer(0.001).minimize(loss_mse)

#3生成会话，训练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_mse, feed_dict={x: X, y_: Y_})
            print("After %d training step(s), loss_mse on all data is %g" % (i, total_loss))
    
    # 输出训练后的参数取值。
    print("\n")
    print("w1:\n", sess.run(w1))
    print("w2:\n", sess.run(w2))

打印结果： 

X:
[[ 0.83494319  0.11482951]
 [ 0.66899751  0.46594987]
 [ 0.60181666  0.58838408]
 [ 0.31836656  0.20502072]
 [ 0.87043944  0.02679395]
 [ 0.41539811  0.43938369]
 [ 0.68635684  0.24833404]
 [ 0.97315228  0.68541849]
 [ 0.03081617  0.89479913]
 [ 0.24665715  0.28584862]
 [ 0.31375667  0.47718349]
 [ 0.56689254  0.77079148]
 [ 0.7321604   0.35828963]
 [ 0.15724842  0.94294584]
 [ 0.34933722  0.84634483]
 [ 0.50304053  0.81299619]
 [ 0.23869886  0.9895604 ]
 [ 0.4636501   0.32531094]
 [ 0.36510487  0.97365522]
 [ 0.73350238  0.83833013]
 [ 0.61810158  0.12580353]
 [ 0.59274817  0.18779828]
 [ 0.87150299  0.34679501]
 [ 0.25883219  0.50002932]
 [ 0.75690948  0.83429824]
 [ 0.29316649  0.05646578]
 [ 0.10409134  0.88235166]
 [ 0.06727785  0.57784761]
 [ 0.38492705  0.48384792]
 [ 0.69234428  0.19687348]
 [ 0.42783492  0.73416985]
 [ 0.09696069  0.04883936]]
Y_:
[[1], [0], [0], [1], [1], [1], [1], [0], [1], [1], [1], [0], [0], [0], [0], [0], [0], [1], [0], [0], [1], [1], [0], [1], [0], [1], [1], [1], [1], [1], [0], [1]]
w1:
[[-0.81131822  1.48459876  0.06532937]
 [-2.4427042   0.0992484   0.59122431]]
w2:
[[-0.81131822]
 [ 1.48459876]
 [ 0.06532937]]


After 0 training step(s), loss_mse on all data is 5.13118
After 500 training step(s), loss_mse on all data is 0.429111
After 1000 training step(s), loss_mse on all data is 0.409789
After 1500 training step(s), loss_mse on all data is 0.399923
After 2000 training step(s), loss_mse on all data is 0.394146
After 2500 training step(s), loss_mse on all data is 0.390597


w1:
[[-0.70006633  0.9136318   0.08953571]
 [-2.3402493  -0.14641267  0.58823055]]
w2:
[[-0.06024267]
 [ 0.91956186]
 [-0.0682071 ]]


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


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


版权声明：本文为perfect1t原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。