深度学习入门：卷积神经网络 | CNN概述，图像基础知识，卷积层，池化层（超详解！！！）

🍔 前言

🍔 图像基础知识

1. 像素和通道的理解

2. 小节

🍔 卷积层

1. 卷积计算

2. Padding

3. Stride

4. 多通道卷积计算

5. 多卷积核卷积计算

6. 特征图大小

7. PyTorch 卷积层 API

7. 小节

🍔 池化层

1. 池化层计算编辑

2. Stride

3. Padding

4. 多通道池化计算

5. PyTorch 池化 API 使用

5. 小节

🍔 前言

CNN概述🤖

卷积神经网络是深度学习在计算机视觉领域的突破性成果. 在计算机视觉领域, 往往我们输入的图像都很大，使用全连接网络的话，计算的代价较高. 另外图像也很难保留原有的特征，导致图像处理的准确率不高.

卷积神经网络（Convolutional Neural Network）是含有卷积层的神经网络. 卷积层的作用就是用来自动学习、提取图像的特征.

CNN网络主要有三部分构成：卷积层、池化层和全连接层构成。

🐼 卷积层负责提取图像中的局部特征；

🐼 池化层用来大幅降低参数量级(降维)；

🐼 全连接层类似人工神经网络的部分，用来输出想要的结果。

🍔 图像基础知识

学习目标

🍀 知道像素、通道等概念

🍀 掌握使用matplotlib加载图片方法

我们在进行图像任务时，需要了解图像的基础知识。图像是由像素点组成的，每个像素点的值范围为: [0, 255], 像素值越大意味着较亮。比如一张 200x200 的图像, 则是由 40000 个像素点组成, 如果每个像素点都是 0 的话, 意味着这是一张全黑的图像.

我们看到的彩色图一般都是多通道的图像, 所谓多通道可以理解为图像由多个不同的图像层叠加而成, 例如我们看到的彩色图像一般都是由 RGB 三个通道组成的，还有一些图像具有 RGBA 四个通道，最后一个通道为透明通道，该值越小，则图像越透明。

1. 像素和通道的理解

接下来，我们使用 matplotlib 库来实际理解下上面讲解的图像知识。

话不多说，直接上代码演示💯：

import numpy as np
import matplotlib.pyplot as plt


# 1. 图像基本理解
def test01():

    img = np.zeros([200, 200])
    print(img)
    plt.imshow(img, cmap='gray', vmin=0, vmax=255)
    plt.show()

    img = np.full([255, 255], 255)
    print(img)
    plt.imshow(img, cmap='gray', vmin=0, vmax=255)
    plt.show()


# 2. 图像的通道
def test02():

    img = plt.imread('data/彩色图片.png')
    # 修改数据的维度
    img = np.transpose(img, [2, 0, 1])

    # 打印所有通道
    for channel in img:
        print(channel)
        plt.imshow(channel)
        plt.show()


    # 修改透明度
    img[3] = 0.05
    img = np.transpose(img, [1, 2, 0])
    plt.imshow(img)
    plt.show()


if __name__ == '__main__':
    test01()
    test02()

程序输出结果:

2. 小节

在本小节我们了解了图像的像素、通道相关概念。图像是由像素点组成的，像素值的范围 [0, 255] 值越小表示亮度越小，值越大，表名亮度值越大。一个全0的图像就是一副全黑图像。一个复杂的图像则是由多个通道组合在一起形成的。

🍔 卷积层

学习目标

🍀 掌握卷积计算过程

🍀 掌握特征图大小计算方法

🍀 掌握PyTorch卷积层API

卷积层在深度学习中具有极其重要的地位，特别是在图像处理和计算机视觉领域。它能够有效地提取图像中的特征，通过滑动窗口和权重共享机制，实现对图像的高效处理。学习卷积层不仅有助于理解深度学习的基本原理，也是掌握先进图像处理技术的关键。

接下来，我们开始学习卷积核的计算过程, 即: 卷积核是如何提取特征的.

1. 卷积计算

input 表示输入的图像
filter 表示卷积核, 也叫做滤波器
input 经过 filter 的得到输出为最右侧的图像，该图叫做特征图

