神经网络与深度学习：案例与实践——第三章(1)

神经网络与深度学习：案例与实践——第三章(1)

3.1 基于Logistic回归的二分类使命

重要使命：实现一个Logistic回归模型，并对一个简单的数据集举行二分类实验。
3.1.1 数据集构建

先构建一个简单的分类使命，并构建训练集、验证集和测试集。
本使命的数据来自带噪音的两个弯月形状函数，每个弯月对一个类别。我们收罗1000条样本，每个样本包罗2个特性。
①数据集构建函数：具体解说在代码内部.

1. #first.py
2. import copy
3. import paddle
4. import math
5. # 数据集构建：1.输入参数
6. def make_moons(n_samples = 1000,shuffle = True,noise = None):
7.     '''
8.     生成弯月状数据集：
9.     输入：
10.     n_samples: 总样本量,默认是1000
11.     shuffle: 表示是否打乱顺序,当值为True时,表示打乱顺序。
12.     noise: 数据类型为None或者float,当数据类型为None,表示没有噪声值
13.     输出：
14.     X: 特征数据,shape = [n_samples,2] ,表示生成是n_samples行,2列
15.     Y: 标签数据,shape = [n_samples],表示生成是 n_samples维
16.     '''
18.     #2.数据分配——将总样本数大致平分给两个半圆。
19.     n_sample_out = n_samples // 2 # 外半圆数据量
20.     n_sample_in = n_samples - n_sample_out # 内半圆数据量
21.     #上述代码运算符解释： '/': 返回浮点数, '//': 返回整数（向下取整，3.1 取 3）
23.     #3.生成外半圆数据
24.     outer_circ_x = paddle.cos(paddle.linspace(0,math.pi,n_sample_out))
25.     outer_circ_y = paddle.sin(paddle.linspace(0,math.pi,n_sample_out))
26.     #上述代码解释，linspace 方法，在0到Π 之间生成 n_samples_out个等距数据，对这些点进行cos,sin计算取得x和y坐标，生成上半圆
28.     #4.生成内半圆数据
29.     inner_circ_x = 1 - paddle.cos(paddle.linspace(0, math.pi, n_sample_in))
30.     inner_circ_y = 0.5 - paddle.sin(paddle.linspace(0, math.pi, n_sample_in))
31.     #内半圆通过变换外半圆得到: x坐标: 1 - cos(θ),使内半圆向右偏移, y坐标: 0.5 - sin(θ),使内半圆向下偏移并缩小
33.     print('outer_circ_x.shape:', outer_circ_x.shape, 'outer_circ_y.shape:', outer_circ_y.shape)
34.     print('inner_circ_x.shape:', inner_circ_x.shape, 'inner_circ_y.shape:', inner_circ_y.shape)
36.     #5.合并特征数据
37.     X = paddle.stack(
38.     [paddle.concat([outer_circ_x, inner_circ_x]),
39.      paddle.concat([outer_circ_y, inner_circ_y])],
40.     axis=1)
41.     #paddle.concat: 沿第0维拼接内外半圆的x/y坐标, paddle.stack: 将x和y坐标沿第1维堆叠，形成(n_samples, 2)的特征矩阵
42.     #paddle.concat:沿指定维度拼接张量,paddle.concat(tensors, axis=0)
43.     #paddle.stack: 沿新维度堆叠张量, paddle.stack(tensors, axis=0)
44.    
46.     #6.生成标签数据
47.     y = paddle.concat(
48.         [paddle.zeros(shape=[n_sample_out]),
49.         paddle.ones(shape=[n_sample_in])]
50.     )
51.     #外半圆标签为0, 内半圆标签为1
53.     print('y shape:', y.shape)
54.    
55.     #7.打乱数据
56.     if shuffle:
57.         idx = paddle.randperm(X.shape[0])
58.         X = X[idx]
59.         Y = y[idx]
60.     #paddle.randperm(X.shape[0]) 的作用, 生成一个 [0, 1, 2, ..., n-1] 的随机排列的索引数组。
61.     #例如：若 X.shape[0] = 4，可能生成 [2, 0, 3, 1]。
62.     #用 idx 的每个元素作为位置索引，从 X 中提取对应行的数据。
63.     #原数据 X = [[a], [b], [c], [d]], idx = [2, 0, 3, 1], 结果 X[idx] = [[c], [a], [d], [b]]
65.     #8.添加噪声值
66.     if noise is not None:
67.         X += paddle.normal(mean=0.0, std=noise, shape=X.shape)
68.     # 使用'paddle.normal'生成符合正态分布的随机Tensor作为噪声，并加到原始特征上,
69.     # mean=0.0: 噪声均值为0, std=noise: 噪声标准差由参数指定
70.     # paddle.normal: 生成正态分布随机数, paddle.normal(mean, std, shape)
72.     return X,y

