1 张量
张量就是多维数组(列表),用“阶”表示张量的维度。
- 0阶张量称作标量(scalar),表示一个单独的数;举例 S=123
- 1阶张量称作向量(vector),表示一个一维数组;举例 V=[1,2,3]
- 2阶张量称作矩阵(matrix),表示一个二维数组,它可以有 i 行 j 列个元素,每个元素可
以用行号和列号共同索引到;
举例 m=[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
判断张量是几阶的,就通过张量右边的方括号数,0 个是 0 阶,n 个是 n 阶。例如 t=[ [ [... ] ] ]为 3 阶。
代码演示：
import tensorflow as tf
a=tf.constant([1.0,2.0])
b=tf.constant([3.0,4.0])
result=a+b
print result
"""
输出的结果为：
Tensor("add:0", shape=(2,), dtype=float32)
add ：节点名
shape :维度信息，括号里只有一个数“2“，表示维度是1且一个维度里有两个元素
dtpye :数据类型
另：
c=tf.constant([1.0,2.0]) #Tensor("Const_2:0", shape=(2,), dtype=float32) 是个向量，有两个元素
d=tf.constant([[1.0,2.0]]) #Tensor("Const_3:0", shape=(1, 2), dtype=float32) 1行2列矩阵
e=tf.constant([[1.0],[2.0]]) #Tensor("Const_4:0", shape=(2, 1), dtype=float32) 2行1列矩阵
"""
2 计算图
计算图(Graph):搭建神经网络的计算过程,是承载一个或多个计算节点的一张图,只搭建网络,不运算。
x1、x2 表示输入,w1、w2 分别是 x1 到 y 和 x2 到 y 的权重,y=x1w1+x2w2。
我们实现上述计算图:
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()”了。
3 会话
会话(Session):执行计算图中的节点运算。
我们用 with 结构实现,语法如下:
with tf.Session() as sess:
print sess.run(y)
【举例】
我们执行 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)
[[11.]]
我们可以看到,运行 Session()会话前只打印出 y 是个张量的提示,运行 Session()
会话后打印出了 y 的结果 1.0 * 3.0 + 2.0 * 4.0 = 11.0。
4 神经网络的参数
Tensorflow 的神经网络： 用张量表示数据，用计算图搭建神经网络，用会话执行计算图，优化线上的权重（参数），得到模型。
神经网络的参数:是指神经元线上的权重 w,用变量表示,一般会先随机生成
这些参数。
生成参数的方法是让 w 等于 tf.Variable,把生成的方式写在括号里。
神经网络中常用的生成随机数/数组的函数有:
tf.random_normal() #生成正态分布随机数
tf.truncated_normal() #生成去掉过大偏离点的正态分布随机数
tf.random_uniform() #生成均匀分布随机数
tf.zeros #表示生成全 0 数组
tf.ones #表示生成全 1 数组
tf.fill #表示生成全定值数组
tf.constant #表示生成直接给定值的数组
举例:
1 生成正态分布随机数,形状两行三列,标准差是 2,均值是 0,随机种子是 1:
w=tf.Variable(tf.random_normal([2,3],stddev=2, mean=0, seed=1))
2 去掉偏离过大的正态分布,也就是如果随机出来的数据偏离平均值超过两个
标准差,这个数据将重新生成。
w=tf.Variable(tf.Truncated_normal([2,3],stddev=2, mean=0, seed=1))
3 从一个均匀分布[minval maxval)中随机采样,注意定义域是左闭右开,即
包含 minval,不包含 maxval。
w=random_uniform(shape=7,minval=0,maxval=1,dtype=tf.int32, seed=1)
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 随机种子如果去掉每次生成的随机数将不一致。
- 2 如果没有特殊要求标准差、均值、随机种子是可以不写的。
5 神经网络的搭建
当我们知道张量、计算图、会话和参数后,我们可以讨论神经网络的实现过程了。
神经网络的实现过程:
- (1)准备数据集,提取特征,作为输入喂给神经网络(Neural Network,NN)
- (2)搭建 NN 结构,从输入到输出(先搭建计算图,再用会话执行)( NN 前向传播算法--->计算输出)
- (3)大量特征数据喂给 NN,迭代优化 NN 参数( NN 反向传播算法--->优化参数训练模型)
- (4)使用训练好的模型预测和分类
由此可见,基于神经网络的机器学习主要分为两个过程,即训练过程和使用过程。
训练过程是第一步、第二步、第三步的循环迭代,使用过程是第四步,一旦参数
优化完成就可以固定这些参数,实现特定应用了。
很多实际应用中,我们会先使用现有的成熟网络结构,喂入新的数据,训练相应
模型,判断是否能对喂入的从未见过的新数据作出正确响应,再适当更改网络结
构,反复迭代,让机器自动训练参数找出最优结构和参数,以固定专用模型。
6 前向传播
前向传播就是搭建模型的计算过程,让模型具有推理能力,可以针对一组输入
给出相应的输出。
举例
假如生产一批零件,体积为 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,这便实现了前向传播过程。
#coding:utf-8
import tensorflow as tf
#定义输入和参数
#用placeholder实现输入定义 ，sess.run中喂一组数据,数据 shape 的第一维位置写数据的组数，可以是None,第二维位置看有几个输入特征
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 "w1:\n",sess.run(w1)
print "w2:\n",sess.run(w2)
print "y in 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]]})
运行的结果：
w1:
[[-0.8113182 1.4845988 0.06532937]
[-2.4427042 0.0992484 0.5912243 ]]
w2:
[[-0.8113182 ]
[ 1.4845988 ]
[ 0.06532937]]
y in tf3_5.py is:
[[3.0904665]
[1.2236414]
[1.7270732]
[2.2305048]]
7 反向传播
反向传播:训练模型参数,在所有参数上用梯度下降,使 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)
搭建神经网络的八股
我们最后梳理出神经网络搭建的八股,神经网络的搭建课分四步完成:准备工作、
前向传播、反向传播和循环迭代。
举例：
随机产生 32 组生产出的零件的体积和重量，训练 3000 轮，每 500 轮输出一次损
失函数。下面我们通过源代码进一步理解神经网络的实现过程：
#coding:utf-8
#0导入模块，生成模拟数据集
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8 #一次喂入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:\n",X
print "Y:'n",Y
#1定义神经网络的输入、参数和输出，定义前向传播过程
x = tf.placeholder(tf.float32,shape=(None,2)) #并不知道有多少组数据，所以写None，每组有两个数据，y_类似
y_ = tf.placeholder(tf.float32,shape=(None,1))
#w1 2行3列 ，w2：3行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.AdamOptimizer(0.001).minimize(loss)
#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]})
# 没500轮打印一次loss值
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:\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:'n [[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
w1:
[[-0.7000663 0.9136318 0.08953571]
[-2.3402493 -0.14641267 0.58823055]]
w2:
[[-0.06024267]
[ 0.91956186]
[-0.0682071 ]]
【注】：本文为MOOC网《 人工智能实践：Tensorflow笔记》学习笔记
其他学习资料：https://blog.csdn.net/u011974639/article/details/73865048?locationNum=4&fps=1
