使用含有四层隐层的神经网络识别手写数字(完整代码详解)

 

目录

1.导入神经网络模块

2.下载数据集

3.创建数据加载器

4.判断当前设备是否支持GPU

5.定义神经网络

6.定义训练函数

7.定义测试函数

8.调用函数

9.多批次训练

10.部分重要结果输出

---

  本代码将使用含有四层隐层的神经网络识别手写数字，第1层256个神经元，第2层512个神经元，第3层128个神经元，第4层256个神经元。

1.导入神经网络模块

import torch
print(torch.__version__)

import torch
from torch import nn
#导入神经网络模块
from torch.utils.data import DataLoader #数据包管理工具，打包数据
from torchvision import datasets #封装了很多与图像相关的模型，数据集
from torchvision.transforms import ToTensor #数据转换，将其他类型的数据转换为tensor张量，如numpy，array, dataframe

2.下载数据集

'''
MNIST包含70000张手写数字图像: 60000张用于训练，10000张用于测试。
图像是灰度的，28x28像素的，并且居中的，以减少预处理和加快运行。
'''

'''下载训练数据集，(包含训练图片+标签)'''
training_data = datasets.MNIST(#跳转到国数的内部源代码，pycharm 按ctrl +鼠标点击
    root="data",
    train=True,
    download=True,
    transform=ToTensor(),#张量，图片不能直接传入神经网络模型
)  #对于pytorch库能够识别的数据一般是tensor张量。
# datasets.MNIST的参数:
# root(string):表示数据集的根目录
# train(bool, optional): 如果为True，则从training.pt创建数据集，否则从test.pt创建数据集
# download(bool, optional): 如果为True，则从internet下载数据集并将其放入根目录。如果数据集已下载，则不会再次下载
# transform(callable, optional): 接收PIL图片并返回转换后版本图片的转换函数

'''下载测试数据集，(包含训练图片+标签)'''
test_data = datasets.MNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor(),#Tensor是在深度学习中提出并厂泛应用的数据类型，它与深度学习框架(如PyTorch、TensorFlow) 紧密集成
)#NumPy数组只能在CPU上运行。Tensor 可以在GPU上运行，这在深度学习应用中可以显著提高计算速度。

3.创建数据加载器

'''
创建数据DataLoader(数据加载器)
batch_size:将数据集分成多份，每一份为batch_size个数据。
优点:可以减少内存的使用，提高训练速度。
'''
train_dataloader = DataLoader(training_data, batch_size=64) #64张图片为一个包，
test_dataloader = DataLoader(test_data, batch_size=64)

4.判断当前设备是否支持GPU

'''判断当前设备是否支持GPU，其中mps是苹果m系列芯片的GPU。'''
device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
print(f"Using {device} device")

5.定义神经网络

'''定义神经网络 通过类的继承这种方式'''
class NeuralNetwork(nn.Module): # 通过调用类的形式来使用神经网络，神经网络的模型，继承父类nn.module
    def __init__(self): # python基础关于类, self类自己本身
        super().__init__()  # 继承的父类初始化
        self.flatten = nn.Flatten()  # 创建一个展开对象flatten，flatten展开28*28的数据，每一个0或1的值为一个神经元
        self.hidden1 = nn.Linear(28*28, 256)  # 前一层神经元的个数，当前本层神经元个数
        # 第1个参数:有多少个神经元传入进来，第2个参数:有多少个数据传出去
        self.hidden2 = nn.Linear(256, 512)
        self.hidden3 = nn.Linear(512, 128)
        self.hidden4 = nn.Linear(128, 256)
        self.out = nn.Linear(256, 10)  # 输出必须和标签的类别相同，输入必须是上层的神经元个数

    def forward(self, x): # 使神经网络层连接起来，函数名称不能改。
        x = self.flatten(x) # 图像进行展开
        x = self.hidden1(x)
        x = torch.relu(x)  # torch使用的relu函数  可选relu, tanh, sigmoid
        x = self.hidden2(x)
        x = torch.relu(x)
        x = self.hidden3(x)
        x = torch.relu(x)
        x = self.hidden4(x)
        x = torch.relu(x)
        x = self.out(x)
        return x

model = NeuralNetwork().to(device) #把刚刚创建的模型传入到 Gpu
print(model)

6.定义训练函数

def train(dataloader, model, loss_fn, optimizer):
    model.train()  # #告诉模型要开始训练，模型中ω进行随机化操作，以及更新ω，在训练过程中，ω会被修改
    # pytorch提供2种方式来切换训练和测试的模式，分别是: model.train()和 model.eval()。
    # 一般用法是: 在训练开始之前写上 model.train(),在测试时写上model.eval() 。
    batch_size_num = 1
    for X, y in dataloader: # 其中batch为每个数据的编号
        X, y = X.to(device), y.to(device) # 把训练数据集和标签传入cpu或GPU
        pred = model.forward(X) # 自动初始化ω权值
        loss = loss_fn(pred, y) # 通过交叉熵损失函数计算损失值loss
        # 进来一个batch的数据，计算一次梯度，更新一次网络
        optimizer.zero_grad()  # 梯度值清零
        loss.backward()  # 反向传播计算得到每个参数的梯度值
        optimizer.step()  # 根据梯度更新网络参数

        loss_value = loss.item()  # item从tensor数据中提取数据出来，tensor获取损失值
        print(f"loss: {loss_value:>7f} [number:{batch_size_num}]")
        batch_size_num += 1

7.定义测试函数

def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    model.eval() # 测试，ω就不能再更新。
    test_loss, correct = 0, 0
    with torch.no_grad():# 一个上下文管理器，关闭梯度计算。当确认不会调用Tensor.backward()的时候。这可以减少计算所用内存消耗。
        for X, y in dataloader:
            X, y = X.to(device), y.to(device)  # 数据传到GPU或者CPU中
            pred = model.forward(X)
            test_loss += loss_fn(pred, y).item() # test_loss 会自动累加每一个批次的损失值
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
            # dim=1表示每行中的最大值对应的索引号，dim=0表示每列中的最大值对应的索引号
            # torch类型转换成float类型
            # sum计算正确的个数

    test_loss /= num_batches  # 能来衡量模型测试的好坏。
    correct /= size  # 平均的正确率
    print(f"Test result: \n Accuracy: {(100*correct)}%，Avg loss: {test_loss}")

8.调用函数

loss_fn = nn.CrossEntropyLoss()  # 创建交叉熵损失函数对象，因为手写字识别中共有10个数字，输出会有10个结果
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)  # 创建一个优化器， SGD为随机梯度下降算法，Adam为自适应矩估计算法
# params:要训练的参数. 一般我们传入的都是model.parameters()。
# lr: Learning_rate学习率，也就是步长。

# loss表示模型训练后的输出结果与样本标签的差距。如果差距越小，就表示模型训练越好，越逼近于真实的模型。
train(train_dataloader, model, loss_fn, optimizer)  # 训练1次完整的数据，可以进行多轮训练
test(test_dataloader, model, loss_fn)

9.多批次训练

epochs = 10  # 训练10次
for t in range(epochs):
    print(f"Epoch {t+1}\n--------------------------")
    train(train_dataloader, model, loss_fn, optimizer)
    # test(test_ataloader, model, loss_fn)
print("Done!")
test(test_dataloader, model, loss_fn)

10.部分重要结果输出