[人工智能]NNDL 实验五 前馈神经网络（3）鸢尾花分类

深入研究鸢尾花数据集

画出数据集中150个数据的前两个特征的散点分布图：

import numpy as np
data_x,data_y = load_data()
iris_first = []
iris_second = []
iris_third = []
for i in range(0,len(data_y)):
    if(data_y[i]==0):
        iris_first.append(data_x[i,:].numpy())
    elif(data_y[i]==2):
        iris_second.append(data_x[i,:].numpy())
    else:
        iris_third.append(data_x[i,:].numpy())
iris_first = torch.tensor(iris_first)
iris_second = torch.tensor(iris_second)
iris_third = torch.tensor(iris_third)

plt.scatter(iris_first[:,0],iris_first[:,1],c='b')
plt.scatter(iris_second[:,0],iris_second[:,1],c='y')
plt.scatter(iris_third[:,0],iris_third[:,1],c='g')
plt.legend(['iris versicolor','iris setosa','iris vlrglnica'])

4.5 实践：基于前馈神经网络完成鸢尾花分类

在本实践中，我们继续使用第三章中的鸢尾花分类任务，将Softmax分类器替换为本章介绍的前馈神经网络。
在本实验中，我们使用的损失函数为交叉熵损失；优化器为随机梯度下降法；评价指标为准确率。

4.5.1 小批量梯度下降法

在梯度下降法中，目标函数是整个训练集上的风险函数，这种方式称为批量梯度下降法（Batch Gradient Descent，BGD）。 批量梯度下降法在每次迭代时需要计算每个样本上损失函数的梯度并求和。当训练集中的样本数量$N$很大时，空间复杂度比较高，每次迭代的计算开销也很大。

为了减少每次迭代的计算复杂度，我们可以在每次迭代时只采集一小部分样本，计算在这组样本上损失函数的梯度并更新参数，这种优化方式称为
小批量梯度下降法（Mini-Batch Gradient Descent，Mini-Batch GD）。

第$t$次迭代时，随机选取一个包含$K$个样本的子集${\mathcal{B}}_t$，计算这个子集上每个样本损失函数的梯度并进行平均，然后再进行参数更新。
$${\theta }_{t+1}\leftarrow {\theta }_t?\alpha \frac{1}{K}\sum _{(\mathbf{x},y)\in {\mathcal{S}}_t}\frac{?\mathcal{L}(y,f(\mathbf{x};\theta ))}{?\theta },$$
其中$K$为批量大小(Batch Size)。$K$通常不会设置很大，一般在$1～100$之间。在实际应用中为了提高计算效率，通常设置为2的幂$2^n$。

在实际应用中，小批量随机梯度下降法有收敛快、计算开销小的优点，因此逐渐成为大规模的机器学习中的主要优化算法。
此外，随机梯度下降相当于在批量梯度下降的梯度上引入了随机噪声。在非凸优化问题中，随机梯度下降更容易逃离局部最优点。

小批量随机梯度下降法的训练过程如下：

4.5.1.1 数据分组

为了小批量梯度下降法，我们需要对数据进行随机分组。目前，机器学习中通常做法是构建一个数据迭代器，每个迭代过程中从全部数据集中获取一批指定数量的数据。

数据迭代器的实现原理如下图所示：

=

1. 首先，将数据集封装为Dataset类，传入一组索引值，根据索引从数据集合中获取数据；
2. 其次，构建DataLoader类，需要指定数据批量的大小和是否需要对数据进行乱序，通过该类即可批量获取数据。

在实践过程中，通常使用进行参数优化。在飞桨中，使用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 numpy as np
import torch

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)

