文章目录

一、数据集介绍

  • 此模型训练的数据集是 torchvision 库中 datasets 数据包中的 MNIST 数据集

  • MNIST 数据集中含有 70000 张由不同的人手写数字图像，其中60000张训练集，10000张是测试集

  • 每张图片都是灰度的，大小为28x28像素，且每张图片中的数字都是剧中的，以减少预处理和加块模型训练

  • 导入此数据包，提取出训练集和测试集，并展示出部分手写图片，代码如下：

    from torchvision import datasets 

""" 下载训练数据集 （包含训练数据+标签）"""
training_data = datasets.MNIST(
    root='data',
    train=True,
    download=True,
    transform=ToTensor()  # 张量，图片是不能直接传入神经网络模型
)  # 对于pytorch库能够识别的数据一般是tensor张量.
# NumPy 数组只能在CPU上运行。Tensor可以在GPU上运行，这在深度学习应用中可以显著提高计算速度。

""" 下载测试数据集（包含训练图片+标签）"""
test_data = datasets.MNIST(
    root='data',
    train=False,
    download=True,
    transform=ToTensor()
)
print(len(training_data))

""" 展示手写字图片 """
# tensor --> numpy 矩阵类型的数据
from matplotlib import pyplot as plt

figure = plt.figure()
for i in range(9):
    img, label = training_data[i + 59000]  # 提取第59000张图片

    figure.add_subplot(3, 3, i + 1)  # 图像窗口中创建多个小窗口，小窗口用于显示图片
    plt.title(label)
    plt.axis("off")  # 关闭坐标
    plt.imshow(img.squeeze(), cmap="gray")
    a = img.squeeze()  # img.squeeze()从张量img中去掉维度为1的(降维)
plt.show()

  • 展示的手写数字图片如下：
    在这里插入图片描述

  • 下面链接是此数据集的官方解释（纯英文，可在浏览器中翻译成中文）：

二、卷积神经网络模型对手写数字识别步骤和完整代码

  • 步骤：

    • 1.下载训练集和测试集，并展示部分手写数字图片
    • 2.运用 DataLoader 数据包管理工具，在训练集和测试集数据中，将每64张图片打包成一个数据包
    • 3.构建一个卷积神经网络模型类
    • 4.定义训练模型的函数
    • 5.定义测试模型的函数
    • 6.创建交叉熵损失函数对象，并创建一个优化器，用于更行模型中的权重参数，达到优化模型的效果
    • 7.定义模型训练轮数，进行模型训练，并打印出每一轮训练后的损失值，便于观察模型的优化效果
    • 8.传入训练数据，进行模型测试

  • 完整代码：

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

"""
MNIST包含70,000张手写数字图像:60,000张用于训练，10,000张用于测试。
图像是灰度的，28x28像素的，并且居中的，以减少预处理和加快运行。
"""
""" 下载训练数据集 （包含训练数据+标签）"""
training_data = datasets.MNIST(
    root='data',
    train=True,
    download=True,
    transform=ToTensor()  # 张量，图片是不能直接传入神经网络模型
)  # 对于pytorch库能够识别的数据一般是tensor张量.
# NumPy 数组只能在CPU上运行。Tensor可以在GPU上运行，这在深度学习应用中可以显著提高计算速度。

""" 下载测试数据集（包含训练图片+标签）"""
test_data = datasets.MNIST(
    root='data',
    train=False,
    download=True,
    transform=ToTensor()
)
print("训练数据集数量为：{}".format(len(training_data)))
print("测试数据集数量为：{}".format(len(test_data)))

""" 展示手写字图片 """
# tensor --> numpy 矩阵类型的数据
from matplotlib import pyplot as plt

figure = plt.figure()
for i in range(9):
    img, label = training_data[i + 59000]  # 提取第59000张图片

    figure.add_subplot(3, 3, i + 1)  # 图像窗口中创建多个小窗口，小窗口用于显示图片
    plt.title(label)
    plt.axis("off")  # 关闭坐标
    plt.imshow(img.squeeze(), cmap="gray")
    a = img.squeeze()  # img.squeeze()从张量img中去掉维度为1的(降维)
plt.show()

train_dataloader = DataLoader(training_data, batch_size=64)  # 64张图片为一个包
test_dataloader = DataLoader(test_data, batch_size=64)
for X, y in test_dataloader:  # X 表示打包好的每一个数据包
    print(f"Shape of X [N, C, H, W]: {X.shape}")
    print(f"Shape of y: {y.shape} {y.dtype}")
    break

