神经网络与深度学习（五）前馈神经网络（3）鸢尾花分类
2024-06-03 06:53:04
目录
4.5实践：基于前馈神经网络完成鸢尾花分类
深入研究鸢尾花数据集
4.5.1 小批量梯度下降法
4.5.1.1 数据分组
4.5.2 数据处理
4.5.2.2 用DataLoader进行封装
4.5.3 模型构建
4.5.4 完善Runner类
4.5.5 模型训练
4.5.6 模型评价
4.5.7 模型预测
思考题
1. 对比Softmax分类和前馈神经网络分类。
2. 对比SVM与FNN分类效果，谈谈自己看法。
3. 尝试基于MNIST手写数字识别数据集，设计合适的前馈神经网络进行实验，并取得95%以上的准确率。
总结
参考资料
4.5实践：基于前馈神经网络完成鸢尾花分类
继续使用神经网络与深度学习（四）线性分类中3.3实践中的鸢尾花数据集，并将Softmax分类器替换为前馈神经网络进行分类任务。
- 损失函数：交叉熵损失；
- 优化器：随机梯度下降法；
- 评价指标：准确率。
深入研究鸢尾花数据集
【统计学习方法】感知机对鸢尾花(iris)数据集进行二分类_征途黯然.的博客-CSDN博客
所有属性之间的关系图：
4.5.1 小批量梯度下降法
【批量梯度下降法】在梯度下降法中，目标函数是整个训练集上的风险函数，这种方式称为批量梯度下降法（Batch Gradient Descent，BGD）。 批量梯度下降法在每次迭代时需要计算每个样本上损失函数的梯度并求和。当训练集中的样本数量N很大时，空间复杂度比较高，每次迭代的计算开销也很大。
【小批量梯度下降法】为了减少每次迭代的计算复杂度，我们可以在每次迭代时只采集一小部分样本，计算在这组样本上损失函数的梯度并更新参数，这种优化方式称为小批量梯度下降法（Mini-Batch Gradient Descent，Mini-Batch GD）。
第次迭代时，随机选取一个包含
个样本的子集
，计算这个子集上每个样本损失函数的梯度并进行平均，然后再进行参数更新。
其中为批量大小(Batch Size)。
通常不会设置很大，一般在1∼1001∼100之间。在实际应用中为了提高计算效率，通常设置为2的幂
。
在实际应用中，小批量随机梯度下降法有收敛快、计算开销小的优点，因此逐渐成为大规模的机器学习中的主要优化算法。此外，随机梯度下降相当于在批量梯度下降的梯度上引入了随机噪声。在非凸优化问题中，随机梯度下降更容易逃离局部最优点。
小批量随机梯度下降法的训练过程如下：
4.5.1.1 数据分组
为了使用小批量梯度下降法，我们需要对数据进行随机分组。目前，机器学习中通常做法是构建一个数据迭代器，每个迭代过程中从全部数据集中获取一批指定数量的数据。
（1）首先，将数据集封装为Dataset类，传入一组索引值，根据索引从数据集合中获取数据；
（2）其次，构建DataLoader类，需要指定数据批量的大小和是否需要对数据进行乱序，通过该类即可批量获取数据。
在实践过程中，通常使用进行参数优化。在pytorch中，使用torch.utils.data.DataLoader加载minibatch的数据，torch.utils.data.DataLoader API可以生成一个迭代器，其中通过设置batch_size参数来指定minibatch的长度，通过设置shuffle参数为True，可以在生成minibatch的索引列表时将索引顺序打乱。
4.5.2 数据处理
构造IrisDataset类进行数据读取，继承自torch.utils.data.Dataset类。torch.utils.data.Dataset是用来封装 Dataset的方法和行为的抽象类，通过一个索引获取指定的样本，同时对该样本进行数据处理。当继承torch.utils.data.Dataset来定义数据读取类时，实现如下方法：
__getitem__：根据给定索引获取数据集中指定样本，并对样本进行数据处理；__len__：返回数据集样本个数。
代码实现如下：
import torch
import numpy as np
import torch.utils.data
from nndl.load_data import load_dataclass IrisDataset(torch.utils.data.Dataset):def __init__(self, mode='train', num_train=120, num_dev=15):super(IrisDataset, self).__init__()# 调用第三章中的数据读取函数，其中不需要将标签转成one-hot类型X, y = load_data(shuffle=True)if mode == 'train':self.X, self.y = X[:num_train], y[:num_train]elif mode == 'dev':self.X, self.y = X[num_train:num_train + num_dev], y[num_train:num_train + num_dev]else:self.X, self.y = X[num_train + num_dev:], y[num_train + num_dev:]def __getitem__(self, idx):return self.X[idx], self.y[idx]def __len__(self):return len(self.y)torch.manual_seed(12)
train_dataset = IrisDataset(mode='train')
dev_dataset = IrisDataset(mode='dev')
test_dataset = IrisDataset(mode='test')
# 打印训练集长度
print("length of train set: ", len(train_dataset))运行结果：
注：其中load_data代码如下所示:
import torch
import numpy as np
from sklearn.datasets import load_iris# 加载数据集
def load_data(shuffle=True):# 加载原始数据X = np.array(load_iris().data, dtype=np.float32)y = np.array(load_iris().target, dtype=np.int32)X = torch.tensor(X)y = torch.tensor(y)# 数据归一化X_min = torch.min(X, dim=0)X_max = torch.max(X, dim=0)X = (X - X_min.values) / (X_max.values - X_min.values)# 如果shuffle为True，随机打乱数据if shuffle:idx = torch.randperm(X.shape[0])X = X[idx]y = y[idx]return X, y4.5.2.2 用DataLoader进行封装
# 批量大小
batch_size = 16# 加载数据
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
dev_loader = torch.utils.data.DataLoader(dev_dataset, batch_size=batch_size)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size)4.5.3 模型构建
构建一个简单的前馈神经网络进行鸢尾花分类实验。其中输入层神经元个数为4，输出层神经元个数为3，隐含层神经元个数为6。代码实现如下：
import torch.nn as nn
from torch.nn.init import constant_, normal_, uniform_# 定义前馈神经网络
class Model_MLP_L2_V3(nn.Module):def __init__(self, input_size, output_size, hidden_size):super(Model_MLP_L2_V3, self).__init__()# 构建第一个全连接层self.fc1 = nn.Linear(input_size, hidden_size)normal_(self.fc1.weight, mean=0.0, std=0.01)constant_(self.fc1.bias, val=1.0)# 构建第二全连接层self.fc2 = nn.Linear(hidden_size, output_size)normal_(self.fc2.weight, mean=0.0, std=0.01)constant_(self.fc2.bias, val=1.0)# 定义网络使用的激活函数self.act = nn.Sigmoid()def forward(self, inputs):outputs = self.fc1(inputs)outputs = self.act(outputs)outputs = self.fc2(outputs)return outputsfnn_model = Model_MLP_L2_V3(input_size=4, output_size=3, hidden_size=6)4.5.4 完善Runner类
基于RunnerV2类进行完善实现了RunnerV3类。其中训练过程使用自动梯度计算，使用DataLoader加载批量数据，使用随机梯度下降法进行参数优化；模型保存时，使用state_dict方法获取模型参数；模型加载时，使用set_state_dict方法加载模型参数.
由于这里使用随机梯度下降法对参数优化，所以数据以批次的形式输入到模型中进行训练，那么评价指标计算也是分别在每个批次进行的，要想获得每个epoch整体的评价结果，需要对历史评价结果进行累积。这里定义Accuracy类实现该功能。
import torchclass Accuracy():def __init__(self, is_logist=True):"""输入：- is_logist: outputs是logist还是激活后的值"""# 用于统计正确的样本个数self.num_correct = 0# 用于统计样本的总数self.num_count = 0self.is_logist = is_logistdef update(self, outputs, labels):"""输入：- outputs: 预测值, shape=[N,class_num]- labels: 标签值, shape=[N,1]"""# 判断是二分类任务还是多分类任务，shape[1]=1时为二分类任务，shape[1]>1时为多分类任务if outputs.shape[1] == 1: # 二分类outputs = torch.squeeze(outputs, dim=-1)if self.is_logist:# logist判断是否大于0preds = torch.tensor((outputs >= 0), dtype=torch.float32)else:# 如果不是logist，判断每个概率值是否大于0.5，当大于0.5时，类别为1，否则类别为0preds = torch.tensor((outputs >= 0.5), dtype=torch.float32)else:# 多分类时，使用'paddle.argmax'计算最大元素索引作为类别preds = torch.argmax(outputs, dim=1)preds = torch.tensor(preds, dtype=torch.int64)# 获取本批数据中预测正确的样本个数labels = torch.squeeze(labels, dim=-1)batch_correct = torch.sum(torch.tensor(preds == labels, dtype=torch.float32)).numpy()batch_count = len(labels)# 更新num_correct 和 num_countself.num_correct += batch_correctself.num_count += batch_countdef accumulate(self):# 使用累计的数据，计算总的指标if self.num_count == 0:return 0return self.num_correct / self.num_countdef reset(self):# 重置正确的数目和总数self.num_correct = 0self.num_count = 0def name(self):return "Accuracy"RunnerV3类的代码实现如下：
class RunnerV3(object):def __init__(self, model, optimizer, loss_fn, metric, **kwargs):self.model = modelself.optimizer = optimizerself.loss_fn = loss_fnself.metric = metric # 只用于计算评价指标# 记录训练过程中的评价指标变化情况self.dev_scores = []# 记录训练过程中的损失函数变化情况self.train_epoch_losses = [] # 一个epoch记录一次lossself.train_step_losses = [] # 一个step记录一次lossself.dev_losses = []# 记录全局最优指标self.best_score = 0def train(self, train_loader, dev_loader=None, **kwargs):# 将模型切换为训练模式self.model.train()# 传入训练轮数，如果没有传入值则默认为0num_epochs = kwargs.get("num_epochs", 0)# 传入log打印频率，如果没有传入值则默认为100log_steps = kwargs.get("log_steps", 100)# 评价频率eval_steps = kwargs.get("eval_steps", 0)# 传入模型保存路径，如果没有传入值则默认为"best_model.pdparams"save_path = kwargs.get("save_path", "best_model.pdparams")custom_print_log = kwargs.get("custom_print_log", None)# 训练总的步数num_training_steps = num_epochs * len(train_loader)if eval_steps:if self.metric is None:raise RuntimeError('Error: Metric can not be None!')if dev_loader is None:raise RuntimeError('Error: dev_loader can not be None!')# 运行的step数目global_step = 0# 进行num_epochs轮训练for epoch in range(num_epochs):# 用于统计训练集的损失total_loss = 0for step, data in enumerate(train_loader):X, y = data# 获取模型预测logits = self.model(X)y = torch.tensor(y, dtype=torch.int64)loss = self.loss_fn(logits, y) # 默认求meantotal_loss += loss# 训练过程中，每个step的loss进行保存self.train_step_losses.append((global_step, loss.item()))if log_steps and global_step % log_steps == 0:print(f"[Train] epoch: {epoch}/{num_epochs}, step: {global_step}/{num_training_steps}, loss: {loss.item():.5f}")# 梯度反向传播，计算每个参数的梯度值loss.backward()if custom_print_log:custom_print_log(self)# 小批量梯度下降进行参数更新self.optimizer.step()# 梯度归零self.optimizer.zero_grad()# 判断是否需要评价if eval_steps > 0 and global_step > 0 and \(global_step % eval_steps == 0 or global_step == (num_training_steps - 1)):dev_score, dev_loss = self.evaluate(dev_loader, global_step=global_step)print(f"[Evaluate] dev score: {dev_score:.5f}, dev loss: {dev_loss:.5f}")# 将模型切换为训练模式self.model.train()# 如果当前指标为最优指标，保存该模型if dev_score > self.best_score:self.save_model(save_path)print(f"[Evaluate] best accuracy performence has been updated: {self.best_score:.5f} --> {dev_score:.5f}")self.best_score = dev_scoreglobal_step += 1# 当前epoch 训练loss累计值trn_loss = (total_loss / len(train_loader)).item()# epoch粒度的训练loss保存self.train_epoch_losses.append(trn_loss)print("[Train] Training done!")# 模型评估阶段，使用'paddle.no_grad()'控制不计算和存储梯度@torch.no_grad()def evaluate(self, dev_loader, **kwargs):assert self.metric is not None# 将模型设置为评估模式self.model.eval()global_step = kwargs.get("global_step", -1)# 用于统计训练集的损失total_loss = 0# 重置评价self.metric.reset()# 遍历验证集每个批次for batch_id, data in enumerate(dev_loader):X, y = data# 计算模型输出logits = self.model(X)y = torch.tensor(y, dtype=torch.int64)# 计算损失函数loss = self.loss_fn(logits, y).item()# 累积损失total_loss += loss# 累积评价self.metric.update(logits, y)dev_loss = (total_loss / len(dev_loader))dev_score = self.metric.accumulate()# 记录验证集lossif global_step != -1:self.dev_losses.append((global_step, dev_loss))self.dev_scores.append(dev_score)return dev_score, dev_loss# 模型评估阶段，使用'paddle.no_grad()'控制不计算和存储梯度@torch.no_grad()def predict(self, x, **kwargs):# 将模型设置为评估模式self.model.eval()# 运行模型前向计算，得到预测值logits = self.model(x)return logitsdef save_model(self, save_path):torch.save(self.model.state_dict(), save_path)def load_model(self, model_path):model_state_dict = torch.load(model_path)self.model.set_state_dict(model_state_dict)4.5.5 模型训练
实例化RunnerV3类，并传入训练配置，代码实现如下：
import torch.optim as opt
import torch.nn.functional as Flr = 0.2
# 定义网络
model = fnn_model
# 定义优化器
optimizer = opt.SGD(lr=lr, params=model.parameters())
# 定义损失函数。softmax+交叉熵
loss_fn = F.cross_entropy
# 定义评价指标
metric = Accuracy(is_logist=True)
runner = RunnerV3(model, optimizer, loss_fn, metric)使用训练集和验证集进行模型训练，共训练150个epoch。在实验中，保存准确率最高的模型作为最佳模型。代码实现如下：
# 启动训练
log_steps = 100
eval_steps = 50
runner.train(train_loader, dev_loader, num_epochs=150, log_steps=log_steps, eval_steps=eval_steps, save_path="best_model.pdparams")运行结果：
[Train] epoch: 0/150, step: 0/1200, loss: 1.09898
[Evaluate] dev score: 0.33333, dev loss: 1.09582
[Evaluate] best accuracy performence has been updated: 0.00000 --> 0.33333
[Train] epoch: 12/150, step: 100/1200, loss: 1.13891
[Evaluate] dev score: 0.46667, dev loss: 1.10749
[Evaluate] best accuracy performence has been updated: 0.33333 --> 0.46667
[Evaluate] dev score: 0.20000, dev loss: 1.10089
[Train] epoch: 25/150, step: 200/1200, loss: 1.10158
[Evaluate] dev score: 0.20000, dev loss: 1.12477
[Evaluate] dev score: 0.46667, dev loss: 1.09090
[Train] epoch: 37/150, step: 300/1200, loss: 1.09982
[Evaluate] dev score: 0.46667, dev loss: 1.07537
[Evaluate] dev score: 0.53333, dev loss: 1.04453
[Evaluate] best accuracy performence has been updated: 0.46667 --> 0.53333
[Train] epoch: 50/150, step: 400/1200, loss: 1.01054
[Evaluate] dev score: 1.00000, dev loss: 1.00635
[Evaluate] best accuracy performence has been updated: 0.53333 --> 1.00000
[Evaluate] dev score: 0.86667, dev loss: 0.86850
[Train] epoch: 62/150, step: 500/1200, loss: 0.63702
[Evaluate] dev score: 0.80000, dev loss: 0.66986
[Evaluate] dev score: 0.86667, dev loss: 0.57089
[Train] epoch: 75/150, step: 600/1200, loss: 0.56490
[Evaluate] dev score: 0.93333, dev loss: 0.52392
[Evaluate] dev score: 0.86667, dev loss: 0.45410
[Train] epoch: 87/150, step: 700/1200, loss: 0.41929
[Evaluate] dev score: 0.86667, dev loss: 0.46156
[Evaluate] dev score: 0.93333, dev loss: 0.41593
[Train] epoch: 100/150, step: 800/1200, loss: 0.41047
[Evaluate] dev score: 0.93333, dev loss: 0.40600
[Evaluate] dev score: 0.93333, dev loss: 0.37672
[Train] epoch: 112/150, step: 900/1200, loss: 0.42777
[Evaluate] dev score: 0.93333, dev loss: 0.34534
[Evaluate] dev score: 0.93333, dev loss: 0.33552
[Train] epoch: 125/150, step: 1000/1200, loss: 0.30734
[Evaluate] dev score: 0.93333, dev loss: 0.31958
[Evaluate] dev score: 0.93333, dev loss: 0.32091
[Train] epoch: 137/150, step: 1100/1200, loss: 0.28321
[Evaluate] dev score: 0.93333, dev loss: 0.28383
[Evaluate] dev score: 0.93333, dev loss: 0.27171
[Evaluate] dev score: 0.93333, dev loss: 0.25447
[Train] Training done!可视化观察训练集损失和训练集loss变化情况。
import matplotlib.pyplot as plt# 绘制训练集和验证集的损失变化以及验证集上的准确率变化曲线
def plot_training_loss_acc(runner, fig_name,fig_size=(16, 6),sample_step=20,loss_legend_loc="upper right",acc_legend_loc="lower right",train_color="#e4007f",dev_color='#f19ec2',fontsize='large',train_linestyle="-",dev_linestyle='--'):plt.figure(figsize=fig_size)plt.subplot(1, 2, 1)train_items = runner.train_step_losses[::sample_step]train_steps = [x[0] for x in train_items]train_losses = [x[1] for x in train_items]plt.plot(train_steps, train_losses, color=train_color, linestyle=train_linestyle, label="Train loss")if len(runner.dev_losses) > 0:dev_steps = [x[0] for x in runner.dev_losses]dev_losses = [x[1] for x in runner.dev_losses]plt.plot(dev_steps, dev_losses, color=dev_color, linestyle=dev_linestyle, label="Dev loss")# 绘制坐标轴和图例plt.ylabel("loss", fontsize=fontsize)plt.xlabel("step", fontsize=fontsize)plt.legend(loc=loss_legend_loc, fontsize='x-large')# 绘制评价准确率变化曲线if len(runner.dev_scores) > 0:plt.subplot(1, 2, 2)plt.plot(dev_steps, runner.dev_scores,color=dev_color, linestyle=dev_linestyle, label="Dev accuracy")# 绘制坐标轴和图例plt.ylabel("score", fontsize=fontsize)plt.xlabel("step", fontsize=fontsize)plt.legend(loc=acc_legend_loc, fontsize='x-large')plt.savefig(fig_name)plt.show()plot_training_loss_acc(runner, 'fw-loss.pdf')运行结果：
从输出结果可以看出准确率随着迭代次数增加逐渐上升，损失函数下降。
4.5.6 模型评价
使用测试数据对在训练过程中保存的最佳模型进行评价，观察模型在测试集上的准确率以及Loss情况。代码实现如下：
# 加载最优模型
runner.load_model('best_model.pdparams')
# 模型评价
score, loss = runner.evaluate(test_loader)
print("[Test] accuracy/loss: {:.4f}/{:.4f}".format(score, loss))运行结果：
4.5.7 模型预测
同样地，也可以使用保存好的模型，对测试集中的某一个数据进行模型预测，观察模型效果。代码实现如下：
# 模型评价
score, loss = runner.evaluate(test_loader)
print("[Test] accuracy/loss: {:.4f}/{:.4f}".format(score, loss))
test_loader = iter(test_loader)
# 获取测试集中第一条数据
(X, label) = next(test_loader)
logits = runner.predict(X)
pred_class = torch.argmax(logits[0]).numpy()
label = label.numpy()[0]# 输出真实类别与预测类别
print("The true category is {} and the predicted category is {}".format(label, pred_class))运行结果：
[Test] accuracy/loss: 1.0000/0.2396
The true category is 2 and the predicted category is 2思考题
1. 对比Softmax分类和前馈神经网络分类。
Softmax分类：
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.linear_model import LogisticRegression
from matplotlib.colors import ListedColormapiris = datasets.load_iris() # 加载数据
list(iris.keys()) # 属性
X = iris["data"][:, (2, 3)] # 花瓣长度, 花瓣宽度
y = iris["target"]
# 设置超参数multi_class为"multinomial"，指定一个支持Softmax回归的求解器，默认使用l2正则化，可以通过超参数C进行控制
softmax_reg = LogisticRegression(multi_class="multinomial", solver="lbfgs", C=500, random_state=42)
softmax_reg.fit(X, y)
softmax_reg.predict([[5, 2]]) # 输出：array([2])
softmax_reg.predict_proba([[5, 2]])
x0, x1 = np.meshgrid(np.linspace(0, 8, 500).reshape(-1, 1), np.linspace(0, 3.5, 200).reshape(-1, 1))
X_new = np.c_[x0.ravel(), x1.ravel()]
y_proba = softmax_reg.predict_proba(X_new)
y_predict = softmax_reg.predict(X_new)
zz1 = y_proba[:, 1].reshape(x0.shape)
zz = y_predict.reshape(x0.shape)
plt.figure(figsize=(10, 4))
plt.plot(X[y == 2, 0], X[y == 2, 1], "g^", label="Iris virginica")
plt.plot(X[y == 1, 0], X[y == 1, 1], "bs", label="Iris versicolor")
plt.plot(X[y == 0, 0], X[y == 0, 1], "yo", label="Iris setosa")
custom_cmap = ListedColormap(['#fafab0', '#9898ff', '#a0faa0'])
plt.contourf(x0, x1, zz, cmap=custom_cmap)
plt.xlabel("Petal length", fontsize=14)
plt.ylabel("Petal width", fontsize=14)
plt.legend(loc="center left", fontsize=14)
plt.axis([0, 7, 0, 3.5])
plt.show()运行结果：
from sklearn.datasets import load_iris
import pandas
import numpy as np
import matplotlib.pyplot as plt # 可视化工具
import torch
from nndl import op
from nndl import op, metric, opitimizeriris_features = np.array(load_iris().data, dtype=np.float32)
iris_labels = np.array(load_iris().target, dtype=np.int32)
print(pandas.isna(iris_features).sum())
print(pandas.isna(iris_labels).sum())# 箱线图查看异常值分布
def boxplot(features):feature_names = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']# 连续画几个图片plt.figure(figsize=(5, 5), dpi=200)# 子图调整plt.subplots_adjust(wspace=0.6)# 每个特征画一个箱线图for i in range(4):plt.subplot(2, 2, i+1)# 画箱线图plt.boxplot(features[:, i],showmeans=True,whiskerprops={"color":"#E20079", "linewidth":0.4, 'linestyle':"--"},flierprops={"markersize":0.4},meanprops={"markersize":1})# 图名plt.title(feature_names[i], fontdict={"size":5}, pad=2)# y方向刻度plt.yticks(fontsize=4, rotation=90)plt.tick_params(pad=0.5)# x方向刻度plt.xticks([])plt.savefig('ml-vis.pdf')plt.show()boxplot(iris_features)# 加载数据集
def load_data(shuffle=True):# 加载原始数据X = np.array(load_iris().data, dtype=np.float32)y = np.array(load_iris().target, dtype=np.int32)X = torch.tensor(X)y = torch.tensor(y)# 数据归一化X_min = torch.min(X, dim=0)X_max = torch.max(X, dim=0)X = (X-X_min.values) / (X_max.values-X_min.values)# 如果shuffle为True，随机打乱数据if shuffle:idx = torch.randperm(X.shape[0])X = X[idx]y = y[idx]return X, y# 固定随机种子
torch.manual_seed(102)num_train = 120
num_dev = 15
num_test = 15X, y = load_data(shuffle=True)
print("X shape: ", X.shape, "y shape: ", y.shape)
X_train, y_train = X[:num_train], y[:num_train]
X_dev, y_dev = X[num_train:num_train + num_dev], y[num_train:num_train + num_dev]
X_test, y_test = X[num_train + num_dev:], y[num_train + num_dev:]
# 打印X_train和y_train的维度
print("X_train shape: ", X_train.shape, "y_train shape: ", y_train.shape)
# 打印前5个数据的标签
print(y_train[:5])
# 输入维度
input_dim = 4
# 类别数
output_dim = 3
# 实例化模型
model = op.model_SR(input_dim=input_dim, output_dim=output_dim)class RunnerV2(object):def __init__(self, model, optimizer, metric, loss_fn):self.model = modelself.optimizer = optimizerself.loss_fn = loss_fnself.metric = metric# 记录训练过程中的评价指标变化情况self.train_scores = []self.dev_scores = []# 记录训练过程中的损失函数变化情况self.train_loss = []self.dev_loss = []def train(self, train_set, dev_set, **kwargs):# 传入训练轮数，如果没有传入值则默认为0num_epochs = kwargs.get("num_epochs", 0)# 传入log打印频率，如果没有传入值则默认为100log_epochs = kwargs.get("log_epochs", 100)# 传入模型保存路径，如果没有传入值则默认为"best_model.pdparams"save_path = kwargs.get("save_path", "best_model.pdparams")# 梯度打印函数，如果没有传入则默认为"None"print_grads = kwargs.get("print_grads", None)# 记录全局最优指标best_score = 0# 进行num_epochs轮训练for epoch in range(num_epochs):X, y = train_set# 获取模型预测logits = self.model(X)# 计算交叉熵损失trn_loss = self.loss_fn(logits, y).item()self.train_loss.append(trn_loss)# 计算评价指标trn_score = self.metric(logits, y).item()self.train_scores.append(trn_score)# 计算参数梯度self.model.backward(y)if print_grads is not None:# 打印每一层的梯度print_grads(self.model)# 更新模型参数self.optimizer.step()dev_score, dev_loss = self.evaluate(dev_set)# 如果当前指标为最优指标，保存该模型if dev_score > best_score:self.save_model(save_path)print(f"best accuracy performence has been updated: {best_score:.5f} --> {dev_score:.5f}")best_score = dev_scoreif epoch % log_epochs == 0:print(f"[Train] epoch: {epoch}, loss: {trn_loss}, score: {trn_score}")print(f"[Dev] epoch: {epoch}, loss: {dev_loss}, score: {dev_score}")def evaluate(self, data_set):X, y = data_set# 计算模型输出logits = self.model(X)# 计算损失函数loss = self.loss_fn(logits, y).item()self.dev_loss.append(loss)# 计算评价指标score = self.metric(logits, y).item()self.dev_scores.append(score)return score, lossdef predict(self, X):return self.model(X)def save_model(self, save_path):torch.save(self.model.params, save_path)def load_model(self, model_path):self.model.params = torch.load(model_path)# 学习率
lr = 0.2# 梯度下降法
optimizer = opitimizer.SimpleBatchGD(init_lr=lr, model=model)
# 交叉熵损失
loss_fn = op.MultiCrossEntropyLoss()
# 准确率
metric = metric.accuracy# 实例化RunnerV2
runner = RunnerV2(model, optimizer, metric, loss_fn)# 启动训练
runner.train([X_train, y_train], [X_dev, y_dev], num_epochs=200, log_epochs=10, save_path="best_model.pdparams")def plot(runner, fig_name):plt.figure(figsize=(10, 5))plt.subplot(1, 2, 1)epochs = [i for i in range(len(runner.train_scores))]# 绘制训练损失变化曲线plt.plot(epochs, runner.train_loss, color='#e4007f', label="Train loss")# 绘制评价损失变化曲线plt.plot(epochs, runner.dev_loss, color='#f19ec2', linestyle='--', label="Dev loss")# 绘制坐标轴和图例plt.ylabel("loss", fontsize='large')plt.xlabel("epoch", fontsize='large')plt.legend(loc='upper right', fontsize='x-large')plt.subplot(1, 2, 2)# 绘制训练准确率变化曲线plt.plot(epochs, runner.train_scores, color='#e4007f', label="Train accuracy")# 绘制评价准确率变化曲线plt.plot(epochs, runner.dev_scores, color='#f19ec2', linestyle='--', label="Dev accuracy")# 绘制坐标轴和图例plt.ylabel("score", fontsize='large')plt.xlabel("epoch", fontsize='large')plt.legend(loc='lower right', fontsize='x-large')plt.tight_layout()plt.savefig(fig_name)plt.show()plot(runner,fig_name='linear-acc3.pdf')# 加载最优模型
runner.load_model('best_model.pdparams')
# 模型评价
score, loss = runner.evaluate([X_test, y_test])
print("[Test] score/loss: {:.4f}/{:.4f}".format(score, loss))
# 预测测试集数据
logits = runner.predict(X_test)
# 观察其中一条样本的预测结果
pred = torch.argmax(logits[0]).numpy()
# 获取该样本概率最大的类别
label = y_test[0].numpy()
# 输出真实类别与预测类别
print("The true category is {} and the predicted category is {}".format(label, pred))
Softmax分类结果：
前馈神经网络分类结果：
对比两种结果可知对于鸢尾花分类，前馈神经网络的准确率要高于Softmax分类。
2. 对比SVM与FNN分类效果，谈谈自己看法。
SVM
优点：非线性映射理论基础，利用核函数代替了高维空间的映射，最大化间隔是核心，支持向量是训练的结果，最终结果是少量的向量决定的，可以提出较大的样本，所以有较小的鲁棒性。
缺点：对大规模训练难以实施，解决多分类有很大的困难。
FNN
优点：可实现非线性映射，有自学能力，有推广概括能力。
缺点：采用梯度下降法，速度慢，有可能进入局部最小值而训练失败，新加入的样本有影响，可能会出现欠学习或过学习。
3. 尝试基于MNIST手写数字识别数据集，设计合适的前馈神经网络进行实验，并取得95%以上的准确率。
import torch
import torch.nn as nn
from matplotlib import pyplot as plt
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasetsbatch_size = 64
lr = 0.01
momentum = 0.5
epoch = 5# 归一化
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
# train=True训练集，=False测试集
train_dataset = datasets.MNIST(root='./pythonProject/mnist', train=True, transform=transform, download=True)
test_dataset = datasets.MNIST(root='./pythonProject/mnist', train=False, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)fig = plt.figure()
for i in range(12):plt.subplot(3, 4, i+1)plt.tight_layout()plt.imshow(train_dataset.train_data[i], cmap='gray', interpolation='none')plt.title("Labels: {}".format(train_dataset.train_labels[i]))plt.xticks([])plt.yticks([])
plt.show()# 定义前馈神经网络
class Model_MLP_L2_V3(nn.Module):def __init__(self):super(Model_MLP_L2_V3, self).__init__()self.conv1 = torch.nn.Sequential(torch.nn.Conv2d(1, 10, kernel_size=(5, 5)), torch.nn.ReLU(), torch.nn.MaxPool2d(kernel_size=2))self.conv2 = torch.nn.Sequential(torch.nn.Conv2d(10, 20, kernel_size=(5, 5)), torch.nn.ReLU(), torch.nn.MaxPool2d(kernel_size=2))self.fc = torch.nn.Sequential(torch.nn.Linear(320, 50), torch.nn.Linear(50, 10))def forward(self, x):batch_size = x.size(0)x = self.conv1(x) # 一层卷积层,一层池化层,一层激活层x = self.conv2(x)x = x.view(batch_size, -1) # flatten变成全连接网络需要的输入(batch, 20,4,4)==>(batch,320),-1此处自动算出的是320x = self.fc(x)return xmodel = Model_MLP_L2_V3()# 设置损失函数和优化器
criterion = torch.nn.CrossEntropyLoss() # 交叉熵损失
optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=momentum)def train(epoch):running_loss = 0.0 # 这整个epoch的loss清零running_total = 0running_correct = 0for batch_idx, data in enumerate(train_loader, 0):inputs, target = dataoptimizer.zero_grad()# forward + backward + updateoutputs = model(inputs)loss = criterion(outputs, target)loss.backward()optimizer.step()# 把运行中的loss累加起来，为了下面300次一除running_loss += loss.item()# 把运行中的准确率acc算出来_, predicted = torch.max(outputs.data, dim=1)running_total += inputs.shape[0]running_correct += (predicted == target).sum().item()if batch_idx % 100 == 99:print('[%d, %5d]: loss: %.3f , acc: %.2f %%' % (epoch + 1, batch_idx + 1, running_loss / 300, 100 * running_correct / running_total))running_loss = 0.0 # 该批次loss清零running_total = 0running_correct = 0 # 该批次acc清零def test():correct = 0total = 0with torch.no_grad():for data in test_loader:images, labels = dataoutputs = model(images)_, predicted = torch.max(outputs.data, dim=1) # dim=1 列是第0个维度，行是第1个维度，沿着行(第1个维度)去找1.最大值和2.最大值的下标total += labels.size(0) # 张量之间的比较运算correct += (predicted == labels).sum().item()accuracy = correct / total # 测试准确率=正确数/总数print('[%d]: Accuracy on test set: %.1f %% ' % (epoch+1, 100 * accuracy))return accuracy# 主函数
if __name__ == '__main__':acc_list_test = []for epoch in range(epoch):train(epoch)acc_test = test()acc_list_test.append(acc_test)plt.plot(acc_list_test)plt.xlabel('Epoch')plt.ylabel('Accuracy')plt.show()
运行结果：
[1, 100]: loss: 0.480 , acc: 57.27 %
[1, 200]: loss: 0.148 , acc: 86.47 %
[1, 300]: loss: 0.115 , acc: 89.55 %
[1, 400]: loss: 0.090 , acc: 91.84 %
[1, 500]: loss: 0.074 , acc: 93.62 %
[1, 600]: loss: 0.067 , acc: 94.02 %
[1, 700]: loss: 0.057 , acc: 94.55 %
[1, 800]: loss: 0.058 , acc: 94.98 %
[1, 900]: loss: 0.050 , acc: 95.53 %
[1]: Accuracy on test set: 96.4 %
[2, 100]: loss: 0.041 , acc: 96.28 %
[2, 200]: loss: 0.047 , acc: 95.88 %
[2, 300]: loss: 0.038 , acc: 96.66 %
[2, 400]: loss: 0.043 , acc: 96.20 %
[2, 500]: loss: 0.033 , acc: 96.91 %
[2, 600]: loss: 0.034 , acc: 96.77 %
[2, 700]: loss: 0.031 , acc: 97.08 %
[2, 800]: loss: 0.037 , acc: 96.50 %
[2, 900]: loss: 0.033 , acc: 97.16 %
[2]: Accuracy on test set: 97.8 %
[3, 100]: loss: 0.030 , acc: 97.55 %
[3, 200]: loss: 0.029 , acc: 97.39 %
[3, 300]: loss: 0.029 , acc: 97.25 %
[3, 400]: loss: 0.029 , acc: 97.36 %
[3, 500]: loss: 0.025 , acc: 97.48 %
[3, 600]: loss: 0.028 , acc: 97.36 %
[3, 700]: loss: 0.025 , acc: 97.75 %
[3, 800]: loss: 0.024 , acc: 97.88 %
[3, 900]: loss: 0.026 , acc: 97.67 %
[3]: Accuracy on test set: 97.8 %
[4, 100]: loss: 0.026 , acc: 97.75 %
[4, 200]: loss: 0.023 , acc: 97.89 %
[4, 300]: loss: 0.023 , acc: 97.84 %
[4, 400]: loss: 0.020 , acc: 98.27 %
[4, 500]: loss: 0.023 , acc: 98.02 %
[4, 600]: loss: 0.023 , acc: 97.97 %
[4, 700]: loss: 0.022 , acc: 97.95 %
[4, 800]: loss: 0.026 , acc: 97.39 %
[4, 900]: loss: 0.021 , acc: 98.23 %
[4]: Accuracy on test set: 98.4 %
[5, 100]: loss: 0.020 , acc: 98.19 %
[5, 200]: loss: 0.022 , acc: 97.94 %
[5, 300]: loss: 0.021 , acc: 97.94 %
[5, 400]: loss: 0.021 , acc: 98.06 %
[5, 500]: loss: 0.017 , acc: 98.41 %
[5, 600]: loss: 0.020 , acc: 98.12 %
[5, 700]: loss: 0.022 , acc: 97.92 %
[5, 800]: loss: 0.018 , acc: 98.28 %
[5, 900]: loss: 0.020 , acc: 98.20 %
[5]: Accuracy on test set: 98.4 %
总结
此次通过使用前馈神经网络完成鸢尾花分类任务，在此深化理解了前馈神经网络的基本概念、网络结构及代码实现。此外还基于MNIST手写数字识别数据集，设计合适的前馈神经网络进行实验。在此次实验中，出现最多的报错就是数据类型上的错误，在完成后面的实验时会对这个方面多加留意。
前馈神经网络知识点梳理——思维导图：
参考资料
用PyTorch实现MNIST手写数字识别(非常详细) - 知乎 (zhihu.com)
【学习笔记】前馈神经网络（ANN） - Lugendary - 博客园 (cnblogs.com)
机器学习——前馈神经网络 - NeilZhang - 博客园 (cnblogs.com
逻辑回归、Softmax回归 --- 鸢尾花分类_劳埃德·福杰的博客-CSDN博客_iris softmax回归
神经网络与深度学习（五）前馈神经网络（3）鸢尾花分类相关推荐
- 深度学习3 前馈神经网络
深度学习3 前馈神经网络 目录 深度学习3 前馈神经网络 1. 神经元模型(M-P) (1)公式 (2)运算 (3)结构 2. 感知机模型 (1)单层感知机 (2)多层感知器 (3)BP算法 1. 神 ...
- 水很深的深度学习-Task03前馈神经网络
本文参考 Datawhale:水很深的深度学习 深度学习(四)-前馈神经网络_未名湖畔的落叶-CSDN博客_前馈神经网络 神经元模型 在前馈神经网络中,各神经元分别属于不同的层.每一层的神经元可以 ...
- 01.神经网络和深度学习 W4.深层神经网络（作业：建立你的深度神经网络+图片猫预测）
文章目录 作业1. 建立你的深度神经网络 1. 导入包 2. 算法主要流程 3. 初始化 3.1 两层神经网络 3.2 多层神经网络 4. 前向传播 4.1 线性模块 4.2 线性激活模块 4.3 多 ...
- 吴恩达神经网络与深度学习——浅层神经网络
吴恩达神经网络与深度学习--浅层神经网络 神经网络概述 神经网络表示 计算神经网络的输出 m个样本的向量化 for loop 向量化 向量化实现的解释 激活函数 sigmoid tanh函数 ReLu ...
- 深度学习(四)-前馈神经网络
在前馈神经网络中,各神经元分别属于不同的层.每一层的神经元可以接收前一层神经元的信号,并产生信号输出到下一层.第 0 层叫输入层,最后一层叫输出层,其它中间层叫做隐藏层,相邻两层的神经元之间为全连 ...
- 剖析大数据、人工智能、机器学习、神经网络、深度学习五者之区别与联系
1 引言 当下时代,无论你是否专业于CS,想必都应当听过大数据.人工智能.机器学习.神经网络与深度学习这几个热词.他们区别明显却又联系紧密,有些互有交集,有些又是另一部分的子集.基于上述原因,现作文一 ...
- 深度学习入门——前馈神经网络
前馈神经网络作为深度学习基础中的基础,是很多同学入门深度学习的必经之路.由于马上要迎来考试复习周,在这里简单记录一下学习心得. 感知机模型 感知机(perceptron)是深度学习中最基本的元素,很多 ...
- 深度学习之前馈神经网络（前向传播和误差反向传播）
转自:https://www.cnblogs.com/Luv-GEM/p/10694471.html 这篇文章主要整理三部分内容,一是常见的三种神经网络结构:前馈神经网络.反馈神经网络和图网络:二是整 ...
- 深度学习：前馈神经网络
对深度学习(或称神经网络)的探索通常从它在计算机视觉中的应用入手.计算机视觉属于人工智能领域,因深度学习技术而不断革新,并且计算机视觉的基础(光强度)是用实数来表示的,处理实数正是神经网络所擅长的. ...
- 【深度学习】前馈神经网络
一.前馈神经网络 思维导图 线性问题分为两个: 1.与门 IN IN OUT 1 1 1 1 0 0 0 1 0 0 0 0 2.或门 IN IN OUT 1 1 1 1 0 1 0 1 1 0 0 ...
最新文章
- OSI，TCP/IP，五层协议的体系结构，以及各层协议
- JAVA并发-为现有的线程安全类添加原子方法
- Python Django模板语法标签代码示例（页面渲染与取值）
- leetcode 211. Design Add and Search Words Data Structure | 211. 添加与搜索单词 - 数据结构设计（Java）
- JAGUARSDN1网络的开机自动启动 禁用，WIFI模块的启动关闭控制
- mysql server远程连接_本地远程连接 MySQL server
- 迅速步入jQuery的殿堂
- 解决手动运行脚本执行正常而放入crontab后不正常的方法
- kafka分区和es的分区支持对比
- mysql序列化字段反序列化_序列化serialize()与反序列化unserialize()的实例
- eclipse启动tomcat报错：org.apache.logging.log4j.web.Log4jServletContextListener
- 机器学习 之 Hog特征
- 2012最新网上购物排行榜
- 联想y50更换固态硬盘_联想y50怎么加固态硬盘而不换原来的机器硬盘？
- php排课系统设计,基于PHP+MYSQL教务排课系统设计实现论文
- thinkphp 对接阿里云短信支付，其主要是新版composer对接阿里短信
- Allegro删除Out of data shape铜皮框
- mediasoup推拉流分析
- 20220326-代码日记-Unity画符
- 千万融资资金为何青睐edge这家公司？
热门文章
- 史上最有效地选出第二天一定能大幅上涨的选股方法
- 微信小程序云开发数据库 网页管理后台
- 甘肃省金昌市谷歌卫星地图下载(百度网盘离线包下载)
- python 新媒体素材_新媒体运营日常工作是怎样的？
- # 工欲善其事必先利其器-C语言拓展--嵌入式C语言（四）
- http://www.ibm.com/developerworks/cn/opensource/os-cn-cas/
- (跨域问题)Access to XMLHttpRequest at xxx from origin xxx
- 在LINUX下玩小游戏
- acm-(dp、最小树形图)Sichuan State Programming Contest 2011 I.Smart Typist
- 【最短路】【Heap-dijkstra】hihocoder 1587 ACM-ICPC国际大学生程序设计竞赛北京赛区(2017)网络赛 J. Typist's Problem...