神经网络搭建“八股”

最新推荐文章于 2024-05-23 03:17:01 发布

dl_None

最新推荐文章于 2024-05-23 03:17:01 发布

阅读量2.9k

点赞数 3

分类专栏： Tensorflow笔记

本文链接：https://blog.csdn.net/Coding_1995/article/details/81450577

版权

Tensorflow笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、基本概念

1.张量

张量就是多维数组，“阶”表示张量的维度

0阶张量是一个单独的数，称为标量，如：S = 123

1阶张量是一个一维数组，称为向量，如：V = [1, 2, 3]

2阶张量是一个二维数组，称为矩阵，如：M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

.......

n阶张量，如：t = [[[[·····]]]···]]] ，右边有n个方括号即为n阶张量

2.数据类型

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

3.计算图

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

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)                  #实现 x w 矩阵乘法
print y                              #打印出结果

执行上述代码后可以得到如下结果，结果显示y是一个张量，没有实际运算，只是搭建承载计算过程的
计算图，如果要得到运算结果，需要使用“会话（Session）”。

Tensor(“matmul:0”, shape(1,1), dtype=float32)

3.会话（Session）

执行计算图中的节点运算，使用with结构实现，如下：

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)                    #执行会话并打印出执行后的结果

执行上述代码后可以得到如下结果，运行Session()会话前只打印出y是个张量的提示，运行Session()
会话后打印出了 y 的结果 1.0 * 3.0 + 2.0 * 4.0 = 11.0。

Tensor(“matmul:0”, shape(1,1), dtype=float32)
[[11.]]

二、神经网络的参数

神经网络的参数是指神经元线上的权重w，用变量表示，一般会先随机生成这些参数。生成参数的方法如下：

