原文链接：AI 基础知识从 0.4 到 0.5—— 计算机视觉之光 CNN 原文链接：AI 基础知识从 0.4 到 0.5—— 计算机视觉之光 CNN

AI 基础知识从 0.4 到 0.5—— 计算机视觉之光 CNN

计算机视觉的发展

1. ImageNet 大规模视觉识别挑战赛由斯坦福大学李飞飞团队于 2010 年发起的，其核心目标是推动图像分类、目标检测、场景解析等任务的算法创新。前两年 ImageNet 竞赛的排行榜由传统机器学习方法垄断，2010 年的冠军 SIFT+FVS（错误率 28.2%）、2011 年的冠军稀疏编码（错误率 25.7%），这和人类平均错误率 5.1% 相距甚远，无法达到工业落地标准。
   1. 但 2012 年发生了历史性转折——使用 CNN 架构的 AlexNet 在 ImageNet 竞赛中以 15.3% 的错误率碾压传统方法（第二名 26.2%），这也直接导致传统特征工程研究的式微，学术界开始转向 CNN 架构探索。2014 年的 VGGNet 通过堆叠 16-19 层卷积层，将错误率降至 7.3%；2015 年的 ResNet 引入残差连接，错误率进一步降至 3.57%，首次超越人类水平。

什么是卷积

1. 在数学中，**卷积（Convolutional）**是一种描述两个函数如何通过 “相互作用” 生成新函数的运算，其核心思想是 “翻转、平移、叠加”。对于连续函数其数学公式如下：
   1. 核心分三步步骤：
2. 对于离散数列和卷积定义为：

卷积的现实意义

掷骰子

1. 当掷两个六面骰子时，两个骰子的点数和的概率分布是通过卷积运算得到的。每个骰子的点数可以看作一个离散的概率分布，两个骰子的和就是这两个概率分布的卷积。

信号处理

1. 无线通信中的电信号本应是平滑的波浪信息，但现实世界充满了电磁干扰、设备噪声或环境扰动，导致波形失真，收音机的杂音、摄像头的雪花屏等都是信号被噪声污染的表现。
   1. 如何从夹杂噪声的信号中提取出 “干净” 的有效信息？一种经典且高效的方法是使用移动平均滤波器（Moving Average Filter）。它的核心思想是通过对信号的局部邻域进行加权平均，抑制高频噪声的干扰，让信号重新回归平滑，而这一过程的数学本质正是卷积运算。比如一个 3 点移动平均滤波器会将信号中每个点的值替换为该点及其前后各一点的平均值，从而 “熨平” 突变的噪声尖峰。

CNN 的卷积

1. CNN 中也利用了类似信号处理中的滤波器（称之为卷积核 Kernel）对图像进行特征提取，卷积核本质上是一个小的权重矩阵，通过在输入图像上进行滑动，执行卷积操作，从而提取图像中的特征。每一个卷积核都可以检测特定类型的特征，像边缘、纹理等。
   1. 假设输入是一张二维图像，卷积核在图像上从左到右、从上到下滑动，每次滑动时，卷积核与它覆盖的图像区域对应元素相乘，然后将结果相加，得到一个输出值。这个过程持续进行，直到卷积核遍历完整个图像，最终得到一个特征图。
2. cv2 是 OpenCV 库在 Python 中的接口，它是一个广泛应用于计算机视觉任务的开源库，提供了丰富的图像处理和计算机视觉算法。
3. Sobel 核是一种广泛应用于图像处理和计算机视觉中的边缘检测滤波器。旨在突出图像中的边缘特征，帮助识别图像中物体的边界和形状。
4. 垂直边缘检测卷积核的设计是基于图像中垂直边缘处灰度值的变化特点。在垂直边缘处，图像的一侧灰度值较高，而另一侧灰度值较低。卷积核中的数值能够捕捉到这种灰度值的变化，当卷积核与图像中的垂直边缘对齐时，加权求和的结果会比较大，从而在输出图像中突出显示垂直边缘。
5. 卷积操作本质上是对两个函数进行的一种数学运算，在图像处理中，图像和卷积核可以看作一个二元离散函数，卷积操作可以理解为对图像函数和卷积核函数进行卷积。通过卷积操作，我们可以得到一个新的函数（新的图像数组），它是原图像函数和卷积核函数相互作用的结果。

CNN 架构

