拒绝繁琐概念 | 零基础基于pytorch手写构建一个神经网络¶

import torch  # PyTorch 主库，处理张量、模型、训练等
from torch.utils.data import DataLoader  # 用于把数据整理成一批一批
from torchvision import transforms  # 用来做图像的预处理（比如转成张量）
from torchvision.datasets import MNIST  # 直接导入MNIST数据集
import matplotlib.pyplot as plt  # 用于显示图像

class Net(torch.nn.Module):  # 我们的模型继承自 PyTorch 提供的标准模型类

    def __init__(self):
        super().__init__()  # 调用父类的初始化方法

        # 输入层到第一层：28*28=784，表示图像展平成一个长向量
        self.fc1 = torch.nn.Linear(28*28, 64)  # 输入784个数字，输出64个

        # 第二层，全连接，输入64个神经元，输出64个
        self.fc2 = torch.nn.Linear(64, 64)

        # 第三层，全连接
        self.fc3 = torch.nn.Linear(64, 64)

        # 输出层：输出10个结果，对应数字0~9的分类概率
        self.fc4 = torch.nn.Linear(64, 10)

    def forward(self, x):  # 定义前向传播（输入如何一步一步流过网络）
        x = torch.nn.functional.relu(self.fc1(x))  # 第一层 + ReLU激活
        x = torch.nn.functional.relu(self.fc2(x))  # 第二层 + ReLU激活
        x = torch.nn.functional.relu(self.fc3(x))  # 第三层 + ReLU激活

        # 最后一层输出，使用log_softmax（对数 + 概率归一化）
        x = torch.nn.functional.log_softmax(self.fc4(x), dim=1)
        return x

def get_data_loader(is_train):
    # 把图片转成张量（Tensor），同时自动把像素缩放到0~1之间
    to_tensor = transforms.Compose([transforms.ToTensor()])

    # 下载 MNIST 数据集（is_train=True 表示是训练集，否则是测试集）
    data_set = MNIST("", is_train, transform=to_tensor, download=True)

    # 把数据分成小批次，每次给15张图片给模型训练/测试
    return DataLoader(data_set, batch_size=15, shuffle=True)

def evaluate(test_data, net):
    n_correct = 0  # 正确预测的数量
    n_total = 0    # 总预测数

    with torch.no_grad():  # 不计算梯度，节省内存和加速
        for (x, y) in test_data:  # 遍历所有测试图片和标签
            # 展平图像，再传入网络中得到预测
            outputs = net.forward(x.view(-1, 28*28))

            # 遍历每个预测结果
            for i, output in enumerate(outputs):
                if torch.argmax(output) == y[i]:  # 如果预测的数字等于真实数字
                    n_correct += 1
                n_total += 1  # 总数 +1

    return n_correct / n_total  # 返回准确率

def main():
    # 加载训练和测试数据
    train_data = get_data_loader(is_train=True)
    test_data = get_data_loader(is_train=False)

    # 初始化我们的神经网络
    net = Net()

    # 看看一开始（没训练前）准确率有多低
    print("initial accuracy:", evaluate(test_data, net))

    # Adam 是一种智能优化器，比传统方法更快收敛
    optimizer = torch.optim.Adam(net.parameters(), lr=0.001)

    for epoch in range(2):  # 训练2轮（可以改成更多）
        for (x, y) in train_data:
            net.zero_grad()  # 每次先清空旧梯度

            # 把图像展平成一行，送入网络得到预测
            output = net.forward(x.view(-1, 28*28))

            # 计算损失：实际值 y 和预测值 output 的差距
            loss = torch.nn.functional.nll_loss(output, y)

            loss.backward()  # 反向传播：计算每层误差
            optimizer.step()  # 调整每层权重

        # 每轮训练完就评估一次准确率
        print("epoch", epoch, "accuracy:", evaluate(test_data, net))

    for (n, (x, _)) in enumerate(test_data):  # 从测试集中取前4张图片
        if n > 3:
            break
        # 预测这张图属于哪个数字（注意只取一张图 x[0]）
        predict = torch.argmax(net.forward(x[0].view(-1, 28*28)))

        # 显示图像
        plt.figure(n)
        plt.imshow(x[0].view(28, 28))  # 转换成 28x28 的二维图像显示
        plt.title("prediction: " + str(int(predict)))  # 标题显示预测数字
    plt.show()

if __name__ == "__main__":
    main()