TensorFlow 2.0 笔记(一)神经网络计算过程及模型搭建
第一章 神经网络计算过程及模型搭建
1 人工智能三学派
我们常说的人工智能,就是让机器具备人的思维和意识。人工智能主要有三个学派,即行为主义、符号主义和连接主义。
行为主义:是基于控制论的,是在构建感知、动作的控制系统。单脚站立是行为主义一个典型例子,通过感知要摔倒的方向,控制两只手的动作,保持身体的平衡。这就构建了一个感知、动作的控制系统,是典型的行为主义。
符号主义:基于算数逻辑表达式。即在求解问题时,先把问题描述为表达式,再求解表达式。例如在求解某个问题时,利用 if case 等条件语句和若干计算公式描述出来,即使用了符号主义的方法,如专家系统。符号主义是能用公式描述的人工智能,它让计算机具备了理性思维。
连接主义:仿造人脑内的神经元连接关系,使人类不仅具备理性思维,还具备无法用公式描述的感性思维,如对某些知识产生记忆。
图 1.1 展示了人脑中的一根神经元,其中紫色部分为树突,其作为神经元的输入。黄色部分为轴突,其作为神经元的输出。人脑就是由 860 亿个这样的神经元首尾相接组成的网络。
图1.1 神经元示意图
基于连接主义的神经网络模仿上图的神经元,使计算机具有感性思维。图1.2展示了从出生到成年,人脑中神经网络的变化。
图1.2 人脑神经网络变化示意图
随着我们的成长,大量的数据通过视觉、听觉涌入大脑,使我们的神经网络连接,也就是这些神经元连接线上的权重发生了变化,有些线上的权重增强了,有些线上的权重减弱了。如图1.3所示。
图1.3 神经网络权重变化示意图
2 神经网络设计过程
我们要用计算机模仿刚刚说到的神经网络连接关系,让计算机具备感性思维。
首先,需要准备数据,数据量越大越好,要构成特征和标签对。如要识别猫,就要有大量猫的图片和这个图片是猫的标签,构成特征标签对。
随后,搭建神经网络的网络结构,并通过反向传播,优化连线的权重,直到模型的识别准确率达到要求,得到最优的连线权重,把这个模型保存起来。
最后,用保存的模型,输入从未见过的新数据,它会通过前向传播,输出概率值,概率值最大的一个,就是分类或预测的结果。图2.1展示了搭建与使用神经网络模型的流程。
图2.1 搭建与使用神经网络示意图
2.1 数据集介绍
本讲中采用鸢尾花数据集,此数据集包含鸢尾花花萼长、花萼宽、花瓣长、花瓣宽及对应的类别。其中前4个属性作为输入特征,类别作为标签,0代表狗尾草鸢尾,1代表杂色鸢尾,2代表弗吉尼亚鸢尾。人们通过对数据进行分析总结出了规律:通过测量花的花萼长、花萼宽、花瓣长、花瓣宽,可以得出鸢尾花的类别(如:花萼长>花萼宽且花瓣长/花瓣宽>2 ,则杂色鸢尾)。
由上述可知,可通过if与case语句构成专家系统,进行判别分类。在本讲中,采用搭建神经网络的办法对其进行分类,即将鸢尾花花萼长、花萼宽、花瓣长、花瓣宽四个输入属性喂入搭建好的神经网络,网络优化参数得到模型,输出分类结果。
2.2 网络搭建与训练
本讲中,我们搭建包含输入层与输出层的神经网络模型,通过对输入值乘权值,并于偏置值求和的方式得到输出值,图示如下。
图2.2 鸢尾花神经网络简要模型
由图2.2可知输出y = x*w+b,即所有的输入x乘以各自线上的权重w求和加上偏置项b得到输出y。由2.1部分对数据集的介绍可知,输入特征x形状应为(1,4)即1行4列,输出y形状应为(1,3)即1行3列,w形状应为(4,3)即4行3列,b形状应为(3, )即有3个偏置项。
搭建好基本网络后,需要输入特征数据,并对线上权重w与偏置b进行初始化。搭建的神经网络如图2.3所示,w,b初始化矩阵如图2.4所示。在这里,我们输入标签为0的狗尾草鸢尾。
图2.3 鸢尾花神经网络展开模型
图2.4 权重与偏置初始化矩阵
有了输入数据与线上权重等数据,即可按照y = x*w+b方式进行前向传播,计算过程如图2.5所示。
图2.5 前向传播计算过程
图2.5中输出y中,1.01代表0类鸢尾得分,2.01代表1类鸢尾得分,-0.66代表2类鸢尾得分。通过输出y可以看出数值最大(可能性最高)的是1类鸢尾,而不是标签0类鸢尾。这是由于最初的参数w和b是随机产生的,现在输出的结果是蒙的。
为了修正这一结果,我们用损失函数,定义预测值y和标准答案(标签) y_的差距,损失函数可以定量的判断当前这组参数w和b的优劣,当损失函数最小时,即可得到最优w的值和b的值。
损失函数的定义有多种方法,均方误差就是一种常用的损失函数,它计算每个前向传播输出y和标准答案_y的差求平方再求和再除以n求平均值,表征了网络前向传播推理结果和标准答案之间的差距。
通过上述对损失函数的介绍,其目的是寻找一组参数w和b使得损失函数最小。为达成这一目的,我们采用梯度下降的方法。损失函数的梯度表示损失函数
对各参数求偏导后的向量,损失函数梯度下降的方向,就是是损失函数减小的方向。梯度下降法即沿着损失函数梯度下降的方向,寻找损失函数的最小值,从而得到最优的参数。梯度下降法涉及的公式如下
上式中,lr表示学习率,是一个超参数,表征梯度下降的速度。如学习率设置过小,参数更新会很慢,如果学习率设置过大,参数更新可能会跳过最小值。
上述梯度下降更新的过程为反向传播,下面通过例子感受反向传播。利用如下公式对参数w进行更新。
设损失函数为(w+1)^2,则其对w的偏导数为2w+2。设w在初始化时被随机初始化为5,学习率设置为0.2。则我们可按上述公式对w进行更新:
第一次参数为5,按上式计算即5-0.2×(2×5+2)=2.6。
同理第二次计算得到参数为1.16,第三次计算得到参数为0.296……
画出损失函数(w+1)^2的图像,可知w=-1时损失函数最小,我们反向传播优化参数的目的即为找到这个使损失函数最小的w=-1值。
3 TensorFlow2.X 基本概念与常见函数
3.1 基本概念
TensorFlow中的Tensor表示张量,是多维数组、多维列表,用阶表示张量的维数。0阶张量叫做标量,表示的是一个单独的数,如123;1阶张量叫作向量,表示的是一个一维数组如[1,2,3];2阶张量叫作矩阵,表示的是一个二维数组,它可以有i行j列个元素,每个元素用它的行号和列号共同索引到,如在[[1,2,3],[4,5,6],[7,8,9]]中,2的索引即为第0行第1列。张量的阶数与方括号的数量相同,0个方括号即为0阶张量,1个方括号即为1阶张量。故张量可以表示0阶到n阶的数组。也可通过reshape的方式得到更高维度数组,举例如下:
c = np.arange(24).reshape(2,4,3)
print(c)
输出结果:
[[[ 0 1 2] [ 3 4 5] [ 6 7 8] [ 9 10 11]]
[[12 13 14] [15 16 17] [18 19 20] [21 22 23]]]
TensorFlow中数据类型包括32位整型(tf.int32)、32位浮点(tf.float32)、64位浮点(tf.float64)、布尔型(tf.bool)、字符串型(tf.string)
创建张量有若干种不同的方法:
(1) 利用tf.constant(张量内容,dtype=数据类型(可选)),第一个参数表示张量内容,第二个参数表示张量的数据类型。举例如下:
a = tf.constant([1, 5], dtype=tf.int64)
print("a:", a)
print("a.dtype:", a.dtype)
print("a.shape:", a.shape)
输出结果为:
a: tf.Tensor([1 5], shape=(2,), dtype=int64)
a.dtype: <dtype: 'int64'>
a.shape: (2,)
即会输出张量内容、形状与数据类型,shape中数字为2,表示一维张量里有2个元素。
注:去掉dtype项,不同电脑环境不同导致默认值不同,可能导致后续程序bug
(2) 很多时候数据是由numpy格式给出的,此时可以通过如下函数将numpy格式化为Tensor格式:tf. convert_to_tensor(数据名,dtype=数据类型(可选))。举例如下:
import tensorflow as tf
import numpy as np
a = np.arange(0, 5)
b = tf.convert_to_tensor(a, dtype=tf.int64)
print("a:", a)
print("b:", b)
输出结果为:
a: [0 1 2 3 4]
b: tf.Tensor([0 1 2 3 4], shape=(5,), dtype=int64)
(3) 可采用不同函数创建不同值的张量。如用tf. zeros(维度)创建全为0的张量,tf.ones(维度)创建全为1的张量,tf. fill(维度,指定值)创建全为指定值的张量。其中维度参数部分,如一维则直接写个数,二维用[行,列]表示,多维用[n,m,j..]表示。举例如下:
a = tf.zeros([2, 3])
b = tf.ones(4)
c = tf.fill([2, 2], 9)
print("a:", a)
print("b:", b)
print("c:", c)
输出结果:
a: tf.Tensor([[0. 0. 0.] [0. 0. 0.]], shape=(2, 3), dtype=float32)
b: tf.Tensor([1. 1. 1. 1.], shape=(4,), dtype=float32)
c: tf.Tensor([[9 9] [9 9]], shape=(2, 2), dtype=int32)
可见,tf.zeros([2,3])创建了一个二维张量,第一个维度有两个元素,第二个维度有三个元素,元素的内容全是0;tf.ones(4)创建了一个一维张量,里边有4个元素,内容全是1;tf.fill([2,2],9)创建了一个两行两列的二维张量,第一个维度有两个元素,第二个维度也有两个元素,内容都是9。
(4) 可采用不同函数创建符合不同分布的张量。如用tf. random.normal (维度,mean=均值,stddev=标准差)生成正态分布的随机数,默认均值为0,标准差为1;用tf. random.truncated_normal (维度,mean=均值,stddev=标准差)生成截断式正态分布的随机数,能使生成的这些随机数更集中一些,如果随机生成数据的取值在(μ-2σ,μ+2σ),之外则重新进行生成,保证了生成值在均值附近;利用tf. random. uniform(维度,minval=最小值,maxval=最大值),生成指定维度的均匀分布随机数,用minval给定随机数的最小值,用maxval给定随机数的最大值,最小、最大值是前闭后开区间。举例如下:
d = tf.random.normal([2, 2], mean=0.5, stddev=1)
print("d:", d)
e = tf.random.truncated_normal([2, 2], mean=0.5, stddev=1)
print("e:", e)
f = tf.random.uniform([2, 2], minval=0, maxval=1)
print("f:", f)
d: tf.Tensor([[ 2.8951766 0.34715778] [-0.88545835 0.1141389 ]], shape=(2, 2), dtype=float32)
e: tf.Tensor([[ 1.3894703 1.226865 ] [ 0.6791599 -0.03111815]], shape=(2, 2), dtype=float32)
f: tf.Tensor([[1.3811994e-01 8.8101661e-01] [1.9073486e-04 9.7648060e-01]], shape=(2, 2), dtype=float32)
3.2 常用函数
(1)利用tf.cast (张量名,dtype=数据类型)强制将Tensor转换为该数据类型;利用tf.reduce_min (张量名)计算张量维度上元素的最小值;利用tf.reduce_max (张量名)计算张量维度上元素的最大值。举例如下:
x1 = tf.constant([1., 2., 3.], dtype=tf.float64)
print("x1:", x1)
x2 = tf.cast(x1, tf.int32)
print("x2", x2)
print("minimum of x2:", tf.reduce_min(x2))
print("maxmum of x2:", tf.reduce_max(x2))
输出结果:
x1: tf.Tensor([1. 2. 3.], shape=(3,), dtype=float64)
x2 tf.Tensor([1 2 3], shape=(3,), dtype=int32)
minimum of x2: tf.Tensor(1, shape=(), dtype=int32)
maxmum of x2: tf.Tensor(3, shape=(), dtype=int32)
(2) 可用tf.reduce_mean (张量名,axis=操作轴)计算张量沿着指定维度的平均值;可用f.reduce_sum (张量名,axis=操作轴)计算张量沿着指定维度的和,如不指定axis,则表示对所有元素进行操作。其中维度可按图3.1理解。
图3.1 维度定义
由上图可知对于一个二维张量,如果axis=0表示纵向操作(沿经度方向) ,axis=1 表示横向操作(沿纬度方向)。举例如下:
x = tf.constant([[1, 2, 3], [2, 2, 3]])
print("x:", x)
print("mean of x:", tf.reduce_mean(x)) # 求x中所有数的均值
print("sum of x:", tf.reduce_sum(x, axis=1)) # 求每一行的和
输出结果:
x: tf.Tensor(
[[1 2 3]
[2 2 3]], shape=(2, 3), dtype=int32)
mean of x: tf.Tensor(2, shape=(), dtype=int32)
sum of x: tf.Tensor([6 7], shape=(2,), dtype=int32)
(3) 可利用tf.Variable(initial_value,trainable,validate_shape,name)函数可以将变量标记为“可训练”的,被它标记了的变量,会在反向传播中记录自己的梯度信息。其中initial_value默认为None,可以搭配tensorflow随机生成函数来初始化参数;trainable默认为True,表示可以后期被算法优化的,如果不想该变量被优化,即改为False;validate_shape默认为True,形状不接受更改,如果需要更改,validate_shape=False;name默认为None,给变量确定名称。举例如下:
w = tf.Variable(tf.random.normal([2, 2], mean=0, stddev=1)),表示首先随机生成正态分布随机数,再给生成的随机数标记为可训练,这样在反向传播中就可以通过梯度下降更新参数w了。
(4) 利用TensorFlow中函数对张量进行四则运算。利用tf.add (张量1,张量2)实现两个张量的对应元素相加;利用tf.subtract (张量1,张量2)实现两个张量的对应元素相减;利用tf.multiply (张量1,张量2)实现两个张量的对应元素相乘;利用tf.divide (张量1,张量2)实现两个张量的对应元素相除。注:只有维度相同的张量才可以做四则运算,举例如下:
a = tf.ones([1, 3])
b = tf.fill([1, 3], 3.)
print("a:", a)
print("b:", b)
print("a+b:", tf.add(a, b))
print("a-b:", tf.subtract(a, b))
print("a*b:", tf.multiply(a, b))
print("b/a:", tf.divide(b, a))
输出结果:
a: tf.Tensor([[1. 1. 1.]], shape=(1, 3), dtype=float32)
b: tf.Tensor([[3. 3. 3.]], shape=(1, 3), dtype=float32)
a+b: tf.Tensor([[4. 4. 4.]], shape=(1, 3), dtype=float32)
a-b: tf.Tensor([[-2. -2. -2.]], shape=(1, 3), dtype=float32)
a*b: tf.Tensor([[3. 3. 3.]], shape=(1, 3), dtype=float32)
b/a: tf.Tensor([[3. 3. 3.]], shape=(1, 3), dtype=float32)
(5) 利用TensorFlow中函数对张量进行幂次运算。可用tf.square (张量名)计算某个张量的平方;利用tf.pow (张量名,n次方数)计算某个张量的n次方;利用tf.sqrt (张量名)计算某个张量的开方。举例如下:
a = tf.fill([1, 2], 3.)
print("a:", a)
print("a的平方:", tf.pow(a, 3))
print("a的平方:", tf.square(a))
print("a的开方:", tf.sqrt(a))
输出结果:
a: tf.Tensor([[3. 3.]], shape=(1, 2), dtype=float32)
a的平方: tf.Tensor([[27. 27.]], shape=(1, 2), dtype=float32)
a的平方: tf.Tensor([[9. 9.]], shape=(1, 2), dtype=float32)
a的开方: tf.Tensor([[1.7320508 1.7320508]], shape=(1, 2), dtype=float32)
(6) 可利用tf.matmul(矩阵1,矩阵2)实现两个矩阵的相乘。举例如下:
a = tf.ones([3, 2])
b = tf.fill([2, 3], 3.)
print("a*b:", tf.matmul(a, b))
输出结果:tf.Tensor([[6. 6. 6.] [6. 6. 6.] [6. 6. 6.]], shape=(3, 3), dtype=float32),即a为一个3行2列的全1矩阵,b为2行3列的全3矩阵,二者进行矩阵相乘。
(7) 可利用tf.data.Dataset.from_tensor_slices((输入特征, 标签))切分传入张量的第一维度,生成输入特征/标签对,构建数据集,此函数对Tensor格式与Numpy格式均适用,其切分的是第一维度,表征数据集中数据的数量,之后切分batch等操作都以第一维为基础。举例如下:
features = tf.constant([12, 23, 10, 17])
labels = tf.constant([0, 1, 1, 0])
dataset = tf.data.Dataset.from_tensor_slices((features, labels))
for element in dataset:
print(element)
(<tf.Tensor: shape=(), dtype=int32, numpy=12>, <tf.Tensor: shape=(), dtype=int32, numpy=0>)
(<tf.Tensor: shape=(), dtype=int32, numpy=23>, <tf.Tensor: shape=(), dtype=int32, numpy=1>)
(<tf.Tensor: shape=(), dtype=int32, numpy=10>, <tf.Tensor: shape=(), dtype=int32, numpy=1>)
(<tf.Tensor: shape=(), dtype=int32, numpy=17>, <tf.Tensor: shape=(), dtype=int32, numpy=0>)
即将输入特征12和标签0对应,产生配对;将输入特征23和标签1对应,产生配对……
(8) 可利用tf.GradientTape( )函数搭配with结构计算损失函数在某一张量处的梯度,举例如下:
with tf.GradientTape() as tape:
x = tf.Variable(tf.constant(3.0))
y = tf.pow(x, 2)
grad = tape.gradient(y, x)
print(grad)
输出结果:tf.Tensor(6.0, shape=(), dtype=float32) 在上例中,损失函数为\(w^2\),\(w\)当前取值为3,故计算方式为
(9) 可利用enumerate(列表名)函数枚举出每一个元素,并在元素前配上对应的索引号,常在for循环中使用。举例如下:
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
print(i, element)
输出结果:
0 one
1 two
2 three
(10)可用tf.one_hot(待转换数据,depth=几分类)函数实现用独热码表示标签,在分类问题中很常见。标记类别为为1和0,其中1表示是,0表示非。如在鸢尾花分类任务中,如果标签是1,表示分类结果是1杂色鸢尾,其用把它用独热码表示就是0,1,0,这样可以表示出每个分类的概率:也就是百分之0的可能是0狗尾草鸢尾,百分百的可能是1杂色鸢尾,百分之0的可能是弗吉尼亚鸢尾。举例如下:
classes = 3
labels = tf.constant([1, 0, 2]) # 输入的元素值最小为0,最大为2
output = tf.one_hot(labels, depth=classes)
print("result of labels1:", output)
输出结果:
result of labels1: tf.Tensor(
[[0. 1. 0.]
[1. 0. 0.]
[0. 0. 1.]], shape=(3, 3), dtype=float32)
索引从0开始,待转换数据中各元素值应小于depth,若带转换元素值大于等于depth,则该元素输出编码为[0, 0 … 0, 0]。即depth确定列数,待转换元素的个数确定行数。举例如下:
classes = 3
labels = tf.constant([1, 0, 4]) #输入的元素值4超出depth-1
output = tf.one_hot(labels, depth=classes)
print("result of labels1:", output)
输出结果:
result of labels1: tf.Tensor(
[[0. 1. 0.]
[1. 0. 0.]
[0. 0. 0.]], shape=(3, 3), dtype=float32)
即元素4对应的输出编码为[0. 0. 0.]。
(11)可利用tf.nn.softmax( )函数使前向传播的输出值符合概率分布,进而与独热码形式的标签作比较,其计算公式为
其中\(y_i\)是前向传播的输出。在前一部分,我们得到了前向传播的输出值,分别为1.01、2.01、-0.66,通过上述计算公式,可计算对应的概率值:
上式中,0.256表示为0类鸢尾的概率是25.6%,0.695表示为1类鸢尾的概率是69.5%,0.048表示为2类鸢尾的概率是4.8%。程序实现如下:
y = tf.constant([1.01, 2.01, -0.66])
y_pro = tf.nn.softmax(y)
print("After softmax, y_pro is:", y_pro) # y_pro 符合概率分布
输出结果:
After softmax, y_pro is: tf.Tensor([0.25598174 0.6958304 0.0481878 ], shape=(3,), dtype=float32)
与上述计算结果相同。
(12)可利用assign_sub对参数实现自更新。使用此函数前需利用tf.Variable定义变量w为可训练(可自更新),举例如下:
x = tf.Variable(4)
x.assign_sub(1)
print("x:", x) # 4-1=3
输出结果:x: <tf.Variable 'Variable:0' shape=() dtype=int32, numpy=3>
即实现了参数w自减1。注:直接调用tf.assign_sub会报错,要用w.assign_sub。
(13)可利用tf.argmax (张量名,axis=操作轴)返回张量沿指定维度最大值的索引,维度定义与图3.1一致。举例如下:
test = np.array([[1, 2, 3], [2, 3, 4], [5, 4, 3], [8, 7, 2]])
print("test:\n", test)
print("每一列的最大值的索引:", tf.argmax(test, axis=0)) # 返回每一列最大值的索引
print("每一行的最大值的索引", tf.argmax(test, axis=1)) # 返回每一行最大值的索引
输出结果:
test:
[[1 2 3]
[2 3 4]
[5 4 3]
[8 7 2]]
每一列的最大值的索引: tf.Tensor([3 3 1], shape=(3,), dtype=int64)
每一行的最大值的索引 tf.Tensor([2 2 0 0], shape=(4,), dtype=int64)
4 程序实现鸢尾花数据集分类
4.1 数据集回顾
先回顾鸢尾花数据集,其提供了150组鸢尾花数据,每组包括鸢尾花的花萼长、花萼宽、花瓣长、花瓣宽4个输入特征,同时还给出了这一组特征对应的鸢尾花类别。类别包括狗尾鸢尾、杂色鸢尾、弗吉尼亚鸢尾三类, 分别用数字0、1、2表示。使用此数据集代码如下:
from sklearn import datasets
# 导入数据,分别为输入特征和标签
x_data = datasets.load_iris().data
y_data = datasets.load_iris().target
即从sklearn包中导出数据集,将输入特征赋值给x_data变量,将对应标签赋值给y_data变量。
4.2 程序实现
我们用神经网络实现鸢尾花分类仅需要三步:
(1)准备数据,包括数据集读入、数据集乱序,把训练集和测试集中的数据配成输入特征和标签对,生成train和test即永不相见的训练集和测试集;
(2)搭建网络,定义神经网络中的所有可训练参数;
(3)优化这些可训练的参数,利用嵌套循环在with结构中求得损失函数loss对每个可训练参数的偏导数,更改这些可训练参数,为了查看效果,程序中可以加入每遍历一次数据集显示当前准确率,还可以画出准确率acc和损失函数loss的变化曲线图。以上部分的完整代码与解析如下:
(1) 数据集读入:
from sklearn import datasets
# 导入数据,分别为输入特征和标签
x_data = datasets.load_iris().data
y_data = datasets.load_iris().target
(2) 数据集乱序:
# 随机打乱数据(因为原始数据是顺序的,顺序不打乱会影响准确率)
# seed: 随机数种子,是一个整数,当设置之后,每次生成的随机数都一样(为方便教学,以保每位同学结果一致)
np.random.seed(116) # 使用相同的seed,保证输入特征和标签一一对应
np.random.shuffle(x_data)
np.random.seed(116)
np.random.shuffle(y_data)
tf.random.set_seed(116)
(3) 数据集分割成永不相见的训练集和测试集:
# 将打乱后的数据集分割为训练集和测试集,训练集为前120行,测试集为后30行
x_train = x_data[:-30]
y_train = y_data[:-30]
x_test = x_data[-30:]
y_test = y_data[-30:]
(4) 配成[输入特征,标签]对,每次喂入一小撮(batch):
# from_tensor_slices函数使输入特征和标签值一一对应。(把数据集分批次,每个批次batch组数据)
train_db = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32)
test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)
上述四小部分代码实现了数据集读入、数据集乱序、将数据集分割成永不相见的训练集和测试集、将数据配成[输入特征,标签]对。人类在认识这个世界的时候信息是没有规律的,杂乱无章的涌入大脑的,所以喂入神经网络的数据集也需要被打乱顺序。(2)部分实现了让数据集乱序,因为使用了同样的随机种子,所以打乱顺序后输入特征和标签仍然是一一对应的。(3)部分将打乱后的前120个数据取出来作为训练集,后30个数据作为测试集,为了公正评判神经网络的效果,训练集和测试集没有交集。(4)部分使用from_tensor_slices把训练集的输入特征和标签配对打包,将每32组输入特征标签对打包为一个batch,在喂入神经网络时会以batch为单位喂入。
(5) 定义神经网路中所有可训练参数:
# 生成神经网络的参数,4个输入特征故,输入层为4个输入节点;因为3分类,故输出层为3个神经元
# 用tf.Variable()标记参数可训练
# 使用seed使每次生成的随机数相同(方便教学,使大家结果都一致,在现实使用时不写seed)
w1 = tf.Variable(tf.random.truncated_normal([4, 3], stddev=0.1, seed=1))
b1 = tf.Variable(tf.random.truncated_normal([3], stddev=0.1, seed=1))
(6) 嵌套循环迭代,with结构更新参数,显示当前loss:
lr = 0.1 # 学习率为0.1
train_loss_results = [] # 将每轮的loss记录在此列表中,为后续画loss曲线提供数据
test_acc = [] # 将每轮的acc记录在此列表中,为后续画acc曲线提供数据
epoch = 500 # 循环500轮
loss_all = 0 # 每轮分4个step,loss_all记录四个step生成的4个loss的和
# 训练部分
for epoch in range(epoch): #数据集级别的循环,每个epoch循环一次数据集
for step, (x_train, y_train) in enumerate(train_db): #batch级别的循环 ,每个step循环一个batch
with tf.GradientTape() as tape: # with结构记录梯度信息
y = tf.matmul(x_train, w1) + b1 # 神经网络乘加运算
y = tf.nn.softmax(y) # 使输出y符合概率分布(此操作后与独热码同量级,可相减求loss)
y_ = tf.one_hot(y_train, depth=3) # 将标签值转换为独热码格式,方便计算loss和accuracy
loss = tf.reduce_mean(tf.square(y_ - y)) # 采用均方误差损失函数mse = mean(sum(y-out)^2)
loss_all += loss.numpy() # 将每个step计算出的loss累加,为后续求loss平均值提供数据,这样计算的loss更准确
# 计算loss对各个参数的梯度
grads = tape.gradient(loss, [w1, b1])
# 实现梯度更新 w1 = w1 - lr * w1_grad b = b - lr * b_grad
w1.assign_sub(lr * grads[0]) # 参数w1自更新
b1.assign_sub(lr * grads[1]) # 参数b自更新
# 每个epoch,打印loss信息
print("Epoch {}, loss: {}".format(epoch, loss_all/4))
train_loss_results.append(loss_all / 4) # 将4个step的loss求平均记录在此变量中
loss_all = 0 # loss_all归零,为记录下一个epoch的loss做准备
# 测试部分
# total_correct为预测对的样本个数, total_number为测试的总样本数,将这两个变量都初始化为0
total_correct, total_number = 0, 0
for x_test, y_test in test_db:
# 使用更新后的参数进行预测
y = tf.matmul(x_test, w1) + b1
y = tf.nn.softmax(y)
pred = tf.argmax(y, axis=1) # 返回y中最大值的索引,即预测的分类
# 将pred转换为y_test的数据类型
pred = tf.cast(pred, dtype=y_test.dtype)
# 若分类正确,则correct=1,否则为0,将bool型的结果转换为int型
correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32)
# 将每个batch的correct数加起来
correct = tf.reduce_sum(correct)
# 将所有batch中的correct数加起来
total_correct += int(correct)
# total_number为测试的总样本数,也就是x_test的行数,shape[0]返回变量的行数
total_number += x_test.shape[0]
# 总的准确率等于total_correct/total_number
acc = total_correct / total_number
test_acc.append(acc)
print("Test_acc:", acc)
print("--------------------------")
(7) 计算当前参数前向传播后的准确率,显示当前准确率acc:
# 测试部分
# total_correct为预测对的样本个数, total_number为测试的总样本数,将这两个变量都初始化为0
total_correct, total_number = 0, 0
for x_test, y_test in test_db:
# 使用更新后的参数进行预测
y = tf.matmul(x_test, w1) + b1
y = tf.nn.softmax(y)
pred = tf.argmax(y, axis=1) # 返回y中最大值的索引,即预测的分类
# 将pred转换为y_test的数据类型
pred = tf.cast(pred, dtype=y_test.dtype)
# 若分类正确,则correct=1,否则为0,将bool型的结果转换为int型
correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32)
# 将每个batch的correct数加起来
correct = tf.reduce_sum(correct)
# 将所有batch中的correct数加起来
total_correct += int(correct)
# total_number为测试的总样本数,也就是x_test的行数,shape[0]返回变量的行数
total_number += x_test.shape[0]
# 总的准确率等于total_correct/total_number
acc = total_correct / total_number
test_acc.append(acc)
print("Test_acc:", acc)
print("--------------------------")
(8) acc / loss可视化:
# 绘制 loss 曲线
plt.title('Loss Function Curve') # 图片标题
plt.xlabel('Epoch') # x轴变量名称
plt.ylabel('Loss') # y轴变量名称
plt.plot(train_loss_results, label="$Loss$") # 逐点画出trian_loss_results值并连线,连线图标是Loss
plt.legend() # 画出曲线图标
plt.show() # 画出图像
# 绘制 Accuracy 曲线
plt.title('Acc Curve') # 图片标题
plt.xlabel('Epoch') # x轴变量名称
plt.ylabel('Acc') # y轴变量名称
plt.plot(test_acc, label="$Accuracy$") # 逐点画出test_acc值并连线,连线图标是Accuracy
plt.legend()
plt.show()
上述两部分完成了对准确率的计算并可视化准确率与loss。(7)部分前向传播计算出y,使其符合概率分布并找到最大的概率值对应的索引号,调整数据类型与标签一致,如果预测值和标签相等则correct变量自加一,准确率即预测对了的数量除以测试集中的数据总数。(9)部分可将计算出的准确率画成曲线图,通过设置图标题、设置x轴名称、设置y轴名称,标出每个epoch时的准确率并画出曲线,可用同样方法画出loss曲线。结果图如图4.1与4.2。
图4.1 训练过程loss曲线
图4.2 训练过程准确率曲线