1. CNN 由多个功能层堆叠而成，核心层包括：
   1. 输入层：负责接收原始数据，如图像的像素值。对于彩色图像，通常有红、绿、蓝三个通道，而灰度图像则只有一个通道。
   2. 卷积层：图像特征的 “过滤器”，通过卷积核在输入图像上滑动，计算局部像素的加权和，提取局部特征（如边缘、纹理、颜色）。
   3. 激活函数层：通常在卷积层之后使用，为模型引入非线性因素，使模型能够学习到更复杂的函数关系。常见的激活函数有 ReLU、Sigmoid、Tanh 等。
   4. 池化层：特征的 “压缩器”，对卷积层输出的特征图进行降维，保留关键信息，减少计算量，同时增强特征的平移不变性（如物体位置稍有移动，特征仍不变）。
   5. 全连接层：特征的 “分类器”，将池化层输出的特征图** “拉平” 成一维向量**，通过全连接网络进行分类（如判断图像是猫还是狗）。
   6. 输出层：根据具体的任务输出结果。例如在分类任务中，输出各个类别的概率；在回归任务中，输出连续的数值。常用的输出层激活函数有 Softmax（用于多分类任务，将输出转化为各个类别的概率分布）、Sigmoid（用于二分类任务，输出 0 到 1 之间的概率值）等。
2. 在实际的 CNN 架构中，通常会包含多个卷积层、激活函数层和池化层的组合，形成一个深度网络，以逐步提取更高级、更抽象的特征。不同的 CNN 模型在层数、卷积核大小、步长、池化方式等方面会有所不同，以适应不同的任务和数据特点。

CNN 如何解决参数爆炸问题

1. 传统神经网络在处理图片时候由于网络层数加深、神经元数量增多，导致需要学习的参数数量急剧增长，进而引发计算量过大、训练时间过长以及过拟合等一系列问题。CNN 架构的特性可以解决参数爆炸问题：
   1. 参数爆炸
      1. 局部连接：在卷积层一个卷积核仅在图像的一个小区域（感受野）上进行卷积操作，并非和整个图像的所有像素连接。比如处理一张大小为 28x28 像素的图像，若采用全连接层且有 100 个神经元，参数数量是 2828100 = 78400个；若使用 5x5 的卷积核进行卷积操作，每个卷积核的参数数量仅为 5*5 = 25 个。
      2. 参数共享：在 CNN 中，同一个卷积核在整个输入数据上滑动进行卷积操作，即卷积核的参数在不同位置是共享的。这意味着无论输入数据的大小怎样，只需学习一组卷积核的参数。在一个卷积层使用 10 个 5 * 5 的卷积核，不管输入图像大小是 28 * 28 还是更大，需要学习的参数数量始终是 10 * 5 * 5 = 250 个，不会随输入数据增大而无限增加。
      3. 池化操作：池化层一般紧跟在卷积层之后，用于对卷积层的输出进行下采样，也就是减少特征图的尺寸。对一个 28 * 28 的特征图进行 2 * 2 的最大池化操作后，特征图尺寸变为 14 * 14，相应地后续层的参数数量也会减少。
   2. 丢失空间结构信息
      1. 图像、视频等数据具有天然的空间结构信息，如像素之间的邻接关系、物体的空间布局等。传统的全连接网络会破坏这种空间结构，CNN 架构模型卷积核在输入数据上进行滑动卷积操作时，每个神经元只关注输入图像的一个小区域，有效捕捉图像中的局部特征，如边缘和角点，这样保留了像素之间的局部空间关系。

使用 CNN 实现手写数字识别

定义一个简单的 CNN，由两个卷积层、两个池化层、一个全连接层和一个输出层组成。

▼
python
复制代码
  class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        # 第一个卷积层：灰度图输入通道数=1，输出通道数=32，卷积核大小=3x3
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        # 第二个卷积层：输入通道数=32，输出通道数=64，卷积核大小=3x3
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        # 最大池化层：2x2
        self.pool = nn.MaxPool2d(2, 2)
        # 全连接层：输入=64 * 7 * 7（在两次池化后，图像尺寸变为7x7），输出=128
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        # 输出层：输入=128，输出=10（对应0-9十个数字）
        self.fc2 = nn.Linear(128, 10)
        
    def forward(self, x):
        # 卷积 -> ReLU -> 池化
        x = self.pool(F.relu(self.conv1(x)))
        # 卷积 -> ReLU -> 池化
        x = self.pool(F.relu(self.conv2(x)))
        # 展平，将多维张量展平成一维向量
        x = x.view(-1, 64 * 7 * 7)
        # 全连接 -> ReLU
        x = F.relu(self.fc1(x))
        # 输出层
        x = self.fc2(x)
        return x

# 实例化模型
model = CNN()

卷积层

