文章目录
深入研究鸢尾花数据集
画出数据集中150个数据的前两个特征的散点分布图
代码如下：
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mp
from sklearn.datasets import load_iris
#在图中显示中文
mp.rcParams['font.sans-serif'] = [u'SimHei']
mp.rcParams['axes.unicode_minus'] = False
iris = load_iris()
##取150个样本，取前两列特征，花萼长度和宽度
x=iris.data[0:150,1:3] #能看特征数据的具体信息
y=iris.target[0:150] #能看每行数据的标签的值
##分别取前两类样本，0和1
samples_0 = x[y==0, :]#把y=0,即Iris-setosa的样本取出来
samples_1 = x[y==1, :]#把y=1，即Iris-versicolo的样本取出来
samples_2 = x[y==2, :]#把y=2，即Iris-virginica的样本取出来
#散点图可视化
plt.scatter(samples_0[:,0],samples_0[:,1],marker='o',color='r')
plt.scatter(samples_1[:,0],samples_1[:,1],marker='x',color='b')
plt.scatter(samples_2[:,0],samples_2[:,1],marker='*',color='y')
plt.legend(['iris versicolor','iris setosa','iris vlrglnica'])
plt.xlabel('花萼宽度', fontsize=14)
plt.ylabel('花瓣长度',fontsize=14)
plt.show()
运行结果：
4.5 实践：基于前馈神经网络完成鸢尾花分类
继续使用第三章中的鸢尾花分类任务，将Softmax分类器替换为前馈神经网络。
损失函数：交叉熵损失；
优化器：随机梯度下降法；
评价指标：准确率。
4.5.1 小批量梯度下降法
在梯度下降法中，目标函数是整个训练集上的风险函数，这种方式称为批量梯度下降法（Batch Gradient Descent，BGD）。 批量梯度下降法在每次迭代时需要计算每个样本上损失函数的梯度并求和。当训练集中的样本数量N很大时，空间复杂度比较高，每次迭代的计算开销也很大。
为了减少每次迭代的计算复杂度，我们可以在每次迭代时只采集一小部分样本，计算在这组样本上损失函数的梯度并更新参数，这种优化方式称为小批量梯度下降法（Mini-Batch Gradient Descent，Mini-Batch GD）。
为了小批量梯度下降法，我们需要对数据进行随机分组。
小批量随机梯度下降法的训练过程如下：
目前，机器学习中通常做法是构建一个数据迭代器，每个迭代过程中从全部数据集中获取一批指定数量的数据。
4.5.1.1 数据分组
为了小批量梯度下降法，我们需要对数据进行随机分组。目前，机器学习中通常做法是构建一个数据迭代器，每个迭代过程中从全部数据集中获取一批指定数量的数据。
数据迭代器的实现原理如下图所示：
1.首先，将数据集封装为Dataset类，传入一组索引值，根据索引从数据集合中获取数据；
2.其次，构建DataLoader类，需要指定数据批量的大小和是否需要对数据进行乱序，通过该类即可批量获取数据。
4.5.2 数据处理
构造IrisDataset类进行数据读取，继承自paddle.io.Dataset类。paddle.io.Dataset是用来封装 Dataset的方法和行为的抽象类，通过一个索引获取指定的样本，同时对该样本进行数据处理。当继承paddle.io.Dataset来定义数据读取类时，实现如下方法：
getitem：根据给定索引获取数据集中指定样本，并对样本进行数据处理；
len：返回数据集样本个数。
4.5.2.1 加载数据集
代码如下：
import torch
import numpy as np
import torch.utils.data
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, y
class 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))
运行结果：
4.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。
代码如下：
# 定义前馈神经网络
class Model_MLP_L2_V3(torch.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)
nn.init.normal_(tensor=self.fc1.weight,mean=0.0, std=0.01)
nn.init.constant_(tensor=self.fc1.bias,val=1.0)
# 构建第二全连接层
self.fc2 = nn.Linear(hidden_size,output_size)
nn.init.normal_(tensor=self.fc2.weight,mean=0.0, std=0.01)
nn.init.constant_(tensor=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 outputs
fnn_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 torchmetrics as Metric
class Accuracy():
def __init__(self, is_logist=True):
"""
输入：
- is_logist: outputs是logist还是激活后的值
"""
# 用于统计正确的样本个数
self.num_correct = 0
# 用于统计样本的总数
self.num_count = 0
self.is_logist = is_logist
def 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, axis=-1)
if self.is_logist:
# logist判断是否大于0
preds = troch.can_cast((outputs>=0), dtype=torch.float32)
else:
# 如果不是logist，判断每个概率值是否大于0.5，当大于0.5时，类别为1，否则类别为0
preds = torch.can_cast((outputs>=0.5), dtype=torch.float32)
else:
# 多分类时，使用'paddle.argmax'计算最大元素索引作为类别
preds = torch.argmax(outputs, dim=1).int()
# 获取本批数据中预测正确的样本个数
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_count
self.num_correct += batch_correct
self.num_count += batch_count
def accumulate(self):
# 使用累计的数据，计算总的指标
if self.num_count == 0:
return 0
return self.num_correct / self.num_count
def reset(self):
# 重置正确的数目和总数
self.num_correct = 0
self.num_count = 0
def name(self):
return "Accuracy"
RunnerV3类的实现
代码如下：
import torch.nn.functional as F
class RunnerV3(object):
def __init__(self, model, optimizer, loss_fn, metric, **kwargs):
self.model = model
self.optimizer = optimizer
self.loss_fn = loss_fn
self.metric = metric # 只用于计算评价指标
# 记录训练过程中的评价指标变化情况
self.dev_scores = []
# 记录训练过程中的损失函数变化情况
self.train_epoch_losses = [] # 一个epoch记录一次loss
self.train_step_losses = [] # 一个step记录一次loss
self.dev_losses = []
# 记录全局最优指标
self.best_score = 0
def train(self, train_loader, dev_loader=None, **kwargs):
# 将模型切换为训练模式
self.model.train()
# 传入训练轮数，如果没有传入值则默认为0
num_epochs = kwargs.get("num_epochs", 0)
# 传入log打印频率，如果没有传入值则默认为100
log_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 = 0
for step, data in enumerate(train_loader):
X, y = data
# 获取模型预测
logits = self.model(X)
loss = self.loss_fn(logits, y) # 默认求mean
total_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_score
global_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)
# 计算损失函数
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()
# 记录验证集loss
if 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 logits
def 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.state_dict(model_state_dict)
4.5.5 模型训练
实例化RunnerV3类，并传入训练配置
代码如下：
import torch.optim as opt
lr = 0.2
# 定义网络
model = fnn_model
# 定义优化器
optimizer = opt.SGD(model.parameters(),lr)
# 定义损失函数。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")
运行结果：
可视化观察训练集损失和训练集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 模型预测
同样地，也可以使用保存好的模型，对测试集中的某一个数据进行模型预测，观察模型效果。
代码如下：
# 获取测试集中第一条数据
X, label = train_dataset[0]
logits = runner.predict(X)
pred_class = torch.argmax(logits[0]).numpy()
label = label.numpy()
# 输出真实类别与预测类别
print("The true category is {} and the predicted category is {}".format(label, pred_class))
运行结果：
思考题
1. 对比Softmax分类和前馈神经网络分类。（必做）
分类效果图可参考：
代码如下：
from sklearn.datasets import load_iris
import pandas
import numpy as np
import matplotlib.pyplot as plt # 可视化工具
import torch
import op, metric, opitimizer
iris_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 = 15
X, 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 = model
self.optimizer = optimizer
self.loss_fn = loss_fn
self.metric = metric
# 记录训练过程中的评价指标变化情况
self.train_scores = []
self.dev_scores = []
# 记录训练过程中的损失函数变化情况
self.train_loss = []
self.dev_loss = []
def train(self, train_set, dev_set, **kwargs):
# 传入训练轮数，如果没有传入值则默认为0
num_epochs = kwargs.get("num_epochs", 0)
# 传入log打印频率，如果没有传入值则默认为100
log_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_score
if 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, loss
def 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))
运行结果：
best accuracy performence has been updated: 0.00000 --> 0.46667
[Train] epoch: 0, loss: 1.09861159324646, score: 0.375
[Dev] epoch: 0, loss: 1.0893398523330688, score: 0.46666666865348816
[Train] epoch: 10, loss: 0.9781171679496765, score: 0.699999988079071
[Dev] epoch: 10, loss: 1.0236393213272095, score: 0.46666666865348816
[Train] epoch: 20, loss: 0.8900946974754333, score: 0.699999988079071
[Dev] epoch: 20, loss: 0.9741119742393494, score: 0.46666666865348816
[Train] epoch: 30, loss: 0.8204634189605713, score: 0.699999988079071
[Dev] epoch: 30, loss: 0.9319687485694885, score: 0.46666666865348816
[Train] epoch: 40, loss: 0.76439368724823, score: 0.699999988079071
[Dev] epoch: 40, loss: 0.896036684513092, score: 0.46666666865348816
[Train] epoch: 50, loss: 0.7185509204864502, score: 0.7250000238418579
[Dev] epoch: 50, loss: 0.8653663396835327, score: 0.46666666865348816
[Train] epoch: 60, loss: 0.6804777979850769, score: 0.7416666746139526
[Dev] epoch: 60, loss: 0.8390589952468872, score: 0.46666666865348816
[Train] epoch: 70, loss: 0.6483750939369202, score: 0.7583333253860474
[Dev] epoch: 70, loss: 0.816339910030365, score: 0.46666666865348816
[Train] epoch: 80, loss: 0.6209224462509155, score: 0.7666666507720947
[Dev] epoch: 80, loss: 0.796570360660553, score: 0.46666666865348816
[Train] epoch: 90, loss: 0.5971452593803406, score: 0.7833333611488342
[Dev] epoch: 90, loss: 0.7792339324951172, score: 0.46666666865348816
[Train] epoch: 100, loss: 0.5763141512870789, score: 0.8166666626930237
[Dev] epoch: 100, loss: 0.7639160752296448, score: 0.46666666865348816
best accuracy performence has been updated: 0.46667 --> 0.53333
[Train] epoch: 110, loss: 0.5578767657279968, score: 0.824999988079071
[Dev] epoch: 110, loss: 0.7502836585044861, score: 0.5333333611488342
best accuracy performence has been updated: 0.53333 --> 0.60000
[Train] epoch: 120, loss: 0.5414095520973206, score: 0.824999988079071
[Dev] epoch: 120, loss: 0.7380689382553101, score: 0.6000000238418579
[Train] epoch: 130, loss: 0.5265832543373108, score: 0.8500000238418579
[Dev] epoch: 130, loss: 0.7270554304122925, score: 0.6000000238418579
[Train] epoch: 140, loss: 0.5131379961967468, score: 0.8500000238418579
[Dev] epoch: 140, loss: 0.7170670628547668, score: 0.6000000238418579
[Train] epoch: 150, loss: 0.5008670687675476, score: 0.875
[Dev] epoch: 150, loss: 0.707959771156311, score: 0.6000000238418579
best accuracy performence has been updated: 0.60000 --> 0.66667
[Train] epoch: 160, loss: 0.48960402607917786, score: 0.875
[Dev] epoch: 160, loss: 0.6996145844459534, score: 0.6666666865348816
[Train] epoch: 170, loss: 0.4792129397392273, score: 0.875
[Dev] epoch: 170, loss: 0.6919329166412354, score: 0.6666666865348816
[Train] epoch: 180, loss: 0.46958208084106445, score: 0.875
[Dev] epoch: 180, loss: 0.6848322749137878, score: 0.6000000238418579
[Train] epoch: 190, loss: 0.46061864495277405, score: 0.875
[Dev] epoch: 190, loss: 0.6782433390617371, score: 0.6000000238418579
[Test] score/loss: 0.7333/0.5930
The true category is 2 and the predicted category is 2
对比两种结果可知对于鸢尾花分类，前馈神经网络的准确率要高于Softmax分类。
2. 对比SVM与FNN分类效果，谈谈自己看法。（选做）
SVM:中文名叫支持向量机，它的基本模型是定义在特征空间上的间隔最大的线性分类器。
1.在线性可分时，在原空间寻找两类样本的最优分类超平面;
2.在线性不可分时，加入松弛变量并通过非线性映射将低维输入空间的样本映射到高维空间使其变为线性可分，这样就可以在该特征空间中寻找最优分类超平面。
SVM的优点：
1)非线性映射是SVM方法的理论基础,SVM利用内积核函数代替向高维空间的非线性映射；
2)支持向量是SVM的训练结果,在SVM分类决策中起决定作用的是支持向量
3)SVM 是一种有坚实理论基础的新颖的小样本学习方法
4)SVM 的最终决策函数只由少数的支持向量所确定,计算的复杂性取决于支持向量的数目,而不是样本空间的维数,这在某种意义上避免了“维数灾难”
泛化性能比较好, 不容易过拟合,可以在较少的数据下取得好的性能
SVM的缺点：
1）支持向量机算法对大规模训练样本难以实施，这是因为支持向量算法借助二次规划求解支持向量，这其中会设计m阶矩阵的计算，所以矩阵阶数很大时将耗费大量的机器内存和运算时间。
2）经典的SVM只给出二分类的算法，而在数据挖掘中，一般要解决多分类的分类问题，而支持向量机对于多分类问题解决效果并不理想。
3）现在常用的SVM理论都是使用固定惩罚系数C，但是正负样本的两种错误造成的损失是不一样的。
FNN模型的特点：
1.采用FM预训练得到的隐含层及其权重作为神经网络的第一层的初始值，之后再不断堆叠全连接层，最终输出预测的点击率。
2.可以将FNN理解成一种特殊的embedding+MLP，其要求第一层嵌入后的各特征域特征维度一致，并且嵌入权重的初始化是FM预训练好的。
3.这不是一个端到端的训练过程，有贪心训练的思路。而且如果不考虑预训练过程，模型网络结构也没有考虑低阶特征组合。
优点：
引入DNN对特征进行更高阶组合，减少特征工程，能在一定程度上增强FM的学习能力，这种尝试为后续深度推荐模型的发展提供了新的思路。
缺点：
1.两阶段训练模式，在应用过程中不方便，且模型能力受限于FM表征能力的上限。
2.FNN专注于高阶组合特征，但是却没有对低阶特征进行建模。
3. 尝试基于MNIST手写数字识别数据集，设计合适的前馈神经网络进行实验，并取得95%以上的准确率。（选做）
代码如下：
import torch
from torch import nn
from torch.autograd import Variable
from torch.utils.data import DataLoader
import torchvision.datasets as dataset
import torchvision.transforms as transforms
batch_size = 100
# 加载数据集
train_dataset = dataset.MNIST(root='./data', train=True, transform=transforms.ToTensor(), download=True)
test_dataset = dataset.MNIST(root='./data', train=False, transform=transforms.ToTensor(), download=True)
# 封装数据集
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=True)
# 初始化超参数
input_size = 784
hidden_size = 500
num_classes = 10 # 类别数目
# 定义神经网络模型
class module(nn.Module):
def __init__(self, input_size, hidden_size, output_num):
super(module, self).__init__()
self.fc1 = nn.Linear(input_size, hidden_size)
self.fc2 = nn.Linear(hidden_size, output_num)
# 前向传播
def forward(self, x):
out = self.fc1(x)
out = torch.relu(out)
out = self.fc2(out)
return out
module = module(input_size, hidden_size, num_classes)
# 超参数初始化
lr = 1e-1
epochs = 5
# 定义损失函数及优化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(module.parameters(), lr=lr)
# 模型开始训练
for epoch in range(epochs + 1):
print("==============第 {} 轮 训练开始==============".format(epoch + 1))
for i, (images, labels) in enumerate(train_loader):
images = Variable(images.view(-1, 28 * 28))
labels = Variable(labels)
outputs = module(images)
# 计算损失
loss = criterion(outputs, labels)
# 梯度清0
optimizer.zero_grad()
# 反向传播
loss.backward()
# 参数更新
optimizer.step() # update parameters
#
if i % 100 == 0:
print("交叉熵损失为: %.5f" % loss.item())
# 利用训练好的模型进行预测
T = 0 # 总共测试集样本个数
CC = 0 # 测试集正确识别的个数
for images, labels in test_loader:
images = Variable(images.view(-1, 28 * 28))
labels = Variable(labels)
outputs = module(images)
_, predicts = torch.max(outputs.data, 1)
T += labels.size(0)
CC += (predicts == labels).sum()
print("识别准确率为：%.2f %%" % (100 * CC / T))
运行结果
总结
1. 总结本次实验
通过此次实验，我掌握了Softmax分类和前馈神经网络分类的区别，SVM与FNN分类效果的区别以及他们的优缺点；发现了模型的构建套路都差不多，只是细节上有差别。
2. 全面总结前馈神经网络，梳理知识点，建议画思维导图。
3063
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