复制代码

②随机收罗1000个样本，之后举行可视化。

1. #second.py
2. from first import make_moons
3. import matplotlib.pyplot as plt
4. # %matplotlib inline
6. # 设置样本量，调用函数
7. n_samples = 1000
8. X, y = make_moons(n_samples=n_samples, shuffle=True, noise=0.5)
10. #创建图形
11. plt.figure(figsize=(5,5))
12. #plt.figure()：创建一个新的图形窗口, figsize=(5,5)：设置图形大小为5×5英寸
14. # 绘制散点图
15. plt.scatter(x=X[:, 0].tolist(), y=X[:, 1].tolist(), marker='*', c=y.tolist())
16. #plt.scatter()：绘制散点图
17. # x=X[:, 0].tolist()：X的第一列作为x坐标（转换为Python列表）
18. # y=X[:, 1].tolist()：X的第二列作为y坐标
19. # marker='*'：使用星号作为点的标记
20. # c=y.tolist()：使用y值作为颜色编码（不同类别不同颜色）
22. # 设置坐标轴范围
23. plt.xlim(-3,4)
24. plt.ylim(-3,4)
25. #plt.xlim()/plt.ylim()：设置x/y轴显示范围, 这里设置为(-3,4)以完整显示数据分布
27. # 保存图片，显示图片，但是现在vscode还没办法显示pdf，所以先不保存
28. #plt.savefig('linear-dataset-vis.pdf')
29. plt.show()

复制代码

③将1000条样本数据拆分成训练集、验证集和测试集，其中训练集640条、验证集160条、测试集200条。

1. #third.py
2. from first import make_moons
3. # 设置样本量，调用函数
4. n_samples = 1000
5. X, y = make_moons(n_samples=n_samples, shuffle=True, noise=0.5)
7. #1. 定义数据集
8. num_train = 640    # 训练集样本数
9. num_dev = 160      # 开发集(验证集)样本数
10. num_test = 200     # 测试集样本数
12. #2.数据分割
13. # 训练集：前640个样本
14. X_train, y_train = X[:num_train], y[:num_train]
16. # 开发集：接下来的160个样本 (640到800)
17. X_dev, y_dev = X[num_train:num_train + num_dev], y[num_train:num_train + num_dev]
19. # 测试集：剩余样本 (800到1000)
20. X_test, y_test = X[num_train + num_dev:], y[num_train + num_dev:]
22. #3.标签维度调整
23. # 将一维标签 [n_samples] 转为二维 [n_samples, 1]
24. y_train = y_train.reshape([-1,1])  # -1表示自动计算该维度大小
25. y_dev = y_dev.reshape([-1,1])
26. y_test = y_test.reshape([-1,1])
28. # 打印X_train和y_train的维度
29. print("X_train shape: ", X_train.shape, "y_train shape: ", y_train.shape)
30. # 打印一下前5个数据的标签
31. print (y_train[:5])

复制代码

如今，完成了数据集的构建
3.1.2 模型构建

Logistic回归是一种常用的处理二分类题目的线性模型。
特性线性回归Logistic回归输出范围任意实数概率值（0，1）区间目标猜测连续值猜测类别概率函数转换无使用Sigmoid函数（非线性转换） 颠末上面的对比，得知Logistic回归与线性回归的相同之处为：都会将输入特性与权重做线性叠加。但是，Logistic回归还引入了非线性函数（Sigmoid函数），取猜测类别标签的厚颜概率p(y = 1|X)，从而办理了连续的线性函数不适合举行分类的这一题目。