1. self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
   1. 输入通道数：对于灰度图像，通道数为 1；对于彩色图像，通常通道数为 3（RGB）。
   2. 输出通道数：每个卷积层会使用多个卷积核进行卷积操作，输出通道数就等于卷积核的数量。代码中self.conv1 使用 32 个卷积核，self.conv2 使用 64 个卷积核，增加输出通道数可以让模型学习到更多的特征。
   3. kernel_size：卷积核的大小，这里设置为 3x3，这是一种常用的卷积核大小，能够在捕捉局部特征的同时，控制参数数量。
   4. padding：填充的大小，设置为 1 表示在图像的边界周围填充一圈 0。填充的目的是在卷积操作后保持图像的尺寸不变。
      1. 在卷积过程中，卷积核从输入数据的左上角开始，按照一定的步长（stride）在输入数据上滑动进行计算。当卷积核滑动到输入数据的边缘时，如果再继续滑动就会超出输入数据的范围，此时卷积操作就会停止。这样会导致输出特征图的尺寸变小，而且边缘信息会因为卷积核无法完全覆盖而丢失较多，使得边缘部分的特征提取不够充分。

池化层

1. self.pool = nn.MaxPool2d(2, 2)
   1. 池化窗口的大小：这里设置为 2，表示池化窗口是 2x2 的。
2. 池化操作的步长：这里也设置为 2。步长为 2 意味着池化窗口每次移动 2 个像素。
   1. MaxPool 会对每个2x2的区域取最大值，经过这样设置的池化操作后，图像的尺寸会缩小一半，28x28 的输入通过一个 2x2 池化层后变为 14x14

全连接层

1. self.fc1 = nn.Linear(64 * 7 * 7, 128)
   1. 输入特征的数：在 self.fc1 中，输入特征的数量是 64*7*7，这是因为经过两次 2*2 的最大池化操作后，图像的尺寸从 28*28 变为 7*7，而 self.conv2 的输出通道数为 64，所以特征图的总特征数量为 64*7*7。
   2. 输出特征数：全连接层的输出特征数决定了下一层的维度。128 一个中等大小的隐藏层神经元数量的经验值，足以学习到复杂的特征表示，同时避免过多的参数导致过拟合。

输出层

1. self.fc2 = nn.Linear(128, 10)
   1. 输入特征数：self.fc1 的输出特征数量设置为 128，做为下一层的 self.fc2 的输入层特征数是 128。
   2. 输出特征数：因为手写数字识别任务有 0-9 这十个类别，所以输出层需要输出 10 个值，分别表示图像属于每个类别的概率。

前向传播路径

1. Pytorch nn.Module 类的 forward() 方法定义了输入数据在神经网络模型中前向传播的具体计算流程。前向传播指的是输入数据从输入层开始，依次经过神经网络的各个层（如卷积层、池化层、全连接层等），最终得到输出结果的过程。
   1. x = self.pool(F.relu(self.conv1(x)))
      1. self.conv1(x): 对输入进行第一层卷积操作，输出 32 个特征图，每个特征图的大小为 28x28。
      2. F.relu(...): 应用 ReLU 激活函数，引入非线性，使模型能够学习更复杂的特征。
      3. self.pool(...): 进行一次 2x2 最大池化，将特征图尺寸从 28x28 缩小到 14x14。
2. PyTorch 的基本使用：https://www.yuque.com/sunluyong/survivor/hr49pkt86xae7g92
3. 完整代码：

▼
python
复制代码
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
import numpy as np

# 检查是否有GPU可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 定义CNN模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        # 第一个卷积层
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        # 第二个卷积层
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        # 池化层
        self.pool = nn.MaxPool2d(2, 2)
        # 全连接层
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        # 输出层
        self.fc2 = nn.Linear(128, 10)
        
    def forward(self, x):
        # 卷积 -> ReLU -> 池化
        x = self.pool(F.relu(self.conv1(x)))
        # 卷积 -> ReLU -> 池化
        x = self.pool(F.relu(self.conv2(x)))
        # 展平
        x = x.view(-1, 64 * 7 * 7)
        # 全连接 -> ReLU
        x = F.relu(self.fc1(x))
        # 输出层
        x = self.fc2(x)
        return x

# 实例化模型并移动到设备
model = CNN().to(device)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 定义数据预处理步骤
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

# 下载并加载训练集
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)

# 下载并加载测试集
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1000, shuffle=False)

# 定义训练函数
def train(model, device, train_loader, optimizer, epoch):
    model.train()
    running_loss = 0.0
    for batch_idx, (data, target) in enumerate(train_loader):
        # 将数据移动到设备上
        data, target = data.to(device), target.to(device)
        
        # 零化参数梯度
        optimizer.zero_grad()
        
        # 前向传播
        outputs = model(data)
        
        # 计算损失
        loss = criterion(outputs, target)
        
        # 反向传播
        loss.backward()
        
        # 更新权重
        optimizer.step()
        
        running_loss += loss.item()
        if batch_idx % 100 == 99:
            print(f"Epoch [{epoch}], Batch [{batch_idx + 1}], Loss: {running_loss / 100:.4f}")
            running_loss = 0.0

# 训练模型
epochs = 5
for epoch in range(1, epochs + 1):
    train(model, device, train_loader, optimizer, epoch)

