目录
搭建神经网络（Tensorflow）
用张量(tensor)表示数据，用计算图搭建神经网络，用会话(session)执行计算图，优化线上的权重（参数），得到模型
张量（tensor）：
多维数组（列表）
阶：张量的维数
0维：标量
1维：向量 [1,2,3,4,5]
2维：矩阵 m=[[1,2],[3,4],[5,6]]
n维：张量 t=[[[… 看方括号有几个，就是几阶
import tensorflow as tf
a=tf.constant([1.0,2.0])
b=tf.constant([3.0,4.0])
a+b
Out[5]: <tf.Tensor 'add:0' shape=(2,) dtype=float32>
constant定义常数
‘add:0’ :为该张量的名称
shape: 维度 (2,) 该张量只有一个维度，第一个维度长度为2。
这段代码相当于计算图，只体现运算过程，不计算运算结果
计算图：
搭建神经网络的计算过程，只搭建，不运算
比如一个神经元的计算，w*x 神经元计算公式
a=tf.constant([[1.0,2.0]])
x=tf.constant([[1.0,2.0]])# 一行两列 1x2
w=tf.constant([[3.0],[4.0]])#两行一列 2x1
y=tf.matmul(x,w) #
y # 1x1
Out[10]: <tf.Tensor 'MatMul:0' shape=(1, 1) dtype=float32>
tf.matmul(x,w):张量相乘
只能得到结果为1x1的张量，但是没有得到结果，要想得到结果则需要会话session.
会话（Session）:
执行计算图中节点运算，用session才能得到计算结果
Out[10]: <tf.Tensor 'MatMul:0' shape=(1, 1) dtype=float32>
with tf.Session()as sess:
print(sess.run(y))
[[11.]]
sess.run()由fetches和feed_dict组成
sess.run(fetches，feed_dict)
sess.run是让fetches节点动起来，告诉tensorflow，想要此节点的输出。
fetches 可以是list或者tensor向量
feed_dict给使用placeholder创建出来的tensor赋值，用来替换原图中的某个tensor，feed 只在调用它的方法内有效, 方法结束, feed 就会消失.
参数：
线上的权重W，用变量表示，随机给初值
例如
#生成随机数
w=tf.Variable(tf.random_normal([2,3],stddev=2,mean=0,seed=1)
# 正态分布 产生2x3矩阵 （标准差为2 均值为0 随即种子）可省略
#与tf.random_normal 可用其他代替
tf.truncated_normal() #去掉过大偏离点的正态分布
tf.random_uniform() #平均分布
#其他生成常量数组
tf.zeros([3,2],int 32) #全0 3x2
tf.ones([3,2],int 32) #全1 3x2
tf.fill([3,2],6) #全定值 3x2
tf.constant([3,2,1]) #直接给值 [3,2,1]
神经网络实现过程
- 准备数据集，提取特征，作为输入给神经网络
- 搭建神经网络结构从输入到输出（先搭建计算图，再用会话执行）
前向传播-----> 计算输出 - 大量特征数据喂给神经网络，迭代优化参数
反向传播------>优化参数训练模型（将每一次输出与标准答案的差传回神经网络，调整参数） - 使用训练好的模型预测和分类
训练过程（1，2，3循环迭代）+使用过程（4）
前向传播：
搭建模型，实现推理
…待补充
变量初始化计算节点，都要用会话实现
with tf.Session() as sess:
sess.run()
变量初始化
init_op=tf.gloal_variables_initializer()
sess.run(init_op)
节点计算
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]]})
# shape(1,2) 第一维位置是输入的个数，第二维位置是特征的个数
#将x喂入神经网络，求得y
多组数据：
x = tf.placeholder(tf.float32, shape=(None, 2)) #第一维位置None，先空着
sess.run(y, feed_dict={x: [[0.1,0.2],[0.2,0.3],[0.3,0.4],[0.4,0.5]]})
前向传播部分代码
import tensorflow as tf
'''
用 placeholder 实现输入定义（sess.run 中喂入多组数据）的情况
第一组喂体积 0.7、重量 0.5，第二组喂体积 0.2、重量 0.3，第三组喂体积 0.3 、
重量 0.4，第四组喂体积 0.4、重量 0.5.
'''
#定义输入和参数
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 tf_forward.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]]}))
#feed_dict 即输入x
反向传播
反向传播：
训练模型参数，在所有参数上用梯度下降，使神经网络 模型在训练数据
上的损失函数最小。
损失函数（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)
学习率(learning_rate)：决定每次参数更新的幅度。
优化器中都需要一个叫做学习率的参数，使用时，如果学习率选择过大会出现震荡不收敛的情况，如果学习率选择过小，会出现收敛速度慢的情况。我们可以选个比较小的值填入，比如 0.01,0.001
搭建神经网络
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)
#Y为生成训练集对应的标签（正确答案）
#从X这个32x2的矩阵，取出一行，如果和小于1，则Y赋值为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))#神经网络输入的特征,每一组2个特征
y_=tf.placeholder(tf.float32,shape=(None,1))#标准答案，每个标签一个元素，合格或不合格
#参数要和输入输出的特征数相匹配，输入2个特征，输出1个特征
# w1是2行，对应x， w2 是1列， 对应y 2......1 ，隐藏层3个神经元，随机生成w1,w2
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, momentum).minimize(loss)
#train_step=tf.train.AdamOptimizer(learning_rate).minimize(loss)
#3.生成会话，训练STEPS轮,在with结构中完成迭代
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()
# 训练模型
STEPS = 3000 # 训练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]}) # x,y_(正确答案)为前向传播输入，执行训练过程
if i % 500 == 0: # 每500轮打印一次loss值
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() # 输出优化后的w1,w2
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.8113182 1.4845988 0.06532937]
[-2.4427042 0.0992484 0.5912243 ]]
w2:
[[-0.8113182 ]
[ 1.4845988 ]
[ 0.06532937]]
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.14641264 0.5882305 ]]
w2:
[[-0.06024266]
[ 0.91956186]
[-0.06820708]]
总结
神经网络的搭建分四步完成：准备工作、
前向传播、反向传播和循环迭代
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:)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