那么, 它是如何进行计算的呢？卷积运算本质上就是在滤波器和输入数据的局部区域间做点积。

左上角的点计算方法：

按照上面的计算方法可以得到最终的特征图为:

2. Padding

通过上面的卷积计算过程，我们发现最终的特征图比原始图像小很多，如果想要保持经过卷积后的图像大小不变, 可以在原图周围添加 padding 来实现.

3. Stride

按照步长为1来移动卷积核，计算特征图如下所示：

如果我们把 Stride 增大为2，也是可以提取特征图的，如下图所示：

4. 多通道卷积计算

实际中的图像都是多个通道组成的，我们怎么计算卷积呢？

计算方法如下： 1. 当输入有多个通道(Channel), 例如 RGB 三个通道, 此时要求卷积核需要拥有相同的通道数数. 2. 每个卷积核通道与对应的输入图像的各个通道进行卷积. 3. 将每个通道的卷积结果按位相加得到最终的特征图.

如下图所示:

5. 多卷积核卷积计算

上面的例子里我们只使用一个卷积核进行特征提取, 实际对图像进行特征提取时, 我们需要使用多个卷积核进行特征提取. 这个多个卷积核可以理解为从不同到的视角、不同的角度对图像特征进行提取.

那么, 当使用多个卷积核时, 应该怎么进行特征提取呢?

6. 特征图大小

输出特征图的大小与以下参数息息相关:

size: 卷积核/过滤器大小，一般会选择为奇数，比如有 1*1, 3*3， 5*5*
Padding: 零填充的方式
Stride: 步长

那计算方法如下图所示:

输入图像大小: W x W
卷积核大小: F x F
Stride: S
Padding: P
输出图像大小: N x N

以下图为例:

图像大小: 5 x 5
卷积核大小: 3 x 3
Stride: 1
Padding: 1
(5 - 3 + 2) / 1 + 1 = 5, 即得到的特征图大小为: 5 x 5

7. PyTorch 卷积层 API

我们接下来对下面的图片进行特征提取:

test01 函数使用一个多通道卷积核进行特征提取, test02 函数使用 3 个多听到卷积核进行特征提取:

import torch
import torch.nn as nn
import matplotlib.pyplot as plt


# 显示图像
def show(img):

    # 输入形状: (Height, Width, Channel)
    plt.imshow(img)
    plt.axis('off')
    plt.show()


# 1. 单个多通道卷积核
def test01():

    # 读取图像, 形状: (640, 640, 4)
    img = plt.imread('data/彩色图片.png')
    show(img)

    # 构建卷积层
    # 由于 out_channels 为 1, 相当于只有一个4通道卷积核
    conv = nn.Conv2d(in_channels=4, out_channels=1, kernel_size=3, stride=1, padding=1)

    # 输入形状: (BatchSize, Channel, Height, Width)
    # mg形状: torch.Size([4, 640, 640])
    img = torch.tensor(img).permute(2, 0, 1)

    # img 形状: torch.Size([1, 4, 640, 640])
    img = img.unsqueeze(0)

    # 输入卷积层, new_img 形状: torch.Size([1, 1, 640, 640])
    new_img = conv(img)

    # new_img 形状: torch.Size([640, 640, 1])
    new_img = new_img.squeeze(0).permute(1, 2, 0)

    show(new_img.detach().numpy())


# 2. 多个多通道卷积核
def test02():

    # 读取图像, 形状: (640, 640, 4)
    img = plt.imread('data/彩色图片.png')
    show(img)

    # 构建卷积层
    # 由于 out_channels 为 3, 相当于只有 3 个4通道卷积核
    conv = nn.Conv2d(in_channels=4, out_channels=3, kernel_size=3, stride=1, padding=1)

    # 输入形状: (BatchSize, Channel, Height, Width)
    # img形状: torch.Size([3, 640, 640])
    img = torch.tensor(img).permute(2, 0, 1)

    # img 形状: torch.Size([1, 3, 640, 640])
    img = img.unsqueeze(0)

    # 输入卷积层, new_img 形状: torch.Size([1, 3, 640, 640])
    new_img = conv(img)

    # new_img 形状: torch.Size([640, 640, 3])
    new_img = new_img.squeeze(0).permute(1, 2, 0)

    # 打印三个特征图
    show(new_img[:, :, 0].unsqueeze(2).detach().numpy())
    show(new_img[:, :, 1].unsqueeze(2).detach().numpy())
    show(new_img[:, :, 2].unsqueeze(2).detach().numpy())