Logistic函数是Logistic回归的焦点。其特点与优势：
①输出范围：将任意实数映射到 (0,1) 区间，适合表现概率。
②平滑性：连续可导，便于优化（如梯度降落）。
③与阶跃函数的对比：办理了阶跃函数在阈值点不连续的题目，更适合分类。
Logistic函数代码实现如下：

结果分析：输入在0附近时，Logistic函数近似为线性函数；当输入值非常大大概非常小时，函数会对输入举行抑制.输入越小，越靠近0；输入越大，越靠近1。正是因为这样的性质，才使得其输出可以直接看作是概率分布。
Logistic回归算子
Logistic回归模型其实就是线性层与Logistic函数的组合，通常会讲Logistic回归模型中的权重和偏置初始化为0.并且，为例进步猜测样本服从，将N个样本归为一组举行成批猜测。

实现代码如下：

1. class model_LR(op.Op):#继承自定义的算子基类
2.     def __init__(self, input_dim): # 输入特征维度
3.         super(model_LR, self).__init__()
4.         self.params = {}
5.         # 将线性层的权重参数全部初始化为0
6.         self.params['w'] = paddle.zeros(shape=[input_dim, 1])
7.         # self.params['w'] = paddle.normal(mean=0, std=0.01, shape=[input_dim, 1])
8.         #这个是替代初始化方案，小随机数，实践中常用
9.         # 将线性层的偏置参数初始化为0
10.         self.params['b'] = paddle.zeros(shape=[1])
12.     def __call__(self, inputs): # 辅助方法
13.         #使类实例可像函数一样调用，使Python的特殊方法，实现对象可调用性
14.         return self.forward(inputs)
15.     #前向计算，
16.     def forward(self, inputs):
17.         """
18.         输入：
19.             - inputs: shape=[N,D], N是样本数量，D为特征维度
20.         输出：
21.             - outputs：预测标签为1（类别为1）的概率，shape=[N,1]
22.         """
23.         # 线性计算 ，matmul实现矩阵乘法 Xw，再加上偏置b
24.         score = paddle.matmul(inputs, self.params['w']) + self.params['b']
25.         # Logistic 函数，非线性激活，将分数映射到【0，1】中
26.         outputs = logistic(score)
27.         return outputs
29. # 固定随机种子，保持每次运行结果一致
30. paddle.seed(0)
31. # 随机生成3条长度为4的数据
32. inputs = paddle.randn(shape=[3,4])
33. print('Input is:', inputs)
34. # 实例化模型
35. model = model_LR(4)
36. outputs = model(inputs)
37. print('Output is:', outputs)

复制代码

输出结果：
   Input is: Tensor(shape=[3, 4], dtype=float32, place=CPUPlace, stop_gradient=True,
[[-0.75711036, -0.38059190, 0.10946669, 1.34467661],
[-0.84002435, -1.27341712, 2.47224617, 0.14070207],
[ 0.60608417, 0.23396523, 1.35604191, 0.10350471]])
Output is: Tensor(shape=[3, 1], dtype=float32, place=CPUPlace, stop_gradient=True,
[[0.50000000],
[0.50000000],
[0.50000000]])
  从输出结果看，模型终极的输出g(⋅)恒为0.5。这是由于采用全0初始化后，岂论输入值的大小为多少，Logistic函数的输入值恒为0，因此输出恒为0.5。
损失函数

这段内容重要阐述了在训练Logistic回归模型时，如何通过**交叉熵损失函数（Cross-Entropy Loss）**量化猜测概率与真实标签之间的差异，并给出了数学情势和直观意义。
使用损失函数量化猜测性hi和真实值之间的差异。现有一个分类使命，y表现样本x的标签的概率分布。
向量

表现猜测的标签概率分布，训练目标是使得猜测概率分布尽可能靠近真实概率分布，通常使用交叉熵损失函数。
在给定y的环境下，若猜测与真实越靠近，则交叉熵越小，反之，越大。
对于二分类使命：

Logistic回归的风险函数计算为：

向量化情势为：

二分类使命的交叉熵损失函数的代码实现如下：

