【TensorFlow1.X】系列学习笔记【入门二】

文章目录

【TensorFlow1.X】系列学习笔记【入门二】
前言
神经网络的参数
神经网络的搭建
- 前向传播
- 反向传播
总结

前言

学习了张量、计算图、会话等基础知识，下一步就是实现神经网络的搭建了，本篇博文将讲解搭建神经网络的过程，并简练总结搭建八股。【参考】

神经网络的参数

神经网络的参数是指在神经网络模型中需要学习的可调整值。这些参数用于调整模型的行为，定了神经网络的行为和性能，使其能够更好地拟合训练数据和进行预测。
在典型的神经网络中，参数主要存在于两个部分，用变量表示：

权重(Weights)：
权重是连接神经网络中不同层的神经元之间的参数。每个连接都有一个关联的权重，用于调整信息在网络中的传递。权重决定了每个输入对于特定神经元的重要性。在训练过程中，神经网络通过优化算法来调整权重，以最小化预测输出与实际输出之间的差距。
偏置(Biases)：
偏置是神经元的可调整参数，用于调整神经元的激活阈值。每个神经元都有一个关联的偏置值，它在计算神经元的输出时被加到加权输入上。偏置允许神经元对不同的输入模式做出不同的响应。

这些权重和偏置参数是在训练过程中学习的，通过反向传播算法和优化方法(如梯度下降)来更新,训练过程旨在最小化损失函数，以使神经网络能够更准确地进行预测。

在 TensorFlow 1.x 中，可以使用以下方法来初始化神经网络的参数：

import tensorflow as tf
w = tf.Variable(tf.random_normal([2,3], stddev=2, mean=0, seed=1))
# => <tf.Variable 'Variable:0' shape=(2, 3) dtype=float32_ref>
w = tf.Variable(tf.truncated_normal([2,3], stddev=2, mean=0, seed=1))
# => <tf.Variable 'Variable_1:0' shape=(2, 3) dtype=float32_ref>
w = tf.random_uniform([2,3], minval=0, maxval=1, dtype=tf.int32, seed=1)
# => Tensor("random_uniform:0", shape=(2, 3), dtype=int32)
w = tf.zeros([3,2], tf.int32)
# => Tensor("zeros:0", shape=(3, 2), dtype=int32)
w = tf.ones([3,2], tf.int32)
# => Tensor("ones:0", shape=(3, 2), dtype=int32)
w = tf.fill([3,2], 6)
# => Tensor("Fill:0", shape=(3, 2), dtype=int32)
w = tf.constant([3,2])
# => Tensor("Const:0", shape=(2,), dtype=int32)

注意：①随机种子如果去掉每次生成的随机数将不一致，②如果没有特殊要求标准差、均值、随机种子是可以不写的。

神经网络的搭建

神经网络模型的实现过程：

准备数据集：作为神经网络模型的训练\测试数据
前向传播：搭建模型结构，先搭建计算图，再用会话执行，计算输出
反向传播：模型学习到大量特征数据，迭代优化模型参数
完成训练，验证模型精度

由此可见，基于深度学主要分为两个过程，即训练过程和使用过程。训练过程是第一步、第二步、第三步的循环迭代，使用过程是第四步，一旦参数优化完成就可以固定这些参数，实现特定应用了。当前很多实际应用中，会优先使用现有的成熟可靠的模型结构，用个人的数据集训练模型，判断是否能对个人数据集作出正确响应，再适当更改网络结构，反复迭代，让机器自动训练参数找出最优结构和参数，以固定专用模型。

前向传播

前向传播就是搭建模型的计算过程，让模型具有推理能力，可以针对一组输入给出相应的输出。
举个案例，假如快递运输费用，体积为 x1，重量为 x2，体积和重量就是我们选择的特征，把它们输入到神经网络，当体积和重量这组数据走过神经网络后会得到一个输出，即费用。
假如输入的特征值是：体积 0.7 重量 0.5：
【TensorFlow1.X】系列学习笔记【入门二】-LMLPHP
由图可知，隐藏层节点 a11=x1w11+x2w21=0.14+0.15=0.29，同理算得节点 a12=0.32，a13=0.38，最终计算得到输出层 Y=-0.015，这便实现了前向传播过程。

前向传播过程的 tensorflow 描述：