""" 判断当前设备是否支持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")


# 构建一个卷积神经网络模型类
class CNN(nn.Module):  
    def __init__(self):
        super(CNN, self).__init__()  # 继承的父类初始化
        self.conv1 = nn.Sequential(  # 将多个层组合成一起。
            nn.Conv2d(  # Conv2d一般用于图像，Conv3d用于视频数据(多一个时间维度)，Conv1d一般用于结构化的序列数据
                in_channels=1,  # 图像通道个数，1表示灰度图(确定了卷积核 组中的个数)
                out_channels=16,  # 要得到几多少个特征图->卷积核的个数
                kernel_size=5,  # 卷积核大小，5*5
                stride=1,  # 步长
                padding=2  # 一般希望卷积核处理后的结果大小与处理前的数据大小相同，效果会比较好。那pading该如何设计呢? --> 建议stride为1,kernel_size = 2*padding+1
            ),  # 输出的特征图为(16*28*28)
            nn.ReLU(),  # 激活函数ReLu层，不会改变特征图的大小(16*28*28)
            nn.MaxPool2d(kernel_size=2)  # 进行池化(最大池化)操作(2x2 区域)，输出结果为:(16*14*14)
        )
        self.conv2 = nn.Sequential(  # 输入(16*14*14)
            nn.Conv2d(16, 32, 5, 1, 2),  # 输出(32*14*14)
            nn.ReLU(),  # (32*14*14)
            nn.Conv2d(32, 32, 5, 1, 2),  # 输出(32*14*14)
            nn.ReLU(),  # (32*14*14)
            nn.MaxPool2d(2)  # 输出(32*7*7)
        )
        self.conv3 = nn.Sequential(  # 输入(32*7*7)
            nn.Conv2d(32, 64, 5, 1, 2),  # (64*7*7)
            nn.ReLU()  # 输出(64*7*7)
        )
        self.out = nn.Linear(64 * 7 * 7, 10)  # 全连接层得到的结果

    def forward(self, x):  # 前向传播，你得告诉它，数据的流向。是将卷积神经网络层连接起来，函数名称不能改。
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.conv3(x)
        x = x.view(x.size(0), -1)  # 将图片展开,得到一个长长的向量,便于传入全连接层后的得到结果
        output = self.out(x)
        return output


model = CNN().to(device)  # 把刚刚创建的模型传入到gpu或cpu
print(model)

# 定义训练模型的函数
def train(dataloader, model, loss_fn, optimizer):
    model.train()  # 告诉模型，开始训练，模型中w进行随机化操作，已经更新w。在训练过程中，w会被修改的
    # pytorch提供2种方式来切换训练和测试的模式，分别是:model.train()和 model.eval()。
    # 一般用法是:在训练开始之前写上model.trian()，在测试时写上model.eval()。
    batch_size_num = 1
    for X, y in dataloader:
        X, y = X.to(device), y.to(device)  # 把训练数据集和标签传入cpu或GPU
        pred = model.forward(X)  # .forward可以被省略，父类中已经对次功能进行了设置。自动初始化w权值
        loss = loss_fn(pred, y)  # 通过交叉熵损失函数计算损失值loss

        optimizer.zero_grad()  # 梯度值清零
        loss.backward()  # 反向传播计算得到每个参数的梯度值w
        optimizer.step()  # 根据梯度更新网络w参数

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


# 定义测试模型的函数
def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    model.eval()  # 测试，w就不能再更新。
    test_loss, correct = 0, 0
    with torch.no_grad():  # 一个上下文管理器，关闭梯度计算。当你确认不会调用Tensor.backward()的时候
        for X, y in dataloader:
            X, y = X.to(device), y.to(device)
            pred = model.forward(X)
            test_loss += loss_fn(pred, y).item()  # test loss是会自动累加每一个批次的损失值
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
            a = (pred.argmax(1) == y)  # dim=1表示每一行中的最大值对应的索引号，dim=0表示每一列中的最大值对应的索引号
            b = (pred.argmax(1) == y).type(torch.float)
    test_loss /= num_batches  # 衡量模型测试的好坏。
    correct /= size  # 平均的正确率
    print(f"Test result: \n Accuracy: {(100 * correct)}%, Avg loss: {test_loss}")


loss_fn = nn.CrossEntropyLoss()  # 创建交叉熵损失函数对象，因为手写字识别中一共有10个数字，输出会有10个结果

optimizer = torch.optim.Adam(model.parameters(), lr=0.01)  # 创建一个优化器

# 设置训练轮数
epochs = 10
for e in range(epochs):
    print(f"Epoch {e + 1}\n")
    train(training_dataloader, model, loss_fn, optimizer)
print("Done!")
# 测试模型
test(test_dataloader, model, loss_fn)

  • 模型结构如下:
    在这里插入图片描述

  • 训练结果如下：

  • 共有10轮训练
    在这里插入图片描述

  • 测试结果如下：
    在这里插入图片描述

  • 下面的链接内容是传统神经网络对同样的手写数字的识别

# 深度学习 # cnn # 人工智能
Logo
开放原子开发者工作坊

开放原子开发者工作坊旨在鼓励更多人参与开源活动，与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动，如meetup、训练营等，主打技术交流，干货满满，真诚地邀请各位开发者共同参与！

更多推荐

开源成为金融领域创新发展的新动力引擎

开源成为金融领域创新发展的新动力引擎

avatar 开放原子开发者工作坊

开源成为推动城市数字化转型的核心动力

城市，不仅是人们工作与生活的基本载体，更是承载着亿万人民的希望与梦想。近年来，我国智慧城市建设如火如荼，开源技术的深度融合为其发展注入了新的活力。在民生、环保、公共安全、城市服务等多个领域，开源技术的应用不仅为民众带来了切实的便捷，而且促进了政府决策的科学化，显著提升了城市综合治理能力。

avatar 开放原子开发者工作坊

OpenLoong项目通过技术监督委员会（TOC）评审

OpenLoong项目通过技术监督委员会（TOC）评审

avatar 开放原子开发者工作坊