1. import paddle
2. # 实现交叉熵损失函数
3. class BinaryCrossEntropyLoss(op.Op):
4.     def __init__(self):
5.         self.predicts = None  # 存储预测值
6.         self.labels = None   # 存储真实标签
7.         self.num = None    #存储样本数量
9. # 等同于直接调用前向计算
10.     def __call__(self, predicts, labels):
11.         return self.forward(predicts, labels)
13. #前向计算：完成了从模型输出到损失值的计算过程
14.     def forward(self, predicts, labels):
15.         """
16.         输入：
17.             - predicts：预测值，shape=[N, 1]，N为样本数量
18.             - labels：真实标签，shape=[N, 1]
19.         输出：
20.             - 损失值：shape=[1]
21.         """
22.         self.predicts = predicts
23.         self.labels = labels
24.         self.num = self.predicts.shape[0]
25.         #label.t() ：将列向量转为行向量，形状[1,N],方便矩阵乘法
26.         #paddle,log ：逐元素计算预测值的对数
27.         #损失计算：正类部分：label.t,log(perdicts),负类部分：1 - label.t这些
28.         loss = -1. / self.num * (paddle.matmul(self.labels.t(), paddle.log(self.predicts)) + paddle.matmul((1-self.labels.t()), paddle.log(1-self.predicts)))
29.         #压缩维度，去除多余维度。
30.         loss = paddle.squeeze(loss, axis=1)
31.         return loss
33. # 测试一下
34. # 生成一组长度为3，值为1的标签数据
35. labels = paddle.ones(shape=[3,1])
36. # 计算风险函数
37. bce_loss = BinaryCrossEntropyLoss()
38. # 有了call辅助方法，使得类实例可以想函数一样直接调用，如下。
39. print(bce_loss(outputs, labels))
41. #paddle.matmul(a, b)            矩阵乘法                         a、b 需满足矩阵乘法维度规则
42. #paddle.log(x)                    逐元素自然对数                      输入需为正数（用clip避免0）
43. #paddle.squeeze(x, axis)        压缩指定维度（长度为1的维度）        axis：需压缩的维度
44. #tensor.t()                        矩阵转置                         将 [N,1] 转为 [1,N]

复制代码

模型优化

   差别于线性回归中直接使用最小二乘法即可举行模型参数的求解，Logistic回归需要使用优化算法对模型参数举行有限次地迭代来获取更优的模型，从而尽可能地降低风险函数的值。 在呆板学习使命中，最简单、常用的优化算法是梯度降落法。
使用梯度降落法举行模型优化，首先需要初始化参数W和 b，然后不断地计算它们的梯度，并沿梯度的反方向更新参数。
  

通常将偏导数的计算过程定义在Logistic回归算子的backward函数中.代码实现如下：

2. class model_LR(op.Op):
3.     def __init__(self, input_dim):
4.         super(model_LR, self).__init__()
5.         # 存放线性层参数
6.         self.params = {}
7.         # 将线性层的权重参数全部初始化为0
8.         self.params['w'] = paddle.zeros(shape=[input_dim, 1])
9.         # self.params['w'] = paddle.normal(mean=0, std=0.01, shape=[input_dim, 1])
10.         # 将线性层的偏置参数初始化为0
11.         self.params['b'] = paddle.zeros(shape=[1])
12.         # 存放参数的梯度
13.         self.grads = {}
14.         self.X = None
15.         self.outputs = None
17.     def __call__(self, inputs):
18.         return self.forward(inputs)
20.     def forward(self, inputs):
21.         self.X = inputs
22.         # 线性计算
23.         score = paddle.matmul(inputs, self.params['w']) + self.params['b']
24.         # Logistic 函数
25.         self.outputs = logistic(score)
26.         return self.outputs
28.     def backward(self, labels):
29.         """
30.         输入：
31.             - labels：真实标签，shape=[N, 1]
32.         """
33.         N = labels.shape[0]
34.         # 计算偏导数
35.         self.grads['w'] = -1 / N * paddle.matmul(self.X.t(), (labels - self.outputs))
36.         self.grads['b'] = -1 / N * paddle.sum(labels - self.outputs)

复制代码

参数更新：计算参数梯度之后，按照下面的公式更新参数