输入层： X X X是 n × 2 {\rm{n}} \times 2 n×2的矩阵，表示一次输入 n n n组特征，这组特征包含了体积和重量两个元素。
```
x = tf.placeholder(tf.float32, shape=(None, 2))
```
隐藏层： W ( F r o n t N o d e N u m b e r , R e a r N o d e N u m b e r ) ( l a y e r s ) W_{(F{\rm{rontNodeNumber}},R{\rm{earNodeNumber)}}}^{({\rm{layers}})} W(FrontNodeNumber,RearNodeNumber)(layers)是待优化的参数，对于第一计算层的 w ( 1 ) {w^{({\rm{1}})}} w(1)前面有两个节点，后面有三个节点， w ( 1 ) {w^{({\rm{1}})}} w(1)是个两行三列矩阵：
W ( 1 ) = [ w ( 1 , 1 ) ( 1 ) w ( 1 , 2 ) ( 1 ) w ( 1 , 3 ) ( 1 ) w ( 2 , 1 ) ( 1 ) w ( 2 , 2 ) ( 1 ) w ( 2 , 3 ) ( 1 ) ] {W^{(1)}} = \left[ {\begin{array}{cc} {w_{(1,1{\rm{)}}}^{(1)}}&{w_{(1,2{\rm{)}}}^{(1)}}&{w_{(1,3{\rm{)}}}^{(1)}}\\ {w_{(2,1{\rm{)}}}^{(1)}}&{w_{(2,2{\rm{)}}}^{(1)}}&{w_{(2,3{\rm{)}}}^{(1)}} \end{array}} \right] W(1)=[w(1,1)(1)w(2,1)(1)w(1,2)(1)w(2,2)(1)w(1,3)(1)w(2,3)(1)]，即 a ( 1 ) = [ a 11 , a 12 , a 13 ] = X W ( 1 ) {a^{\left( 1 \right)}} = \left[ {{a_{11}},{\rm{ }}{a_{12}},{\rm{ }}{a_{13}}} \right] = X{W^{(1)}} a(1)=[a11,a12,a13]=XW(1)；
对于第二计算层的 w ( 2 ) {w^{({\rm{2}})}} w(2)前面有三个节点，后面有1个节点， w ( 2 ) {w^{({\rm{2}})}} w(2)是个三行一列矩阵：
W ( 2 ) = [ w ( 1 , 1 ) ( 2 ) w ( 2 , 1 ) ( 2 ) w ( 3 , 1 ) ( 2 ) ] {W^{(2)}} = \left[ {\begin{array}{cc} {w_{(1,1{\rm{)}}}^{(2)}}\\ {w_{(2,1{\rm{)}}}^{(2)}}\\ {w_{(3,1{\rm{)}}}^{(2)}} \end{array}} \right] W(2)= w(1,1)(2)w(2,1)(2)w(3,1)(2) ,即 y = a ( 1 ) W ( 1 ) {y} = {a^{\left( 1 \right)}}{W^{(1)}} y=a(1)W(1)。
```
a = tf.matmul(x, w1)
y = tf.matmul(a, w2)
```

神经网络共有几层(或当前是第几层网络)都是指的计算层，所有的计算层统称为隐藏层，而隐藏层的计算层计算出结果通常称做中间特征，不要错把这些当作隐藏层。
【TensorFlow1.X】系列学习笔记【入门二】-LMLPHP
完整的前向传播代码。

import tensorflow as tf

# 定义输入和参数
# 用tf.placeholder定义输入，在sess.run函数中要用feed_dict指定输入
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)

# 汇总所有待优化变量
init_op = tf.global_variables_initializer()

# 调用会话计算结果
# 变量初始化、计算图节点运算都要用会话(with结构)实现
with tf.Session() as sess:
    # 在sess.run函数中变量初始化
    sess.run(init_op)
    # 在sess.run函数中计算图节点运算
    print("the result of tf3_5.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]]}))
    print("w1:\n", sess.run(w1))
    print("w2:\n", sess.run(w2))

反向传播

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

损失函数(loss)：计算得到的预测值 y 与已知真实值 y_的误差。均方误差 MSE
是比较常用的方法之一，它计算前向传播求出的预测值与已知真实值之差的平方再求平均： M S E ( y _ , y ) = ∑ i = 1 n ( y − y _ ) 2 n MSE(y\_,y) = \frac{{\sum\nolimits_{i = 1}^n {{{(y - y\_)}^2}} }}{n} MSE(y_,y)=n∑i=1n(y−y_)2
```
loss_mse = tf.reduce_mean(tf.square(y-y_)) 
```

反向传播优化方法：以减小 loss 值为优化目标，常见的三种有随机梯度下降、momentum 优化器、adam优化器等优化方法。

# 学习率(learning_rate):决定每次参数更新的幅度。
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)

完整的反向传播代码。

# 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*0.5+x1*0.8)] for (x0, x1) in X]

# 定义神经网络的输入、参数和输出,定义前向传播过程。
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_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)

# 生成会话，训练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))

    # 训练模型
    # 悬链次数
    STEPS = 3000
    for i in range(STEPS):
    	# 随机选取一组batchsize为8的数据段
        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("w1:\n", sess.run(w1))
    print("w2:\n", sess.run(w2))

总结

梳理出神经网络搭建的八股，搭建过程分四步完成：准备工作、前向传播、反向传播和循环迭代：

导入模块，生成模拟数据集；
前向传播：定义输入、参数和输出；
反向传播：定义损失函数、反向传播方法；
生成会话，训练n轮。

牙牙要健康