if __name__ == '__main__':
    test01()
    test02()

程序输出结果：

7. 小节

本小节主要学习卷积层相关知识，卷积层主要用于提取图像特征，避免对复杂图像特征的手动提取，经过实践表明，基于卷积核实现的自动特征提取在很多场景下的效果要好于手动特征提取。

🍔 池化层

学习目标

🍀 掌握池化计算过程

🍀 掌握PyTorch池化层API

池化层 (Pooling) 降低维度, 缩减模型大小，提高计算速度. 即: 主要对卷积层学习到的特征图进行下采样（SubSampling）处理.

池化层主要有两种:

最大池化
平均池化

1. 池化层计算

最大池化:

max(0, 1, 3, 4)
max(1, 2, 4, 5)
max(3, 4, 6, 7)
max(4, 5, 7, 8)

平均池化:

mean(0, 1, 3, 4)
mean(1, 2, 4, 5)
mean(3, 4, 6, 7)
mean(4, 5, 7, 8)

2. Stride

最大池化:

max(0, 1, 4, 5)
max(2, 3, 6, 7)
max(8, 9, 12, 13)
max(10, 11, 14, 15)

平均池化:

mean(0, 1, 4, 5)
mean(2, 3, 6, 7)
mean(8, 9, 12, 13)
mean(10, 11, 14, 15)

3. Padding

最大池化:

max(0, 0, 0, 0)
max(0, 0, 0, 1)
max(0, 0, 1, 2)
max(0, 0, 2, 0)
... 以此类推

平均池化:

mean(0, 0, 0, 0)
mean(0, 0, 0, 1)
mean(0, 0, 1, 2)
mean(0, 0, 2, 0)
... 以此类推

4. 多通道池化计算

在处理多通道输入数据时，池化层对每个输入通道分别池化，而不是像卷积层那样将各个通道的输入相加。这意味着池化层的输出和输入的通道数是相等。

5. PyTorch 池化 API 使用

import torch
import torch.nn as nn


# 1. API 基本使用
def test01():

    inputs = torch.tensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]]).float()
    inputs = inputs.unsqueeze(0).unsqueeze(0)

    # 1. 最大池化
    # 输入形状: (N, C, H, W)
    polling = nn.MaxPool2d(kernel_size=2, stride=1, padding=0)
    output = polling(inputs)
    print(output)

    # 2. 平均池化
    polling = nn.AvgPool2d(kernel_size=2, stride=1, padding=0)
    output = polling(inputs)
    print(output)


# 2. stride 步长
def test02():

    inputs = torch.tensor([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]]).float()
    inputs = inputs.unsqueeze(0).unsqueeze(0)

    # 1. 最大池化
    polling = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
    output = polling(inputs)
    print(output)

    # 2. 平均池化
    polling = nn.AvgPool2d(kernel_size=2, stride=2, padding=0)
    output = polling(inputs)
    print(output)


# 3. padding 填充
def test03():

    inputs = torch.tensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]]).float()
    inputs = inputs.unsqueeze(0).unsqueeze(0)

    # 1. 最大池化
    polling = nn.MaxPool2d(kernel_size=2, stride=1, padding=1)
    output = polling(inputs)
    print(output)

    # 2. 平均池化
    polling = nn.AvgPool2d(kernel_size=2, stride=1, padding=1)
    output = polling(inputs)
    print(output)


# 4. 多通道池化
def test04():

    inputs = torch.tensor([[[0, 1, 2], [3, 4, 5], [6, 7, 8]],
                           [[10, 20, 30], [40, 50, 60], [70, 80, 90]],
                           [[11, 22, 33], [44, 55, 66], [77, 88, 99]]]).float()

    inputs = inputs.unsqueeze(0)

    # 最大池化
    polling = nn.MaxPool2d(kernel_size=2, stride=1, padding=0)
    output = polling(inputs)
    print(output)


if __name__ == '__main__':
    test04()