train_dataset = IrisDataset(mode='train')
dev_dataset = IrisDataset(mode='dev')
test_dataset = IrisDataset(mode='test')   
# 打印数据集长度
print ("length of train set: ", len(train_dataset))
print ("length of dev set: ", len(dev_dataset))
print ("length of test set: ", len(test_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。代码实现如下：

from torch import nn

# 定义前馈神经网络
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)
        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
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 = torch.cast((outputs>=0), dtype='float32')
            else:
                # 如果不是logist，判断每个概率值是否大于0.5，当大于0.5时，类别为1，否则类别为0
                preds = torch.cast((outputs>=0.5), dtype='float32')
        else:
            # 多分类时，使用'paddle.argmax'计算最大元素索引作为类别
            preds = torch.argmax(outputs, axis=1, dtype='int64')

        # 获取本批数据中预测正确的样本个数
        labels = torch.squeeze(labels, axis=-1)
        batch_correct = torch.sum(torch.cast(preds==labels, dtype="float32")).numpy()[0]
        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.clear_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):
        paddle.save(self.model.state_dict(), save_path)

    def load_model(self, model_path):
        model_state_dict = paddle.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 F
lr = 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") 

可视化观察训练集损失和训练集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="#8E004D",
    dev_color='#E20079',
    fontsize='x-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=fontsize)

    # 绘制评价准确率变化曲线
    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=fontsize)

    plt.savefig(fig_name)
    plt.show()

plot_training_loss_acc(runner, 'fw-loss.pdf')

从输出结果可以看出准确率随着迭代次数增加逐渐上升，损失函数下降。

4.5.6 模型评价

使用测试数据对在训练过程中保存的最佳模型进行评价，观察模型在测试集上的准确率以及Loss情况。代码实现如下：

# 加载最优模型
runner.load_model('best_model.pdparams')
# a
score, loss = runner.evaluate(test_loader)
print("[Test] accuracy/loss: {:.4f}/{:.4f}".format(score, loss))

4.5.7 模型预测

同样地，也可以使用保存好的模型，对测试集中的某一个数据进行模型预测，观察模型效果。代码实现如下：

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))

思考

1. 对比Softmax分类和前馈神经网络分类。

Softmax实现对鸢尾花进行分类结果

前馈神经网络对其进行分类：

回顾 一下Softmax分类
Softmax分类器是逻辑回归分类器（LR）面对多分类任务的一般化变形，softmax计算简单，既可以进行二分类和多分类，和逻辑回归不同的是将激活函数变为softmax.
深入Softmax回归