函数	作用	举例
tf.random_normal( )	生成正态分布随机数	w=tf.Variable(tf.random_normal([2,3],stddev=2, mean=0, seed=1))	表示生成形状两行三列矩阵，标准差是 2，均值是 0，随机种子是 1
tf.truncated_normal()	生成去掉过大偏离点的正态分布随机数	w=tf.Variable(tf.Truncated_normal([2,3],stddev=2, mean=0, seed=1))	表示去掉偏离过大的正态分布，也就是如果随机出来的数据偏离平均值超过两个标准差，这个数据将重新生成
tf.random_uniform()	生成均匀分布随机数	w=random_uniform(shape=7,minval=0,maxval=1,dtype=tf.int32，seed=1)	表示从一个均匀分布[minval maxval)中随机采样，注意定义域是左闭右开
tf.zeros	表示生成全0数组	tf.zeros([3,2],int32)	表示生成[[0,0],[0,0],[0,0]]
tf.ones	表示生成全1数组	tf.ones([3,2],int32)	表示生成[[1,1],[1,1],[1,1]
tf.fill	表示生成全定值数组	tf.fill([3,2],6)	表示生成[[6,6],[6,6],[6,6]]
tf.constant	表示生成直接给定值的数组	tf.constant([3,2,1])	表示生成[3,2,1]

三、神经网络的搭建

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

准备数据集，提取特征，作为输入喂给神经网络
搭建 N NN 结构，从输入到输出（先搭建计算图，再用会话执行）

NN 前向传播算法 -----> 计算输出

大量特征数据喂给 NN ，迭代优化 N NN

NN 反向传播算法 -----> 优化参数训练模型

使用训练好的模型预测和分类

四、前向传播

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

1. 举例

假如生产一批零件，体积为 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，这便实现了前向传播过程。

2. 推导

第一层：

X是输入为1 × 2的矩阵

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

$W_{m,n}^{l}$ 为待优化参数

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

$W^{^{(1)}}=\begin{bmatrix} W_{1,1}^{(1)} & W_{1,2}^{(1)}& W_{1,3}^{(1)}\\ W_{2,1}^{(1)}& W_{2,2}^{(1)}&W_{2,3}^{(1)} \end{bmatrix}$

神经网络的层数知道是计算层，输入不是计算层，所以a为第一层网络，a是一个一行三列矩阵。

$a(1)=[a_{11}, a_{12}, a_{13}]=XW^{(1)}$

第二层：

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

$W^{(2)}=\begin{bmatrix} W_{1,1}^{(2)}\\ W_{2,1}^{(2)}\\ W_{3,1}^{(2)} \end{bmatrix}$

计算：

用每层输入乘以线上的权重W就可以计算出输出 y 。

3. 前向传播过程的tensorflow描述

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

# 两层简单的神经网络
import tensorflow as tf

# 定义输入和参数
# 用placeholder实现输入定义（sess.run中喂入一组数据）
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 is :', sess.run(y, feed_dict={x: [[0.7, 0.5]]}))

执行上述代码后可以得到如下结果：

y is : [[3.0904665]]

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

# 两层简单的神经网络
import tensorflow as tf

# 定义输入和参数
# 用placeholder定义输入（sess.run喂多组数据）
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:
    int_op = tf.global_variables_initializer()
    sess.run(int_op)
    print('the result is: ', sess.run(y, feed_dict={x : [[0.7, 0.5],
                                                        [0.2, 0.3],
                                                        [0.3, 0.4],
                                                        [0.4, 0.5]]}))
    print('w1: ', sess.run(w1))
    print('w2: ', sess.run(w2))

执行上述代码后可以得到如下结果：

the result is:  
[[3.0904665]
 [1.2236414]
 [1.7270732]
 [2.2305048]]
w1:  [[-0.8113182   1.4845988   0.06532937]
 [-2.4427042   0.0992484   0.5912243 ]]
w2:  [[-0.8113182 ]
 [ 1.4845988 ]
 [ 0.06532937]]

五、反向传播

1. 反向传播

训练模型参数，在所有参数上用梯度下降，使神经网络模型在训练数据上的损失函数最小。

2. 损失函数

计算得到的预测值y与已知答案y_的差距。

3. 均方误差ESE

均方误差 MSE 是比较常用的方法之一，计算方法如下：

4. 反向传播训练方法

以减小loss值为优化目标，有梯度下降、momentum优化器、adam优化器等优化方法。

5. 学习率

学习率决定每次参数更新的幅度。如果学习率选择过大会出现震荡不收敛的情况，如果学习率选择过小，会出现收敛速度慢的情况。我们可以选个比较小的值填入，比如 0.01、0.001。

六、搭建神经网络的八股

1. 步骤

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

2. 具体实现

随机产生32组生产出的零件的体积和重量，训练5000 轮，每500 轮输出一次损失函数。源代码如下：

# 0导入模块，生成模拟数据集
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: ', X)
print('Y', 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.AdadeltaOptimizer(0.001).minimize(loss)

# 3生成会话，训练step轮
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))
    print('\n')

    # 训练模型
    STEPS = 5000
    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: ', sess.run(w1))
    print('w2: ', 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.8113182   1.4845988   0.06532937]
 [-2.4427042   0.0992484   0.5912243 ]]
w2:  [[-0.8113182 ]
 [ 1.4845988 ]
 [ 0.06532937]]


After 0 training step(s), loss on all data is 5.13118
After 500 training step(s), loss on all data is 0.429111
After 1000 training step(s), loss on all data is 0.409789
After 1500 training step(s), loss on all data is 0.399923
After 2000 training step(s), loss on all data is 0.394146
After 2500 training step(s), loss on all data is 0.390597
After 3000 training step(s), loss on all data is 0.388336
After 3500 training step(s), loss on all data is 0.386855
After 4000 training step(s), loss on all data is 0.385863
After 4500 training step(s), loss on all data is 0.385186


w1:  [[-0.69597054  0.85992473  0.09337731]
 [-2.3418374  -0.12466972  0.5866561 ]]
w2:  [[-0.07531643]
 [ 0.8627887 ]
 [-0.05937824]]

中国大学MOOC《人工智能实践：Tensorflow笔记》笔记

dl_None

关注

3
点赞
踩
23

收藏

觉得还不错? 一键收藏
4
评论
神经网络搭建“八股”

一、基本概念 1.张量张量就是多维数组，“阶”表示张量的维度0阶张量是一个单独的数，称为标量，如：S = 1231阶张量是一个一维数组，称为向量，如：V = [1, 2, 3]2阶张量是一个二维数组，称为矩阵，如：M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]].......n阶张量，如：t = [[[[·····]]]···]]] ，...
复制链接

扫一扫