把上面参数更新过程称为优化器。首先定义一个优化器基类Optimizer，方便后续的调用。在该类中，会初始化优化器的初始学习率init_ir，以及指定优化器需要优化的参数。代码实现如下：

1. from abc import abstractmethod
3. # 优化器基类
4. class Optimizer(object):
5.     def __init__(self, init_lr, model):
6.         """
7.         优化器类初始化
8.         """
9.         # 初始化学习率，用于参数更新的计算
10.         self.init_lr = init_lr
11.         # 指定优化器需要优化的模型
12.         self.model = model
13.     #表示这是一个抽象方法，子类必须重写该方法，否则抛出TypeError
14.     @abstractmethod
15.     def step(self):
16.         """
17.         定义每次迭代如何更新参数
18.         """
19.         pass

复制代码

然后实现一个梯度降落法的优化器函数SimpleBatchGD来执行参数更新过程。其中step函数从模型的grads属性取出参数的梯度并更新。代码实现如下：

1. #实现了简单的批量梯度下降优化器Sim，继承自Optimizer基类
2. class SimpleBatchGD(Optimizer):
3.     def __init__(self, init_lr, model):
4.         super(SimpleBatchGD, self).__init__(init_lr=init_lr, model=model)
5.     #调用父类Optimizer的·初始化方法，传入两个参数
6.    
7.     def step(self):
8.         # 参数更新
9.         # 遍历所有参数，按照公式(3.8)和(3.9)更新参数
10.         if isinstance(self.model.params, dict):
11.             for key in self.model.params.keys():
12.                 self.model.params[key] = self.model.params[key] - self.init_lr * self.model.grads[key]

复制代码

评价指标

在分类使命中，通常使用准确率（Accuracy）作为评价指标。如果模型猜测的类别与真实类别划一，则分析模型猜测精确。准确率即精确猜测的数量与总的猜测数量的比值：

其中I(⋅)是指示函数。
求准确率的代码实现如下：

1. def accuracy(preds, labels):
2.     """
3.     输入：
4.         - preds：预测值，二分类时，shape=[N, 1]，N为样本数量，多分类时，shape=[N, C]，C为类别数量
5.         --二分类任务时，每个样本通常通过sigmoid激活
6.         --多分类任务·时，每个样本通常通过softmax激活
7.         - labels：真实标签，shape=[N, 1]
8.     输出：
9.         - 准确率：shape=[1]
10.     """
11.     # 判断是二分类任务还是多分类任务，preds.shape[1]=1时为二分类任务，preds.shape[1]>1时为多分类任务
12.     if preds.shape[1] == 1:
13.         # 二分类时，判断每个概率值是否大于0.5，当大于0.5时，类别为1，否则类别为0
14.         # 使用'paddle.cast'将preds的数据类型转换为float32类型
15.         preds = paddle.cast((preds>=0.5),dtype='float32')
16.     else:
17.         # 多分类时，使用'paddle.argmax'，沿着类别维度（axis = 1）找到 每个样本预测分数最大的类别索引，返回的索引值作为预测类别
18.         preds = paddle.argmax(preds,axis=1, dtype='int32')
19.     #paddle.mean(): 计算平均值，也就是准确率
20.     #paddle.equal():逐元素比较预测类别和真实标签
21.     return paddle.mean(paddle.cast(paddle.equal(preds, labels),dtype='float32'))
23. # 假设模型的预测值为[[0.],[1.],[1.],[0.]]，真实类别为[[1.],[1.],[0.],[0.]]，计算准确率
24. preds = paddle.to_tensor([[0.],[1.],[1.],[0.]])
25. labels = paddle.to_tensor([[1.],[1.],[0.],[0.]])
26. print("accuracy is:", accuracy(preds, labels))

复制代码

完善Runner类

基于RunnerV1，本章的RunnerV2类在训练过程中使用梯度降落法举行网络优化，模型训练过程中计算在训练集和验证集上的损失及评估指标并打印，训练过程中保存最优模型。代码实现如下：