# 定义测试函数
def test(model, device, test_loader):
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            outputs = model(data)
            _, predicted = torch.max(outputs.data, 1)
            total += target.size(0)
            correct += (predicted == target).sum().item()
    print(f"测试集准确率: {100 * correct / total:.2f}%")

test(model, device, test_loader)

# 可视化部分预测结果
dataiter = iter(test_loader)
images, labels = next(dataiter)

# 将数据移动到设备上
images, labels = images.to(device), labels.to(device)

# 获取预测结果
outputs = model(images)
_, preds = torch.max(outputs, 1)

# 移动数据到CPU并转换为NumPy数组
images = images.cpu().numpy()
preds = preds.cpu().numpy()
labels = labels.cpu().numpy()

# 可视化前 10 个样本
plt.rcParams['font.family'] = 'SimSong' # 设置中文字体
fig, axes = plt.subplots(2, 5, figsize=(12, 6))
axes = axes.flatten()
for idx in range(10):
    img = images[idx].squeeze()
    axes[idx].imshow(img, cmap='gray')
    axes[idx].set_title(f"真实: {labels[idx]}, 预测: {preds[idx]}")
    axes[idx].axis('off')
plt.tight_layout()
plt.show()

CNN 家族模型与应用

常见模型

1. CNN 凭借强大的特征提取能力和对图像数据的高效处理，成为计算机视觉任务的核心技术。从早期探索到技术突破，众多 CNN 模型不断推动着领域发展：
   1. LeNet-5:
      1. 早期经典的卷积神经网络，专为手写数字识别设计。
      2. LeNet-5 通过层级化的卷积和池化操作提取图像特征，结合全连接层进行分类。其简洁的架构适用于简单的图像识别任务，如手写数字和字符识别，是现代深度学习模型的奠基石。
   2. AlexNet:
      1. 突破性的深度卷积网络，显著提升图像分类性能并引领深度学习热潮。
      2. AlexNet 采用更深的网络结构和 ReLU 激活函数，加上数据增强和 Dropout 正则化，大幅提升了大规模图像分类的准确率。它在2012年 ImageNet 竞赛中取得显著成绩，适用于复杂的图像识别和计算机视觉任务，如图像分类和对象识别。
   3. VGGNet:
      1. 以均匀的 3×3 卷积核堆叠构建的深度网络，强调简洁和深度。
      2. VGGNet 通过连续堆叠小卷积核增加网络深度，提升特征表达能力。其模块化设计便于扩展和迁移学习，广泛应用于图像分类、对象检测和分割等领域，尤其在需要高精度特征提取的任务中表现优异。
   4. GoogLeNet(Inception): 
      1. 引入 Inception 模块的高效深度网络，优化计算资源利用。
      2. GoogLeNet 通过 Inception 模块在同一层处理多尺度特征，减少参数数量并提高计算效率。它采用深层网络架构，适用于资源受限环境下的大规模图像识别和检测任务，在保持高准确率的同时显著降低了计算成本。
   5. ResNet: 
      1. 采用残差学习的深层网络，解决深度网络训练中的退化问题。
      2. ResNet 引入残差连接，使信息在网络中更易传播，允许构建超过100层的深度网络而不会出现梯度消失。通过跳跃连接，ResNet有效缓解了深度模型的退化问题，广泛应用于图像分类、目标检测和语义分割，显著提升了模型的表现和训练效率。
   6. EfficientNet: 
      1. 通过复合缩放优化网络结构与深度的高效卷积网络。
      2. EfficientNet 系列通过均衡地缩放网络的深度、宽度和分辨率，达到更高的性能与效率。它采用复合缩放方法，优化模型复杂度和精度，适用于各种图像分类和视觉任务，提供了在相同计算资源下更优的准确率表现，广泛应用于工业和研究领域。
   7. YOLO (You Only Look Once): 
      1. 实时目标检测模型，快速准确地在图像中定位和分类对象。
      2. YOLO 将目标检测视为单一回归问题，通过一个网络直接预测边界框和类别概率，实现高速度和实时检测。它在处理实时视频流和需要快速响应的应用场景（如自动驾驶、监控系统）中表现优异，能够同时检测和分类多个对象，极大提高了目标检测的效率和实用性。
   8. MTCNN (Multi-task Cascaded Convolutional Networks，多任务级联卷积网络): 
      1. 多任务级联卷积网络，用于高效的人脸检测与关键点定位。MTCNN 通过三级级联网络同时执行人脸检测和关键点定位，提升了检测的精度和鲁棒性。其层级化结构首先生成候选区域，然后细化边界框，最后定位关键点（如眼睛、鼻子等）。MTCNN在各种复杂环境下（如不同光照、表情变化）表现出色，广泛应用于人脸识别、面部表情分析和增强现实等需要精确人脸检测的场景中。