通过上面的分类结果，我们发现，三种机器学习的方法，拟合的效果均已经达到一个巅峰，可知，鸢尾花真是我们入门的必要的一个数据集。由于神经网络这个划分结果不是成区域划分，所以很难画出可视化的图，这里我们仅仅将误差和准确率进行可视化，通过观察，我们发现svm和softmax回归划分出来区域及其相似，其实二者自身的原理很相似。Softmax是以误差函数最小为优化目标，Svm是以二者间距最大为目标，前馈神经网络虽然和二者的分类结果近似，但是其原理却和二者差的很多，前馈神经网络是通过一层一层神经元搭建而成形成预测，和空间区域距离等概念没有一点联系。前馈神经网络原理
通过分类结果我们还发现，softmax分类器分类的时候，误差呈单调下降，前馈神经网络在进行训练的时候，虽然最终结果并无大意。但是误差起伏不定。
先说一下比较相近的两个(softmax和SVM)：
Softmax分类器就可以理解为逻辑回归分类器面对多个分类的一般化归纳，说白了就是逻辑回归可以进行多分类了。
SVM将输出 $f(x_i,W)$作为每个分类的评分（因为无定标，所以难以直接解释）。与SVM不同，Softmax的输出（归一化的分类概率）更加直观，并且从概率上可以解释.
在softmax分类器中，函数映射$f(x_i,W)=W{x}_i$? 保持不变，但将这些评分值视为每个分类的未归一化的对数概率，并且将折叶损失（hinge loss）替换为交叉熵损失（cross-entropy loss）。
在实际应用中：SVM和Softmax经常是相似的：通常说来，两种分类器的表现差别很小，不同的人对于哪个分类器更好有不同的看法。
相对于Softmax分类器，SVM更加“局部目标化（local objective）”，这既可以看做是一个特性，也可以看做是一个劣势。
考虑一个评分是[ 10 , ? 2 , 3 ] [10, -2, 3][10,?2,3]的数据，其中第一个分类是正确的。那么一个SVM（Δ = 1 \Delta =1Δ=1）会看到正确分类相较于不正确分类，已经得到了比边界值还要高的分数，它就会认为损失值是0 00。SVM对于数字个体的细节是不关心的：如果分数是[ 10 , ? 100 , ? 100 ] [10, -100, -100][10,?100,?100]或者[ 10 , 9 , 9 ] [10, 9, 9][10,9,9]，对于SVM来说没设么不同，只要满足超过边界值等于1 11，那么损失值就等于0 00。对于softmax分类器，情况则不同。对于[ 10 , 9 , 9 ] [10, 9, 9][10,9,9]来说，计算出的损失值就远远高于[ 10 , ? 100 , ? 100 ] [10, -100, -100][10,?100,?100]的。换句话来说，softmax分类器对于分数是永远不会满意的：正确分类总能得到更高的可能性，错误分类总能得到更低的可能性，损失值总是能够更小。但是，SVM只要边界值被满足了就满意了，不会超过限制去细微地操作具体分数。这可以被看做是SVM的一种特性。我的理解就是，一个汽车的分类器应该把他的大量精力放在如何分辨小轿车和大卡车上，而不应该纠结于如何与青蛙进行区分，因为区分青蛙得到的评分已经足够低了。虽然这三者有很大区别，但是可以相互结合，例如在神经网络中我们可以使用softmax作为激活函数，在误差函数的确定中，我们可以使用SVM中的距离度量作为误差。
softmax和神经网络：
softmax有严格的数学推导，更符合人的主观的以实，而神经网络是仿照的人类的人工神经的原理进行工作的。
人工神经网络的优点：分类的准确度高,并行分布处理能力强,分布存储及学习能力强，对噪声神经有较强的鲁棒性和容错能力，能充分逼近复杂的非线性关系，具备联想记忆的功能等。
人工神经网络的缺点：神经网络需要大量的参数，如网络拓扑结构、权值和阈值的初始值；不能观察之间的学习过程，输出结果难以解释，会影响到结果的可信度和可接受程度；学习时间过长,甚至可能达不到学习的目的。
Softmax训练的深度特征，会把整个超空间或者超球，按照分类个数进行划分，保证类别是可分的，这一点对多分类任务如MNIST和ImageNet非常合适，因为测试类别必定在训练类别中。
但Softmax并不要求类内紧凑和类间分离，这一点非常不适合人脸识别任务，因为训练集的1W人数，相对测试集整个世界70亿人类来说，非常微不足道，而我们不可能拿到所有人的训练样本，更过分的是，一般我们还要求训练集和测试集不重叠。所以需要改造Softmax，除了保证可分性外，还要做到特征向量类内尽可能紧凑，类间尽可能分离。

2. 自定义隐藏层层数和每个隐藏层中的神经元个数，尝试找到最优超参数完成多分类。（选做）

由于隐藏层过多会造成过拟合，同时会造成时间的大幅浪费，这里我们不再增加隐藏层的层数，我们只增加隐藏层神经元的个数。

神经元的个数为4,学习率为0.2

神经元的个数为8，学习率为0.2

神经元的个数为8，学习率为0.1

神经元的个数为4，学习率为0.1

经过多次测试后，我们选取训练效果较好的几组参数，通过实验结果我们发现先，运用该模型的时候，隐藏层神经元的个数为4，学习率为0.2的时候拟合效果最好，在验证集上准确率达到了1.0。。
超参数为 学习率 为0.3，含有一层隐藏层，隐藏层神经元为4个，

3. 对比SVM与FNN分类效果，谈谈自己看法。（选做）

前馈神经网络对其进行分类：

分类效果图可参考：

最优解:

SVM和FNN是截然不同的两种分类方法。SVM考虑到不同数据之间空间上的距离因素，而FNN则并没有考虑到这一点，是通过多层神经元改变参数来进行预测的。

