跳到主要内容

PyTorch 经典CNN模型实现

卷积神经网络（Convolutional Neural Networks, CNN）是深度学习中最常用的模型之一，尤其在计算机视觉任务中表现出色。PyTorch作为一个强大的深度学习框架，提供了灵活的API来构建和训练CNN模型。本文将介绍如何使用PyTorch实现一些经典的CNN模型，包括LeNet、AlexNet和VGG。

什么是卷积神经网络？​

卷积神经网络是一种专门用于处理具有网格结构数据（如图像）的神经网络。它通过卷积层、池化层和全连接层来提取图像中的特征，并通过反向传播算法进行训练。CNN的核心思想是通过局部感受野和权值共享来减少参数数量，从而提高模型的效率和性能。

LeNet​

LeNet是最早的卷积神经网络之一，由Yann LeCun在1998年提出，主要用于手写数字识别。LeNet的结构相对简单，包含两个卷积层和两个全连接层。

LeNet模型实现​

以下是使用PyTorch实现LeNet的代码示例：

import torch
import torch.nn as nn

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, kernel_size=5)
        self.conv2 = nn.Conv2d(6, 16, kernel_size=5)
        self.fc1 = nn.Linear(16*5*5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.max_pool2d(x, 2)
        x = torch.relu(self.conv2(x))
        x = torch.max_pool2d(x, 2)
        x = x.view(-1, 16*5*5)
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

model = LeNet()
print(model)

输入与输出​

假设输入是一个大小为(1, 28, 28)的图像（即1通道，28x28像素），经过LeNet模型后，输出将是一个大小为(10,)的向量，表示10个类别的概率分布。

AlexNet​

AlexNet是2012年ImageNet竞赛的冠军模型，由Alex Krizhevsky等人提出。它比LeNet更深，包含5个卷积层和3个全连接层，并首次引入了ReLU激活函数和Dropout正则化。

AlexNet模型实现​

以下是使用PyTorch实现AlexNet的代码示例：

class AlexNet(nn.Module):
    def __init__(self, num_classes=1000):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(64, 192, kernel_size=5, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(192, 384, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
        )
        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))
        self.classifier = nn.Sequential(
            nn.Dropout(),
            nn.Linear(256 * 6 * 6, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

model = AlexNet()
print(model)

输入与输出​

假设输入是一个大小为(3, 224, 224)的图像（即3通道，224x224像素），经过AlexNet模型后，输出将是一个大小为(1000,)的向量，表示1000个类别的概率分布。

VGG​

VGG是由牛津大学视觉几何组（Visual Geometry Group）提出的深度卷积神经网络。VGG的主要特点是使用小尺寸的卷积核（3x3）和更深的网络结构。VGG有多个版本，如VGG16和VGG19，数字表示网络的层数。

VGG16模型实现​

以下是使用PyTorch实现VGG16的代码示例：

class VGG16(nn.Module):
    def __init__(self, num_classes=1000):
        super(VGG16, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(256, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )
        self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
        self.classifier = nn.Sequential(
            nn.Linear(512 * 7 * 7, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

model = VGG16()
print(model)

输入与输出​

假设输入是一个大小为(3, 224, 224)的图像（即3通道，224x224像素），经过VGG16模型后，输出将是一个大小为(1000,)的向量，表示1000个类别的概率分布。

实际应用场景​

这些经典的CNN模型在计算机视觉任务中有着广泛的应用，例如：

  • LeNet：手写数字识别（MNIST数据集）。
  • AlexNet：图像分类（ImageNet数据集）。
  • VGG：图像分类、目标检测、语义分割等。
提示

在实际应用中，通常会使用预训练的模型进行迁移学习，以加快训练速度并提高模型性能。

总结​

本文介绍了如何使用PyTorch实现经典的CNN模型，包括LeNet、AlexNet和VGG。这些模型在计算机视觉任务中表现出色，并且是深度学习领域的重要里程碑。通过本文的学习，你应该能够理解这些模型的基本结构，并能够在PyTorch中实现它们。

附加资源与练习​

备注

如果你有任何问题或需要进一步的帮助，请随时在评论区留言。