tesorflow 学习笔记：02 搭建神经网络



 

 

一、基本概念
1 基于 Tensorflow 的 NN： 用张量表示数据，用计算图搭建神经网络，用会话执
行计算图，优化线上的权重
2 张量：张量就是多维数组（列表），用“阶”表示张量的维度。
0 阶张量称作标量，表示一个单独的数；
举例 S=123
1 阶张量称作向量，表示一个一维数组；
举例 V=[1,2,3]
2 阶张量称作矩阵，表示一个二维数组，它可以有 i 行 j 列个元素，每个元素可
以用行号和列号共同索引到；
举例 m=[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
3 数据类型： Tensorflow 的数据类型有 tf.float32、 tf.int32 等。
eg:
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 #实现 a 加 b 的加法
print result #打印出结果

 

结果：Tensor(“add:0”, shape=(2, ), dtype=float32)
是一个名称为 add:0 的张量，shape=(2,)表示一维数组长度为 2，dtype=float32 表示数据类型为浮点型。
4 计算图（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 是一个张量，只搭建承载计算过程的计算图，并没有运算
5 会话（Session）： 执行计算图中的节点运算。
用 with 结构实现，语法如下：
with tf.Session() as sess:
print sess.run(y)
eg:
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)
[[11.]]
运行 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 表示生成直接给定值的数组
eg:
(1).w=tf.Variable(tf.random_normal([2,3],stddev=2, mean=0, seed=1))
生成正态分布随机数，形状两行三列， 标准差是 2， 均值是 0， 随机种子是 1
(2)w=tf.Variable(tf.Truncated_normal([2,3],stddev=2, mean=0, seed=1))
去掉偏离过大的正态分布， 也就是如果随机出来的数据偏离平均值超过两个
标准差，这个数据将重新生成
(3)w=random_uniform(shape=7,minval=0,maxval=1,dtype=tf.int32， seed=1)
从一个均匀分布[minval maxval)中随机采样，注意定义域是左闭右开
(4)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 结构，从输入到输出（先搭建计算图，再用会话执行）
（NN 前向传播算法 计算输出）
(3) 大量特征数据喂给 NN，迭代优化 NN 参数
（NN 反向传播算法 优化参数训练模型）
(4) 使用训练好的模型预测和分类
2 前向传播
前向传播就是搭建模型的计算过程， 让模型具有推理能力， 可以针对一组输入
给出相应的输出
eg:
假如生产一批零件， 体积为 x1， 重量为 x2， 体积和重量就是我们选择的特征，
把它们喂入神经网络， 当体积和重量这组数据走过神经网络后会得到一个输出。
假如输入的特征值是：体积 0.7 重量 0.5

 

X 是输入为 1X2 矩阵,W 前节点编号，后节点编号(层数) 为待优化的参数
由搭建的神经网络可得， 隐藏层节点 a11=x1* w11+x2*w21=0.14+0.15=0.29， 同
理算得节点 a12=0.32， a13=0.38，最终计算得到输出层 Y=-0.015， 这便实现了
前向传播过程。
推导：
第一层
用 x 表示输入， 是一个 1 行 2 列矩阵， 表示一次输入一组特征， 这组特征包含了
体积和重量两个元素。
对于第一层的 w,前面有两个节点，后面有三个节点,w 应该是个两行三列矩阵，
这样表示：

 

神经网络共有几层（或当前是第几层网络）都是指的计算层， 输入不是计算层，
所以 a 为第一层网络， a 是一个一行三列矩阵:
a(1)=[a11, a12, a13]=XW(1)
第二层
参数要满足前面三个节点， 后面一个节点， 所以 W(2) 是三行一列矩阵。
这样表示：

 

把每层输入乘以线上的权重 w，这样用矩阵乘法可以计算出输出 y 了。
a= tf.matmul(X, W1)
y= tf.matmul(a, W2)
实现：
前向传播过程的 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]]})
eg:
①用 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]]})
3 反向传播
训练模型参数，在所有参数上用梯度下降，使 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()在更新参数时，利用了超参数，参数更新公式
是

 

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

 

4搭建步骤：
最后梳理出神经网络的搭建课分四步完成：准备工作、前向传播、反向传播和循环迭代。
0.导入模块，生成模拟数据集；
import
常量定义
生成数据集
(1).前向传播：定义输入、参数和输出
x= y_=
w1= w2=
a= y=
(2). 反向传播：定义损失函数、反向传播方法
loss=
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:)
eg:
随机产生 32 组生产出的零件的体积和重量，训练 3000 轮，每 500 轮输出一次损
失函数。下面我们通过源代码进一步理解神经网络的实现过程：

 

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#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)
#如果合小于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)

 

#定义损失函数、反向传播方法
learning_rate=0.001
loss = tf.reduce_mean(tf.square(y-y_))
train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
#train_step=tf.train.MomentumOptimizer(learning_rate, 0.9).minimize(loss)
#train_step=tf.train.AdamOptimizer(learning_rate).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 steps,loss 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]]

 

After 0 training steps,loss on all data is 5.13118
After 500 training steps,loss on all data is 0.429111
After 1000 training steps,loss on all data is 0.409789
After 1500 training steps,loss on all data is 0.399923
After 2000 training steps,loss on all data is 0.394146
After 2500 training steps,loss on all data is 0.390597

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