1. import paddle
2. # 用RunnerV2类封装整个训练过程
3. # 负责管理模型训练，验证，评估和保存的全过程
4. # RunnerV2 的主要目标时：①提供一个统一的训练过程框架；②自动化训练过程中的常见操作（梯度计算，参数更新等）
5. # ③记录训练指标和损失变化；④实现模型保存和加载功能；⑤支持训练过程中的监控和日志输出；
6. class RunnerV2(object):
7.     def __init__(self, model, optimizer, metric, loss_fn):
8.         '''
9.         -model: 包含前向计算和反向传播方法的模型
10.         -optimizer: 负责参数更新的优化器
11.         -metric: 评估模型的性能函数（准确率）
12.         -loss_fn: 计算模型损失函数（交叉熵）
13.         '''
14.         self.model = model
15.         self.optimizer = optimizer
16.         self.loss_fn = loss_fn
17.         self.metric = metric
18.         # 记录训练过程（训练集和验证集）中的评价指标变化情况
19.         self.train_scores = []
20.         self.dev_scores = []
21.         # 记录训练过程（训练集和验证集）中的损失函数变化情况
22.         self.train_loss = []
23.         self.dev_loss = []
25.     def train(self, train_set, dev_set, **kwargs):
26.         # 传入训练轮数，如果没有传入值则默认为0
27.         num_epochs = kwargs.get("num_epochs", 0)
28.         # 传入log打印频率，如果没有传入值则默认为100
29.         log_epochs = kwargs.get("log_epochs", 100)
30.         # 传入模型保存路径，如果没有传入值则默认为"best_model.pdparams"
31.         save_path = kwargs.get("save_path", "best_model.pdparams")
32.         # 梯度打印函数，如果没有传入则默认为"None"
33.         print_grads = kwargs.get("print_grads", None)
34.         # 记录全局最优指标
35.         best_score = 0
36.         # 进行num_epochs轮训练
37.         for epoch in range(num_epochs):
38.             X, y = train_set
39.             # 前向计算，获取模型预测
40.             logits = self.model(X)
41.             # 计算交叉熵损失
42.             trn_loss = self.loss_fn(logits, y).item()
43.             self.train_loss.append(trn_loss)
44.             # 计算评价指标
45.             trn_score = self.metric(logits, y).item()
46.             self.train_scores.append(trn_score)
47.             # 反向传播与优化：计算参数梯度
48.             self.model.backward(y)
49.             if print_grads is not None:
50.                 # 打印每一层的梯度
51.                 print_grads(self.model)
52.             # 更新模型参数
53.             self.optimizer.step() # 参数更新
54.             #验证步骤
55.             dev_score, dev_loss = self.evaluate(dev_set)
56.             # 如果当前指标为最优指标，保存该模型
57.             if dev_score > best_score:
58.                 self.save_model(save_path)
59.                 print(f"best accuracy performence has been updated: {best_score:.5f} --> {dev_score:.5f}")
60.                 best_score = dev_score
61.             #日志输出
62.             if epoch % log_epochs == 0:
63.                 print(f"[Train] epoch: {epoch}, loss: {trn_loss}, score: {trn_score}")
64.                 print(f"[Dev] epoch: {epoch}, loss: {dev_loss}, score: {dev_score}")
65.     #再给定数据集上评估模型性能，返回评估指标和损失值；记录历史评估结果         
66.     def evaluate(self, data_set):
67.         X, y = data_set
68.         # 计算模型输出
69.         logits = self.model(X)
70.         # 计算损失函数
71.         loss = self.loss_fn(logits, y).item()
72.         self.dev_loss.append(loss)
73.         # 计算评价指标
74.         score = self.metric(logits, y).item()
75.         self.dev_scores.append(score)
76.         return score, loss
78.     #模型预测
79.     #对输入数据进行预测，返回模型输出
80.     def predict(self, X):
81.         return self.model(X)
83.     # 模型保存
84.     def save_model(self, save_path):
85.         paddle.save(self.model.paramloadel_models, save_path)
87.     # 模型加载（loadel_model）
88.     def load_model(self, model_path):
89.         self.model.params = paddle.load(model_path)

复制代码

模型训练

下面举行Logistic回归模型的训练，使用交叉熵损失函数和梯度降落法举行优化。 使用训练集和验证集举行模型训练，共训练 500个epoch，每隔50个epoch打印出训练集上的指标。 代码实现如下：

