【深度学习入门篇 ⑧】关于卷积神经网络

小森( ﹡ˆoˆ﹡ )

已于 2024-07-17 20:32:17 修改

阅读量660

点赞数 18

文章标签：深度学习 cnn 人工智能

于 2024-07-17 20:23:56 首次发布

本文链接：https://blog.csdn.net/qq_64685283/article/details/140500721

版权

【🍊易编橙：一个帮助编程小伙伴少走弯路的终身成长社群🍊】

大家好，我是小森( ﹡ˆoˆ﹡ ) ！易编橙·终身成长社群创始团队嘉宾，橙似锦计划领衔成员、阿里云专家博主、腾讯云内容共创官、CSDN人工智能领域优质创作者。

关于卷积神经网络，你还有哪些不知道的知识点呢，之前我们介绍了大部分，今天再来补充一下～

卷积神经网络基础

什么是卷积

Convolution，输入信息与核函数(滤波器)的乘积

一维信号的时间卷积：输入x，核函数w，输出是一个连续时间段t的加权平均结果。
二维图像的空间卷积：输入图像I，卷积核K，输出图像O。

单个二维图片卷积：输入为单通道图像，输出为单通道图像。

图像的数据存储是多通道的二维矩阵：

灰度图(Gray)只有一个通道(一层），RGB彩色图就是三个通道(Red，Green，Blue)，而RGBA彩色图就是四个通道(Red，Green，Blue，Alpha)。

如何表达每一个网络层中高维的图像数据？

特征图包含：通道，宽度，高度，其中输入特征图Ci，输出特征图C0，输出特征图的每一个通道，由输入图的所有通道和相同数量的卷积核先一一对应各自进行卷积计算，然后求和

卷积相关操作与参数

填充

padding ：给卷积前的输入图像边界添加额外的行，列

控制卷积后图像分辨率，方便计算特征图尺寸的变化
弥补边界信息 “丢失 ”

步长

步长（stride）：卷积核在图像上移动的步子

卷积的核心思想

为什么要进行局部连接?

局部连接可以更好地利用图像中的结构信息，空间距离越相近的像素其相互影响越大

权重共享：保证不变性，图像从一个局部区域学习到的信息应用到其他区域，减少参数，降低学习难度。

ANN与CNN比较

传统神经网络为有监督的机器学习，输入为特征；卷积神经网络为无监督特征学习，输入为最原始的图像。

案例-图像分类

CIFAR10 数据集

CIFAR-10数据集5万张训练图像、1万张测试图像、10个类别、每个类别有6k个图像，图像大小32×32×3。

PyTorch 中的 torchvision.datasets 计算机视觉模块封装了 CIFAR10 数据集:

from torchvision.datasets import CIFAR10
from torchvision.transforms import Compose
from torchvision.transforms import ToTensor
from torch.utils.data import DataLoader


def func1():

    # 加载数据集
    train = CIFAR10(root='data', train=True, transform=Compose([ToTensor()]))
    valid = CIFAR10(root='data', train=False, transform=Compose([ToTensor()]))

    print('训练集数量:', len(train.targets))
    print('测试集数量:', len(valid.targets))

    print("数据集形状:", train[0][0].shape)

    print("数据集类别:", train.class_to_idx)


# 数据加载器
def func2():

    train = CIFAR10(root='data', train=True, transform=Compose([ToTensor()]))
    dataloader = DataLoader(train, batch_size=8, shuffle=True)
    for x, y in dataloader:
        print(x.shape)
        print(y)
        break


if __name__ == '__main__':
    func1()
    func2()

我们要搭建的网络结构：

我们在每个卷积计算之后应用 relu 激活函数来给网络增加非线性因素。

网络代码实现：

class ImageClassification(nn.Module):


    def __init__(self):

        super(ImageClassification, self).__init__()

        self.conv1 = nn.Conv2d(3, 6, stride=1, kernel_size=3)
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(6, 16, stride=1, kernel_size=3)
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)

        self.linear1 = nn.Linear(576, 120)
        self.linear2 = nn.Linear(120, 84)
        self.out = nn.Linear(84, 10)


    def forward(self, x):

        x = F.relu(self.conv1(x))
        x = self.pool1(x)

        x = F.relu(self.conv2(x))
        x = self.pool2(x)

        x = x.reshape(x.size(0), -1)
        x = F.relu(self.linear1(x))
        x = F.relu(self.linear2(x))

        return self.out(x)

编写训练函数

训练时，使用多分类交叉熵损失函数，Adam 优化器：

def train():

    transgform = Compose([ToTensor()])
    cifar10 = torchvision.datasets.CIFAR10(root='data', train=True, download=True, transform=transgform)


    model = ImageClassification()

    criterion = nn.CrossEntropyLoss()

    optimizer = optim.Adam(model.parameters(), lr=1e-3)
    # 训练轮数
    epoch = 100

    for epoch_idx in range(epoch):

        # 构建数据加载器
        dataloader = DataLoader(cifar10, batch_size=BATCH_SIZE, shuffle=True)
        # 样本数量
        sam_num = 0
        # 损失总和
        total_loss = 0.0
        # 开始时间
        start = time.time()
        correct = 0

        for x, y in dataloader:
            # 送入模型
            output = model(x)
            # 计算损失
            loss = criterion(output, y)
            # 梯度清零
            optimizer.zero_grad()
            # 反向传播
            loss.backward()
            # 参数更新
            optimizer.step()

            correct += (torch.argmax(output, dim=-1) == y).sum()
            total_loss += (loss.item() * len(y))
            sam_num += len(y)

        print('epoch:%2s loss:%.5f acc:%.2f time:%.2fs' %
              (epoch_idx + 1,
               total_loss / sam_num,
               correct / sam_num,
               time.time() - start))


    torch.save(model.state_dict(), 'model/image_classification.bin')

编写预测函数

我们加载训练好的模型，对测试集中的 1 万条样本进行预测，查看模型在测试集上的准确率

def test():


    transgform = Compose([ToTensor()])
    cifar10 = torchvision.datasets.CIFAR10(root='data', train=False, download=True, transform=transgform)
    # 构建数据加载器
    dataloader = DataLoader(cifar10, batch_size=BATCH_SIZE, shuffle=True)
    # 加载模型
    model = ImageClassification()
    model.load_state_dict(torch.load('model/image_classification.bin'))
    model.eval()


    total_correct = 0
    total_samples = 0
    for x, y in  dataloader:
        output = model(x)
        total_correct += (torch.argmax(output, dim=-1) == y).sum()
        total_samples += len(y)

    print('Acc: %.2f' % (total_correct / total_samples))

输出：