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 训练过程准确率曲线