回顾 一下SVM支持向量机
SVM支持向量机：说简单点，就是找到一个最大间隔超平面将不同的类分开(不同类中各个点到该超平面的距离最大)
【机器学习】支持向量机非常强大
支持向量机中分类和预测：
SVM分类，就是找到一个平面，让两个分类集合的支持向量或者所有的数据（LSSVM）离分类平面最远；
SVR回归，就是找到一个回归平面，让一个集合的所有数据到该平面的距离最近。
SVR是支持向量回归(support vector regression)的英文缩写，是支持向量机(SVM)的重要的应用分支。
支持向量机和神经网络的对比：
二者在形式上有几分相似,但实际上有很大不同。
简而言之，神经网络是个“黑匣子”，优化目标是基于经验风险最小化，易陷入局部最优，训练结果不太稳定，一般需要大样本；
而支持向量机有严格的理论和数学基础，基于结构风险最小化原则, 泛化能力优于前者，算法具有全局最优性, 是针对小样本统计的理论。
目前来看，虽然二者均为机器学习领域非常流行的方法，但后者在很多方面的应用一般都优于前者。
SVM 就是个分类器，它用于回归的时候称为SVR（Support Vector Regression），SVM和SVR本质上都一样。下图就是SVM分类：

SVM的目的：寻找到一个超平面使样本分成两类，并且间隔最大。
神经网络和支持向量机优缺点对比
1、神经网络优缺点
优点：
神经网络有很强的非线性拟合能力，可映射任意复杂的非线性关系，而且学习规则简单，便于计算机实现。具有很强的鲁棒性、记忆能力、非线性映射能力以及强大的自学习能力，因此有很大的应用市场。
缺点：
（1）最严重的问题是没能力来解释自己的推理过程和推理依据。
（2）不能向用户提出必要的询问，而且当数据不充分的时候，神经网络就无法进行工作。
（3）把一切问题的特征都变为数字，把一切推理都变为数值计算，其结果势必是丢失信息。
（4）理论和学习算法还有待于进一步完善和提高。
2、SVM的优缺点
优点：
（1)非线性映射是SVM方法的理论基础,SVM利用内积核函数代替向高维空间的非线性映射；
（2)对特征空间划分的最优超平面是SVM的目标,最大化分类边际的思想是SVM方法的核心；
（3)支持向量是SVM的训练结果,在SVM分类决策中起决定作用的是支持向量.
（4)SVM 是一种有坚实理论基础的新颖的小样本学习方法.它基本上不涉及概率测度及大数定律等,因此不同于现有的统计方法.从本质上看,它避开了从归纳到演绎的传统过程,实现了高效的从训练样本到预报样本的“转导推理”,大大简化了通常的分类和回归等问题.
（5)SVM 的最终决策函数只由少数的支持向量所确定,计算的复杂性取决于支持向量的数目,而不是样本空间的维数,这在某种意义上避免了“维数灾难”.
（6)少数支持向量决定了最终结果,这不但可以帮助我们抓住关键样本、“剔除”大量冗余样本,而且注定了该方法不但算法简单,而且具有较好的“鲁棒”性.这种“鲁棒”性主要体现在:
①增、删非支持向量样本对模型没有影响;
②支持向量样本集具有一定的鲁棒性;
③有些成功的应用中,SVM 方法对核的选取不敏感
缺点：
(1) SVM算法对大规模训练样本难以实施
由于SVM是借助二次规划来求解支持向量,而求解二次规划将涉及m阶矩阵的计算（m为样本的个数）,当m数目很大时该矩阵的存储和计算将耗费大量的机器内存和运算时间.针对以上问题的主要改进有有J.Platt的SMO算法、T.Joachims的SVM、C.J.C.Burges等的PCGC、张学工的CSVM以及O.L.Mangasarian等的SOR算法
(2) 用SVM解决多分类问题存在困难
经典的支持向量机算法只给出了二类分类的算法,而在数据挖掘的实际应用中,一般要解决多类的分类问题.可以通过多个二类支持向量机的组合来解决.主要有一对多组合模式、一对一组合模式和SVM决策树；再就是通过构造多个分类器的组合来解决.主要原理是克服SVM固有的缺点,结合其他算法的优势,解决多类问题的分类精度.如：与粗集理论结合,形成一种优势互补的多类问题的组合分类器。

4. 尝试基于MNIST手写数字识别数据集，设计合适的前馈神经网络进行实验，并取得95%以上的准确率。（选做）

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor
# 1- download dataset
# 2- create data loader
# 3- build model
# 4- train
# 5- save trained model
 
