基于多层感知机(MLP)实现MNIST手写体识别

实现步骤

下载数据集
处理好数据集
确定好模型（初始化模型参数等等）
确定优化函数（损失函数也称为目标函数）和优化方法（一般选用随机梯度下降 SDG ）
进行模型的训练
进行模型的评估

import torch
import torchvision
from torch import nn
from torch import optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import matplotlib.pyplot as plt

# 1. 下载数据集
mnist_train = torchvision.datasets.MNIST(root='../data', train=True, transform=transforms.ToTensor(), download=True)
mnist_test = torchvision.datasets.MNIST(root='../data', train=False, transform=transforms.ToTensor(), download=True)

# 2. 创建批量数据迭代器
train_iter = DataLoader(mnist_train, batch_size=256, shuffle=True)
test_iter = DataLoader(mnist_test, batch_size=256)

# 3. 可视化检查数据
var = next(iter(train_iter))
plt.title(str(var[1][0]))  # 显示标签
plt.imshow(var[0][0].squeeze().numpy(), cmap='gray')  # 显示图片
plt.show()

# 4. 定义模型：多层感知机
net = nn.Sequential(
    nn.Flatten(),
    nn.Linear(28 * 28, 512),
    nn.ReLU(),
    nn.Linear(512, 256),
    nn.ReLU(),
    nn.Linear(256, 10) # 注意这里是不需要加 Softmax 了的，因为后面定义了，nn.CrossEntropyLoss()这个会自动帮我们进行 Softmax 以及进行损失计算。其实就是目标函数
)

# 初始化模型参数
def init_weights(m):
    if isinstance(m, nn.Linear):
        nn.init.normal_(m.weight, std=0.01)

net.apply(init_weights)

# 5. 定义损失函数和优化器
loss_fn = nn.CrossEntropyLoss()  # CrossEntropyLoss已经包含了softmax，所以不需要LogSoftmax
optimizer = optim.SGD(net.parameters(), lr=0.2)

# 6. 训练模型
epoch_num = 20
for epoch in range(epoch_num):
    net.train()  # 设置为训练模式
    total_loss = 0
    for X, y in train_iter:
        optimizer.zero_grad()  # 清除梯度
        y_hat = net(X)  # 前向传播
        loss = loss_fn(y_hat, y)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数

        total_loss += loss.item() * X.shape[0]  # 累积损失

    avg_loss = total_loss / len(mnist_train)  # 计算平均损失
    print(f'Epoch {epoch + 1}/{epoch_num}, Loss: {avg_loss:.4f}')

# 7. 评估模型
def evaluate_model(net, test_iter):
    net.eval()  # 设置为评估模式
    correct, total = 0, 0
    with torch.no_grad():  # 在评估时不需要计算梯度
        for X, y in test_iter:
            y_hat = net(X)
            _, predicted = torch.max(y_hat, 1)  # 获取预测的标签
            correct += (predicted == y).sum().item()  # 统计正确的个数
            total += y.size(0)  # 统计总数

    accuracy = correct / total
    print(f'Accuracy on test set: {accuracy * 100:.2f}%')

# 评估模型的表现
evaluate_model(net, test_iter)

代码实践的结果：

自己不会去计算损失
在模型进行训练的时候不知道如何把数据放进去：原来只需要创建好了 DataLoader 以后，通过枚举
就可以拿到数据了。
最后进行模型评估的时候也是用 AI 进行完成了。所以多少还是差点意思。
后面的代码多去实践实践，并且思考吧！！！

关于代码中交叉熵计算的理解

理解损失函数（loss_fn）是如何计算的，对于训练神经网络来说是非常重要的。具体到你提到的这行代码：

loss = loss_fn(y_hat, y)  # 计算损失

损失函数的定义：

在你的代码中，损失函数是：

loss_fn = nn.CrossEntropyLoss()

nn.CrossEntropyLoss() 是一种常用于多分类问题的损失函数，它实际上包含了两个步骤：

Softmax：将模型的输出转换为概率分布。
交叉熵损失：计算真实标签与预测概率分布之间的差距。

为什么要用交叉熵呢？因为交叉熵可以来衡量预测差距，这个我们只需要这个知识点，并且知道上面的公式就好了。

我们逐步分析这两个步骤。

1. Softmax（概率转换）

假设模型的输出 y_hat 是一个向量，其中每个元素代表对应类别的“分数”（或者说是原始的 logits）。例如，假设有 3 个类别，模型的输出可能是：

y_hat = [2.0, 1.0, -1.0]  # 这三个数字是 logits，不是概率

通过 Softmax 函数，我们将这些 logits 转换成概率：

# 计算 softmax
softmax = torch.nn.functional.softmax(y_hat, dim=-1)

softmax 的输出会是一个概率分布，每个数值的范围在 [0, 1] 之间，且所有数值加起来为 1。例如，经过 Softmax 后可能得到：

softmax = [0.7, 0.2, 0.1]  # 类别 0 的概率是 0.7，类别 1 的概率是 0.2，类别 2 的概率是 0.1

2. 交叉熵损失（Cross Entropy Loss）

交叉熵是衡量两个概率分布之间差异的一个标准方法。在分类任务中，我们希望预测的类别概率与真实标签分布尽可能接近。

对于一个单一的样本，交叉熵损失的计算公式为：

$\sum_{i=1}^{C} y_i \log(p_i)$

( C ) 是类别数。
( y_i ) 是真实标签（在 one-hot 编码下，真实类别的标签为 1，其他类别为 0）。
( p_i ) 是模型预测的概率。

对于多分类任务来说，交叉熵损失会选择对应真实标签的类别概率 ( p_{\text{true}} ) 来计算损失。例如，如果真实标签是类别 0，那么我们只关注模型在类别 0 上的预测概率。