1. # 固定随机种子，保持每次运行结果一致
2. paddle.seed(102)
4. # 特征维度
5. input_dim = 2
6. # 设置梯度下降的学习率，这是一个相对较大的学习率，适合Logistic回归这种简单模型
7. lr = 0.1
9. # 实例化模型
10. model = model_LR(input_dim=input_dim)
11. # 指定优化器，更新参数
12. optimizer = SimpleBatchGD(init_lr=lr, model=model)
13. # 指定损失函数
14. loss_fn = BinaryCrossEntropyLoss()
15. # 指定评价方式
16. metric = accuracy
18. # 实例化RunnerV2类(训练流程管理类),并传入训练配置
19. runner = RunnerV2(model, optimizer, metric, loss_fn)
20. # 训练执行
21. #-X_train: 训练数据，特征
22. #-y_train: 训练数据，标签
23. #-X_dev: 验证数据，特征
24. #-y_dev: 验证数据，输出值，评估模型泛化能力
25. #-num_epochs: 训练轮数
26. #-log_epochs:   每隔 log_epochs  轮打印一次日志
27. #-save_path:  最佳模型保存路径
28. runner.train([X_train, y_train], [X_dev, y_dev], num_epochs=500, log_epochs=50, save_path="best_model.pdparams")

复制代码

可视化观察训练集与验证集的准确率和损失的变革环境。

1. # 可视化观察训练集与验证集的指标变化情况
2. def plot(runner,fig_name):
3.     plt.figure(figsize=(10,5))
4.     plt.subplot(1,2,1)
5.     epochs = [i for i in range(len(runner.train_scores))]
6.     # 绘制训练损失变化曲线
7.     plt.plot(epochs, runner.train_loss, color='#8E004D', label="Train loss")
8.     # 绘制评价损失变化曲线
9.     plt.plot(epochs, runner.dev_loss, color='#E20079', linestyle='--', label="Dev loss")
10.     # 绘制坐标轴和图例
11.     plt.ylabel("loss")
12.     plt.xlabel("epoch")
13.     plt.legend(loc='upper right')
14.     plt.subplot(1,2,2)
15.     # 绘制训练准确率变化曲线
16.     plt.plot(epochs, runner.train_scores, color='#8E004D', label="Train accuracy")
17.     # 绘制评价准确率变化曲线
18.     plt.plot(epochs, runner.dev_scores, color='#E20079', linestyle='--', label="Dev accuracy")
19.     # 绘制坐标轴和图例
20.     plt.ylabel("score")
21.     plt.xlabel("epoch")
22.     plt.legend(loc='lower right')
23.     plt.tight_layout()
24.     plt.savefig(fig_name)
25.     plt.show()
27. plot(runner,fig_name='linear-acc.pdf')

复制代码

从输出结果可以看到，在训练集与验证集上，loss得到了收敛，同时准确率指标都到达了较高的程度，训练比较充实。
模型评价

使用测试集对训练完成后的终极模型举行评价，观察模型在测试集上的准确率和loss数据。代码实现如下：

1. score, loss = runner.evaluate([X_test, y_test])
2. print("[Test] score/loss: {:.4f}/{:.4f}".format(score, loss))

复制代码

输出指标：
score：评估指标得分（此处为准确率）
loss：损失函数值（此处为交叉熵损失）
输出结果：[Test] score/loss: 0.8350/0.3925
可视化观察拟合的决策界限 Xw+b=0。

1. def decision_boundary(w, b, x1):
2.     w1, w2 = w
3.     x2 = (- w1 * x1 - b) / w2
4.     return x2
6. plt.figure(figsize=(5,5))
7. # 绘制原始数据
8. plt.scatter(X[:, 0].tolist(), X[:, 1].tolist(), marker='*', c=y.tolist())
9. #X[:, 0]：第一个特征作为x轴，X[:, 1]：第二个特征作为y轴，c=y.tolist()：用颜色区分不同类别
10. #获取模型参数：
11. w = model.params['w']
12. b = model.params['b']
13. #生成决策边界：
14. x1 = paddle.linspace(-2, 3, 1000)
15. x2 = decision_boundary(w, b, x1)
16. # 绘制决策边界
17. plt.plot(x1.tolist(), x2.tolist(), color="red")
18. plt.show()

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。