PyTorch实现卷积神经网络CNN

涩即是Null

于 2024-10-04 16:38:46 发布

阅读量1.6k

点赞数 19

文章标签： pytorch 人工智能深度学习神经网络卷积神经网络

本文链接：https://blog.csdn.net/weixin_51418964/article/details/142703073

版权

一、卷积神经网络CNN

二、代码实现（PyTorch）

1. 导入依赖库

import torch
from torch import nn, optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

nn：包含了torch已经准备好的层，激活函数、全连接层等
optim：提供了神经网络的一系列优化算法，如 SGD、Adam 等
datasets：提供常用的数据集，如 MNIST（本次使用）、CIFAR10/100、ImageNet、COCO 等
DataLoder：装载上面提到的数据集

2. 准备数据集

这里使用MNIST数据集，它是一个大型手写数字数据库（包含0~9十个数字），原始的这两个数据集由128×128像素的黑白图像组成。LeCun等人将其进行归一化和尺寸调整后得到的是28×28的灰度图像。

MNIST数据集总共包含两个子数据集：一个训练数据集（train_dataset）和一个测试数据集（test_dataset）。它们分别包含了60K和10K的28×28的灰度图像。代码如下：

# 训练集
train_dataset = datasets.MNIST(root='./',
                               train=True,
                               transform=transforms.ToTensor(),  # 数据转换为张量格式
                               download=True)
# 测试集
test_dataset = datasets.MNIST(root='./',
                              train=False,
                              transform=transforms.ToTensor(),
                              download=True)

batch_size = 100  # 批次大小
# 装载训练集
train_loader = DataLoader(dataset=train_dataset,
                          batch_size=batch_size,  # 每次加载多少条数据
                          shuffle=True)  # 生成数据前打乱数据 
# 装载测试集
test_loader = DataLoader(dataset=test_dataset,
                         batch_size=batch_size,
                         shuffle=True)

这里值得注意的是，datasets.s=MNIST() 的参数 download 表示是否下载到参数 root 下的目录。但是实际使用过程中，从 https://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz 下载会出现 403 forbidden 的报错信息。这个不必担心，torch 还会选择其他可用下载链接继续下载。下载好的数据集应该有如下几个：

或者

3. 构建网络模型

首先应该清楚，MNIST给到的原始训练集的图像可以表示为（batch_size, 1, 28, 28），其中 batch_size 代表一共加载了多少条数据，这里我之前设置了100；1代表这个训练集的图片是灰度图；两个28则为灰度图的长和宽。

接下来就可以设计卷积层和池化层。

设计卷积层时，应该注意第一层的卷积核数量（特征图数量）一般从较小的数值开始，我这里设置了32。因为灰度图的特征还算明显，因此卷积核可以适当减小，缓慢增加感受野，以此提高效率，因此设置为5×5。步长一般设置为1。至于填充几圈0，则可通过图像大小、卷积核大小、步长等推算得知。

设计池化层时，首先确定池化法，这里选择最大池化法。选择最常用的2×2大小的池化核，它能够将特征图的宽和高减小一半。

以下是每一层的详细设计思路：

卷积层1（conv1）：先创建一个二维卷积层（Conv2d），然后确定激活函数（ReLU）对卷积层输出的每个值进行非线性变换，最后利用最大池化法（MaxPool）减小特征图尺寸防止过拟合。
卷积层2（conv2）：由卷积层1的输出通道数确定卷积层2的输入通道数，其他不变。
全连接层1（fc1）：使用 Dropout 来控制全连接层的过拟合问题，每次有50%的神经元不使用（只有训练状态下 Dropout 才起作用，测试状态下还是全部神经元工作）。在前向传播时需要注意，应该把卷积层的特征图维数修改为2维。
全连接层2（fc2）：最后将1000个特征图输出为10个数字（0~9）的概率值。这里Softmax不加也行，因为后续在使用交叉熵代价函数（CrossEntropyLoss）时，因为它内部已经包括 Softmax 操作。

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(1, 32, 5, 1, 2),  # Conv2d(输入通道数（灰度图），输出通道数（生成多少特征图），卷积核大小（5×5），步长，0填充（填充2圈）)
            nn.ReLU(),
            nn.MaxPool2d(2, 2)  # MaxPool2d(池化核大小2×2，步长为2)
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)  
        )
        self.fc1 = nn.Sequential(
            nn.Linear(64 * 7 * 7, 1000),  # 将特征压缩为1000维的特征向量
            nn.Dropout(p=0.5),
            nn.ReLU()
        )
        self.fc2 = nn.Sequential(
            nn.Linear(1000, 10),
            nn.Softmax(dim=1)
        )

    def forward(self, x):
        x = self.conv1(x)  # 特征图(batch_size, 1, 28, 28) -> (batch_size, 32, 14, 14)
        x = self.conv2(x)  # 特征图(batch_size, 32, 14, 14) -> (batch_size, 64, 7, 7)
        x = x.view(x.size()[0], -1)  # ([batch_size, 64, 7, 7]) -> (batch_size, 64*7*7)
        x = self.fc1(x)  # (batch_size, 64*7*7) -> (batch_size, 1000)
        x = self.fc2(x)  # (batch_size, 1000) -> (1000, 10)
        return x

4. 训练+测试

使用交叉熵代价函数（CrossEntropyLoss）和自适应矩阵优化算法（Adam）训练数据。代码如下：

LR = 0.001  # 学习率
model = Net()  # 模型
crossEntropy_loss = nn.CrossEntropyLoss()  # 交叉熵代价函数
optimizer = optim.Adam(model.parameters(), LR)


def train():
    model.train()
    for i, data in enumerate(train_loader):
        inputs, labels = data  # 获得一个批次的数据和标签
        out = model(inputs)  # 获得模型预测输出（64张图像，10个数字的概率）
        loss = crossEntropy_loss(out, labels)  # 使用交叉熵损失函数时，可以直接使用整型标签，无须独热编码
        optimizer.zero_grad()  # 梯度清0
        loss.backward()  # 计算梯度
        optimizer.step()  # 修改权值


def test():
    model.eval()
    correct = 0
    for i, data in enumerate(test_loader):
        inputs, labels = data  # 获得一个批次的数据和标签
        out = model(inputs)  # 获得模型预测结构（64，10）
        _, predicted = torch.max(out, 1)  # 获得最大值，以及最大值所在位置
        correct += (predicted == labels).sum()  # 判断64个值有多少是正确的
    print("测试集正确率：{}\n".format(correct.item() / len(test_loader)))


# 训练20个周期
for epoch in range(20):
    print("Epoch:{}".format(epoch))
    train()
    test()

运行，等待片刻后，输出测试集的正确率为：