假设真实标签 y 是类别 0，对应的 one-hot 编码是 [1, 0, 0]，而模型的预测是：

softmax = [0.7, 0.2, 0.1]

那么交叉熵损失为：

$\cdot \log(0.7) + 0 \cdot \log(0.2) + 0 \cdot \log(0.1)) = - \log(0.7) \approx 0.3567$

`nn.CrossEntropyLoss()` 如何工作

在 PyTorch 中，nn.CrossEntropyLoss 会自动处理上述两个步骤：

将 y_hat（logits）转换为概率。
使用真实标签 y 计算交叉熵损失。

输入和输出：

y_hat: 这是模型的原始输出（logits），形状为 (batch_size, num_classes)。每一行是一个样本的 logits。
y: 这是标签，通常是一个包含类别索引的向量，形状为 (batch_size,)。每个元素是该样本的真实类别索引。

例如：

假设我们有以下数据：

模型的输出（logits）为：

y_hat = torch.tensor([[2.0, 1.0, -1.0],  # 第一个样本
                      [0.5, 1.5, 0.3]]) # 第二个样本

真实标签 y 为：

y = torch.tensor([0, 1])  # 第一个样本的标签是类别 0，第二个样本的标签是类别 1

使用 nn.CrossEntropyLoss() 计算损失：

loss_fn = nn.CrossEntropyLoss()
loss = loss_fn(y_hat, y)

CrossEntropyLoss 会首先对 y_hat 进行 softmax 转换，然后计算每个样本的交叉熵损失。你可以通过打印出来的 loss 来查看模型的表现。

总结：

y_hat 是模型的原始输出（logits），表示每个类别的“分数”。
nn.CrossEntropyLoss 会自动处理 softmax 和交叉熵损失的计算。
损失函数的目的是衡量模型的输出与真实标签之间的差异，差异越小，损失值越小，说明模型的预测越准确。

使用`nn.CrossEntropyLoss 会自动进行独热编码

在计算交叉熵损失时，nn.CrossEntropyLoss 会自动处理标签，并且不需要你手动将标签转换为独热编码（one-hot encoding）。

具体来说：

y_hat：是模型的原始输出（logits），形状为 (batch_size, num_classes)，每一行是一个样本的预测结果，包含每个类别的分数（logits）。
y：是标签，形状为 (batch_size,)，每个元素是该样本的真实类别的索引，而不是独热编码。

nn.CrossEntropyLoss 会自动使用标签 y 中的类别索引（如类别 0, 1, 2）来计算损失，它会根据该类别索引选择对应的模型输出进行计算，而不需要你事先将标签转换为独热编码。

举个例子：

假设我们有一个批次的两个样本，模型的输出 y_hat 和真实标签 y 如下：

模型的输出 `y_hat`（logits）：

y_hat = torch.tensor([[2.0, 1.0, -1.0],  # 第一个样本的 logits
                      [0.5, 1.5, 0.3]]) # 第二个样本的 logits

真实标签 `y`（类别索引）：

y = torch.tensor([0, 1])  # 第一个样本的标签是类别 0，第二个样本的标签是类别 1

在这个例子中，y_hat 的形状是 (2, 3)，表示有两个样本，每个样本有三个类别的 logits。

对于第一个样本，它的真实标签是类别 0，y[0] = 0。
对于第二个样本，它的真实标签是类别 1，y[1] = 1。

当使用 nn.CrossEntropyLoss 时，它会根据真实标签中的类别索引来选择对应的类别概率（通过 softmax 后的结果），然后计算交叉熵损失。PyTorch 会自动完成：

Softmax 转换：将 y_hat 的 logits 转换为概率分布。
损失计算：根据真实标签的类别索引计算交叉熵损失。

损失计算过程：

假设 y_hat 的 softmax 输出（经过 softmax 转换后）为：

softmax = torch.nn.functional.softmax(y_hat, dim=1)

# softmax 结果：
# [[0.7, 0.2, 0.1],  # 第一个样本的概率
#  [0.3, 0.6, 0.1]]  # 第二个样本的概率

然后计算交叉熵损失时：

对于第一个样本（真实标签是 0），损失将仅计算 softmax[0][0]（即类别 0 的概率），即 -log(0.7)。
对于第二个样本（真实标签是 1），损失将仅计算 softmax[1][1]（即类别 1 的概率），即 -log(0.6)。

因此，nn.CrossEntropyLoss 会自动从 y 中提取类别索引，并计算相应的损失。

总结：

不需要手动进行独热编码，因为 nn.CrossEntropyLoss 会自动处理。
标签 y 只需要是一个包含类别索引的张量（每个元素是一个整数，表示类别）。
nn.CrossEntropyLoss 会根据标签中的类别索引，从 y_hat 中提取对应的 logits，然后计算交叉熵损失。

通过这种方式，PyTorch 简化了损失计算的过程，让你不需要显式地进行独热编码的转换。

为什么在实验的时候我去掉了参数初始化对结果并没有很大影响？

在深度学习模型中，尤其是在多层感知机（MLP）中，初始化模型参数对于训练的收敛速度和结果有重要影响。虽然初始化通常有助于提升训练过程的稳定性和准确性，但在某些情况下，即使没有显式初始化，训练仍然可能得到较好的结果。这有以下几个原因：

1. PyTorch 默认的权重初始化

如果你没有手动初始化模型参数，PyTorch 会使用默认的初始化方式。对于 nn.Linear 层，PyTorch 默认使用的是 均匀分布初始化（U(-sqrt(k), sqrt(k))），其中 k 是每一层的输入特征数（即该层的输入维度）。这种初始化方式通常可以在大部分场景下有效工作，尤其是在简单的任务或小型模型中。