BATCH_SIZE = 128
Epochs = 10
LEARNING_RATE = 0.001
 
#  5 创建模型
class FeedForwardNet(nn.Module):
 
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.dense_layers = nn.Sequential(  # 允许把多个层打包在一起，并且一层接着一层的运行
            nn.Linear(28*28, 256),  # 输入和输出，相当于dense() 数据集中的像素是28*28
            nn.ReLU(),
            nn.Linear(256, 10),  # 共有10类
        )
        self.softmax = nn.Softmax(dim=1)
 
    # 如何处理data
    def forward(self, input_data):
        flattened_data = self.flatten(input_data)
        logits = self.dense_layers(flattened_data)
        predictions = self.softmax(logits)
        return predictions
 
 
def download_minist_datasets():
    train_data = datasets.MNIST(
        root="data",  # 创建存储的目录
        download=True,  # 如果目录中没有数据集的话就自动下载数据集
        train=True,
        transform=ToTensor()  # 读入我们自己定义的数据预处理操作
    )
    validation_data = datasets.MNIST(  # 验证数据集
        root="data",
        download=True,
        train=False,
        transform=ToTensor()
    )
    return train_data, validation_data
 
def train_one_epoch(model, data_loader, loss_fn, optimiser, device):
    train_correct = 0
    for inputs, targets in data_loader:
        inputs, targets = inputs.to(device), targets.to(device)
 
        # calculate loss #每一个batch计算loss
        # 使用当前模型获得预测
        predictions = model(inputs)
        _, id = torch.max(predictions.data, 1)
        train_correct += torch.sum(id == targets.data)
        loss = loss_fn(predictions, targets)
 
        # backpropagate loss and update weights
        optimiser.zero_grad()  # 在每个batch中让梯度重新为0
        loss.backward()  # 反向传播
        optimiser.step()
 
    print(f"Loss: {loss.item()}")  # 打印最后的batch的loss
    print('        correct:%.03f%%' % (100 * train_correct / len(train_data)))
def train(model, data_loader, loss_fn, optimiser, device, epochs):
    for i in range(epochs):
        print(f"Epoch {i+1}")
        train_one_epoch(model, data_loader, loss_fn, optimiser, device)
        print("---------------------")
    print("Training is down.")
if __name__=="__main__":
    # download MNIST dataset
    train_data, _ = download_minist_datasets()
    print("MNIST dataset downloaded")
 
    # creat a data loader for the train set
    train_data_loader = DataLoader(train_data,
                                   batch_size=BATCH_SIZE,
                                   shuffle=True)
 
    # build model
    if torch.cuda.is_available():
        device = "cuda"
    else:
        device = "cpu"
    print(f"Using {device} device")
 
    feed_forward_net = FeedForwardNet().to(device)
 
    # instantiate loss function + opptimiser
    loss_fn = nn.CrossEntropyLoss()
    optimiser = torch.optim.Adam(feed_forward_net.parameters(),
                                 lr=LEARNING_RATE)
 
    # train model
    train(feed_forward_net, train_data_loader, loss_fn, optimiser, device, Epochs)
    # 存储模型
    torch.save(feed_forward_net.state_dict(), "feedforwardnet.pth")
    print("Model trained and stored at feedforwardnet.pth")

通过多次实验我们可以发现，准确率已经达到了98.312%，已经超过了老师要求的95%。

总结

在进行这次实验的时候，做思考题前面一切都是好好的，但是当做到思考题的第一个，我懵了，对比Softmax分类和前馈神经网络分类。我仔细想想，好像他两也没有什么相同之处，神经网络是模拟的人工神经，Softmax是经过严格的数学推导推导出来的。不过经过查阅资料，了解到了一些他们之间的异同点。同时自己借助网上的资料，下载MINIST数据集，编写网络，改善参数等等使得Minist数据集的最后的准确率达到了98.312%，四舍五入一下也算百分百准确率了。
思维导图

参考：
[深度概念]·Softmax优缺点解析
几种常用机器学习的分类方法
NNDL实验四线性分类
pytorch建立手写数据集训练网络