【一文读懂】卷积神经网络（CNN）底子详解

《------往期经典保举------》

一、AI应用软件开发实战专栏【链接】
项目名称项目名称1.【人脸识别与管理系统开发】2.【车牌识别与主动收费管理系统开发】3.【手势识别系统开发】4.【人脸面部活体检测系统开发】5.【图片风格快速迁移软件开发】6.【人脸表表情识别系统】7.【YOLOv8多目标识别与主动标注软件开发】8.【基于深度学习的行人跌倒检测系统】9.【基于深度学习的PCB板缺陷检测系统】10.【基于深度学习的生活垃圾分类目标检测系统】11.【基于深度学习的安全帽目标检测系统】12.【基于深度学习的120种犬类检测与识别系统】13.【基于深度学习的路面坑洞检测系统】14.【基于深度学习的火焰烟雾检测系统】15.【基于深度学习的钢材表面缺陷检测系统】16.【基于深度学习的舰船目标分类检测系统】17.【基于深度学习的西红柿成熟度检测系统】18.【基于深度学习的血细胞检测与计数系统】19.【基于深度学习的吸烟/抽烟举动检测系统】20.【基于深度学习的水稻害虫检测与识别系统】21.【基于深度学习的高精度车辆行人检测与计数系统】22.【基于深度学习的路面标志线检测与识别系统】23.【基于深度学习的智能小麦害虫检测识别系统】24.【基于深度学习的智能玉米害虫检测识别系统】25.【基于深度学习的200种鸟类智能检测与识别系统】26.【基于深度学习的45种交通标志智能检测与识别系统】27.【基于深度学习的人脸面部表情识别系统】28.【基于深度学习的苹果叶片病害智能诊断系统】29.【基于深度学习的智能肺炎诊断系统】30.【基于深度学习的葡萄簇目标检测系统】31.【基于深度学习的100种中草药智能识别系统】32.【基于深度学习的102种花卉智能识别系统】33.【基于深度学习的100种蝴蝶智能识别系统】34.【基于深度学习的水稻叶片病害智能诊断系统】35.【基于与ByteTrack的车辆行人多目标检测与追踪系统】36.【基于深度学习的智能草莓病害检测与分割系统】37.【基于深度学习的复杂场景下船舶目标检测系统】38.【基于深度学习的农作物幼苗与杂草检测系统】39.【基于深度学习的智能门路裂缝检测与分析系统】40.【基于深度学习的葡萄病害智能诊断与防治系统】41.【基于深度学习的遥感地理空间物体检测系统】42.【基于深度学习的无人机视角地面物体检测系统】43.【基于深度学习的木薯病害智能诊断与防治系统】44.【基于深度学习的田野火焰烟雾检测系统】45.【基于深度学习的脑肿瘤智能检测系统】46.【基于深度学习的玉米叶片病害智能诊断与防治系统】47.【基于深度学习的橙子病害智能诊断与防治系统】48.【基于深度学习的车辆检测追踪与流量计数系统】49.【基于深度学习的行人检测追踪与双向流量计数系统】50.【基于深度学习的反光衣检测与预警系统】51.【基于深度学习的伤害地区人员突入检测与报警系统】52.【基于深度学习的高密度人脸智能检测与统计系统】53.【基于深度学习的CT扫描图像肾结石智能检测系统】54.【基于深度学习的水果智能检测系统】55.【基于深度学习的水果质量优劣智能检测系统】56.【基于深度学习的蔬菜目标检测与识别系统】57.【基于深度学习的非机动车驾驶员头盔检测系统】58.【太基于深度学习的阳能电池板检测与分析系统】59.【基于深度学习的工业螺栓螺母检测】60.【基于深度学习的金属焊缝缺陷检测系统】61.【基于深度学习的链条缺陷检测与识别系统】62.【基于深度学习的交通讯号灯检测识别】63.【基于深度学习的草莓成熟度检测与识别系统】64.【基于深度学习的水下海生物检测识别系统】65.【基于深度学习的门路交通事故检测识别系统】66.【基于深度学习的安检X光伤害品检测与识别系统】67.【基于深度学习的农作物种别检测与识别系统】68.【基于深度学习的伤害驾驶举动检测识别系统】69.【基于深度学习的维修工具检测识别系统】70.【基于深度学习的维修工具检测识别系统】71.【基于深度学习的建筑墙面损伤检测系统】72.【基于深度学习的煤矿传送带异物检测系统】73.【基于深度学习的老鼠智能检测系统】74.【基于深度学习的水面垃圾智能检测识别系统】75.【基于深度学习的遥感视角船只智能检测系统】76.【基于深度学习的胃肠道息肉智能检测分割与诊断系统】77.【基于深度学习的心脏超声图像间隔壁检测分割与分析系统】78.【基于深度学习的心脏超声图像间隔壁检测分割与分析系统】79.【基于深度学习的果园苹果检测与计数系统】80.【基于深度学习的半导体芯片缺陷检测系统】81.【基于深度学习的糖尿病视网膜病变检测与诊断系统】82.【基于深度学习的运动鞋品牌检测与识别系统】83.【基于深度学习的苹果叶片病害检测识别系统】84.【基于深度学习的医学X光骨折检测与语音提示系统】85.【基于深度学习的遥感视角农田检测与分割系统】 二、机器学习实战专栏【链接】，已更新31期，接待关注，连续更新中~~
三、深度学习【Pytorch】专栏【链接】
四、【Stable Diffusion绘画系列】专栏【链接】
五、YOLOv8改进专栏【链接】，连续更新中~~
六、YOLO性能对比专栏【链接】，连续更新中~

《------正文------》

  
卷积神经网络（CNN）

卷积神经网络（CNN）是一类功能强大的深度学习模型，旨在处置惩罚图像等网格状数据。他们通过从原始数据中有效地提取分层特性（边沿、纹理和对象），彻底改变了盘算机视觉、图像识别和医学成像等范畴。
在本文中，我们将使用领先的深度学习框架PyTorch探索CNN的架构、数学和实际实现。从卷积层、池化层、过滤器（或内核）、添补和步幅等核心概念开始，我们将逐步构建和训练CNN模型。此外还介绍了一些先进的技能，如数据加强、DropOut和迁移学习，以进步性能。最后，您将深入相识CNN底子知识以及在实际世界场景中有效应用它们的技能。
1、简介

卷积神经网络（CNN）受到人类视觉皮层的启发，在从结构化网格数据（如图像）中提取特性的空间层次结构方面特殊有效。图像自然地被表现为多维阵列-通常是具有对应于高度、宽度和颜色通道的维度的3D张量（例如，赤色、绿色和蓝色）。这种结构化表现使图像成为CNN的抱负候选者，CNN利用卷积运算来有效地处置惩罚输入数据的局部地区。

尺寸为4x 4x 3的红绿蓝（RGB）图像的3D张量。
与将输入数据视为平面向量的传统神经网络不同，CNN通过应用在图像上滑动的过滤器（或内核）来保留数据中的空间关系。这些过滤器检测边沿、纹理和外形等模式，使CNN可以或许逐层构建越来越复杂的特性表现。这种捕获空间层次结构的独特本事使CNN非常适合涉及图像、视频和其他网格状结构的任务。
CNN在广泛的应用中已经变得不可或缺，包括：

• 图像分类：识别图像中的对象（例如，区分猫和狗）。
  
• 对象检测：定位和分类图像中的多个对象（例如，检测街道场景中的行人或车辆）。
  
• 语义分割：为图像中的每个像素添加标签，实现对场景的细粒度明白（例如，识别卫星图像中的门路、汽车、建筑物和植被）。
  

2、CNN架构的底子

要相识CNN的工作原理，深入研究其核心概念至关重要。下面，我们将探讨CNN架构的关键要素。
2.1、卷积层

CNN的主干是卷积层，它将过滤器（或内核）应用于输入数据以提取边沿，纹理和模式等特性。这些层负责检测输入中的局部模式并构建数据的分层表现。每个卷积层产生一个或多个特性图，突出表现输入的特定特性。

在数学上，卷积运算涉及在输入矩阵上滑动滤波器并盘算滤波器权重与输入的对应地区之间的点积。这个过程捕获空间关系，使网络可以或许学习故意义的特性。
2.2.2 卷积核（Kernel）：过滤器

核（或滤波器）是一个小的权重矩阵，它在输入数据上滑动以执行卷积运算。核的大小决定卷积的感受野，即，对每次盘算有贡献的输入的局部地区。常见的内核大小包括3×3、5×5或7×7。

对于给定的大小为H×W的输入矩阵I和大小为K×K的滤波器F，位置（i，j）处的输出特性图O盘算为：

每个过滤器检测特定类型的特性，例如程度边沿、垂直边沿或纹理。通过堆叠多个滤波器，卷积层可以并行捕获各种模式。
2.3：添补Padding

添补涉及在输入矩阵的界限周围添加额外的像素（通常为零）。添补可确保输出特性图保持与输入相同的空间维度，或防止边沿处的信息丢失。

有两种常见的添补类型：

• 有效添补：不应用添补，导致输出特性图较小。
  
• 相同的添补：添加添补以使输出特性图具有与输入相同的空间维度。
  

例如，如果您将3×3滤波器应用于具有“相同”添补的5×5输入，则输出仍为5×5。如果没有添补，输出大小将由于过滤器与边沿的重叠而缩小。
2.4：步幅Stride

步幅决定了在卷积运算期间滤波器在输入矩阵上移动的程度。步幅为1意味着过滤器一次移动一个像素，而较大的步幅跳过像素，减少输出特性图的空间维度。

在应用具有步幅S的卷积之后，用于盘算输出大小的公式为：

此中：

• H和W是输入的高度和宽度，
  
• K是卷积核大小，
  
• P是添补大小，
  
• S是步幅。
  

例如，步长为2时，过滤器会跳过每隔一个像素，从而有效地将输出特性图的空间维度减半。
2.5：多个过滤器和深度

每个卷积层可以有多个过滤器，每个过滤器检测不同的特性。输出特性图的深度对应于所应用的滤波器的数目。例如，如果您对输入图像应用32个过滤器，则输出将具有32个特性图。
2.6：权重共享

与全连接层不同，卷积层在所有空间位置上共享权重。这减少了参数的数目，并实现了有效的盘算。例如，如果将3×3滤波器应用于5×5输入，则在整个输入中重复使用相同的滤波器权重。
2.7：特性图创建

对输入应用过滤器的结果称为特性图。每个特性图突出表现输入数据中的特定模式或特性。例如，一个特性图可能检测程度边沿，而另一个检测垂直边沿。
让我们通过一个例子来巩固这些概念。思量一个5×5的输入图像和一个3×3的滤波器：
**示例1（无添补，步幅为1）：**输入大小：5×5，内核大小：3×3，步幅：1，添补：无
使用公式：输出大小= 15−3 +1 × 15−3 +1 =3×3
输出特性图的尺寸为3×3。
**示例2（相同添补，步幅为2）：**输入大小：5×5，内核大小：3×3，步幅：2，添补：相同
使用公式：输出大小= 25−3+2（1）+1 × 25−3+2（1）+1 =3×3
输出特性图将保留与输入相同的空间维度（5×5）。
**示例3（多个过滤器）：**假设我们将32个大小为3×3的过滤器应用于5×5的输入，没有添补，步幅为1。每个过滤器产生一个3×3的特性图。由于有32个过滤器，输出将由32个特性图组成，从而产生大小为32×3×3的张量。
通过相识这些基本组件-卷积层，内核，添补，步幅和权重共享-您可以深入相识CNN如何处置惩罚图像数据并提取故意义的特性。这些示例说明白每个参数如何影响输出，并展示了CNN在从结构化数据中捕获不同模式方面的机动性。
2.8、池化层

池层在减少特性映射的空间维度方面发挥着至关重要的作用，使模型的盘算服从更高，更不轻易过拟合。通过总结特性图的局部地区中的信息，池化有助于保留最重要的特性，同时抛弃不太相干的细节。这种降维也减少了后续层中的参数数目，加速了训练和推理。

有两种常见的池操作类型：

最大池化：最大池化从特性图的每个局部地区获取最大值。例如，如果我们使用一个2×2的窗口来应用最大池化，则位置（i，j）处的输出盘算为：

最大池化被广泛使用，因为它保留了每个地区中最突出的特性，例如边沿或纹理，这些特性通常是图像分类等任务中信息量最大的。
例如：思量一个4×4特性图：

应用步长为2的2×2最大池化会导致：

**平均池化：**平均池化盘算每个局部地区的平均值，而不是最大值。此操作平滑了特性图，并提供了输入的更全局的表现。平均池的公式为：

此中K是池化窗口的大小，S是步幅。
示例：使用与上述相同的4×4特性图，应用步长为2的2×2平均池化，结果为：

虽然最大池化夸大的是最显著的特性，但平均池化捕获了更广泛的输入摘要，使其在玄妙模式很重要的场景中非常有效。
2.9：全连接层

在CNN的结尾，全连接（FC）层联合收割机联合提取的特性进行猜测。这些层基于学习的表现执行分类或回归。在多个卷积层和池化层低落了空间维度并提取了高级特性之后，完全连接的层充当网络的决策组件。
完全连接的图层如何工作

全连接层中的每个神经元都连接到前一层中的每个神经元。全连接层的输出是使用线性变换和激活函数盘算的：

此中：

• W是权重矩阵，
  
• x是输入向量（平坦化特性图），
  
• B是偏置项。
  

结果通过激活函数（例如，ReLU、softmax）引入非线性并产生最终输出。
示例：具有128个神经元的全连接层

假设最后一个池化层的输出是一个4×4×64张量（高度= 4，宽度= 4，深度= 64）。在将其馈送到全连接层之前，张量被展平为大小为4×4×64=1024的一维向量。如果全连接层具有128个神经元，则权重矩阵W将具有128×1024的维度，而且偏置向量B将具有128个元素。
全连接层中第一个神经元的盘算如下：

对所有128个神经元重复该过程以产生输出向量。
分类中的作用

在分类任务中，最终的全连接层通常使用softmax激活函数来输出每个种别的概率。例如，在一个10类图像分类问题中，softmax层会天生10类的概率分布：

此中z_i是种别i的logit（原始分数）。
为什么全连接层很重要

全连接层集成了卷积层和池化层提取的分层特性，以明白数据。虽然卷积层专注于局部模式，但全连接层提供了全局视图，使网络可以或许做出明智的猜测。
通过相识池化和全连接层的工作原理，您可以全面相识CNN如何将原始像素数据转换为故意义的猜测。池化层低落了维度并夸大了关键特性，而全连接层联合收割机联合了这些特性来解决分类或回归等特定任务。它们共同构成了现代深度学习架构的支柱。
3：使用PyTorch构建CNN的分步指南

如今我们明白了CNN背后的理论，让我们来看看使用PyTorch构建CNN的过程。

3.1、设置情况

在深入研究代码之前，请确保您的开发情况已精确设置。安装须要的库：

1. # Install PyTorch (if not already installed)
2. !pip install torch torchvision matplotlib
4. # Import necessary libraries
5. import torch
6. import torch.nn as nn
7. import torch.optim as optim
8. from torchvision import datasets, transforms
9. import matplotlib.pyplot as plt

复制代码

3.2、准备数据

下一步是加载和预处置惩罚数据集。在这个例子中，我们将使用CIFAR-10数据集，它由10个类中的60，000个32 x32彩色图像组成，每个类6，000个图像。我们将像素值归一化为范围[-1，1]，并将数据分为训练集和测试集。

1. # Define data transformations
2. transform = transforms.Compose([
3.     transforms.ToTensor(),  # Convert images to PyTorch tensors
4.     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # Normalize pixel values to [-1, 1]
5. ])
7. # Load CIFAR-10 dataset
8. train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
9. test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
11. # Create data loaders for batching and shuffling
12. train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
13. test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)

复制代码

• transforms.ToTensor（）：将PIL图像或NumPy数组转换为PyTorch张量。
  
• Normalize（）：使用均值和标准差对张量进行归一化。这有助于在训练过程中更快地收敛。
  
• DataLoader：处置惩罚数据的重排序和混洗。
  

3.3构建CNN模型

如今，让我们定义CNN的架构。典型的CNN由卷积层、池化层和全连接层组成。下面是一个简朴的CNN架构的例子：

1. # Define the CNN Model
2. class CNN(nn.Module):
3.     def __init__(self):
4.         super(CNN, self).__init__()
5.         
6.         # Convolutional Layer 1: Input channels = 3 (RGB), Output channels = 32, Kernel size = 3x3
7.         self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1)
8.         
9.         # Max Pooling Layer: Reduces spatial dimensions by half
10.         self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
11.         
12.         # Convolutional Layer 2: Input channels = 32, Output channels = 64, Kernel size = 3x3
13.         self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
14.         
15.         # Fully Connected Layer 1: Input size = 64 * 8 * 8, Output size = 128
16.         self.fc1 = nn.Linear(64 * 8 * 8, 128)
17.         
18.         # Fully Connected Layer 2: Output size = 10 (for 10 classes)
19.         self.fc2 = nn.Linear(128, 10)
20.    
21.     def forward(self, x):
22.         # Apply first convolutional layer followed by ReLU activation and max pooling
23.         x = self.pool(torch.relu(self.conv1(x)))
24.         
25.         # Apply second convolutional layer followed by ReLU activation and max pooling
26.         x = self.pool(torch.relu(self.conv2(x)))
27.         
28.         # Flatten the tensor for the fully connected layer
29.         x = x.view(-1, 64 * 8 * 8)
30.         
31.         # Apply fully connected layer 1 with ReLU activation
32.         x = torch.relu(self.fc1(x))
33.         
34.         # Apply fully connected layer 2 (output layer)
35.         x = self.fc2(x)
36.         
37.         return x
39. # Instantiate the model
40. model = CNN()
41. print(model)

复制代码

• 卷积层（nn.Conv2d）：从输入图像中提取特性。
  
• Pooling Layers（nn.MaxPool2d）：减少特性映射的空间维度。
  
• 全连接层（nn.线性）：基于提取的特性执行分类。
  
• ReLU激活：在模型中引入非线性。
  

3.4、定义模型

在定义了模型架构之后，我们需要指定损失函数、优化器和评估指标。

1. # Define the loss function and optimizer
2. criterion = nn.CrossEntropyLoss()  # Cross-Entropy Loss for multi-class classification
3. optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam optimizer with learning rate 0.001

复制代码

• nn.CrossEntropyLoss（）：将nn.LogSoftmax（）和nn.NLLLoss（）组合在一个类中。它通常用于多类分类问题。
  
• optim.Adam（）：一种自适应学习率优化算法，广泛用于深度学习。
  

3.5、训练模型

如今，让我们使用训练数据训练模型，并评估其在测试集上的性能。我们还将在训练期间监测损失。

1. # Train the model
2. num_epochs = 10
4. for epoch in range(num_epochs):  # Loop over the dataset multiple times
5.     running_loss = 0.0
6.    
7.     for i, data in enumerate(train_loader, 0):
8.         inputs, labels = data
9.         
10.         # Zero the parameter gradients
11.         optimizer.zero_grad()
12.         
13.         # Forward pass
14.         outputs = model(inputs)
15.         loss = criterion(outputs, labels)
16.         
17.         # Backward pass and optimization
18.         loss.backward()
19.         optimizer.step()
20.         
21.         # Print statistics
22.         running_loss += loss.item()
23.         
24.         if i % 100 == 99:  # Print every 100 mini-batches
25.             print(f'Epoch {epoch + 1}, Batch {i + 1}, Loss: {running_loss / 100:.3f}')
26.             running_loss = 0.0
28. print('Finished Training')

复制代码

• Forward Pass：盘算给定输入数据的模型输出。
  
• 反向传递：盘算损失相对于模型参数的梯度。
  
• 优化步骤：使用盘算的梯度更新模型参数。
  

3.6、评估模型

最后，让我们在测试数据集上评估经过训练的模型，以衡量其正确性。

1. # Evaluate the model on the test set
2. correct = 0
3. total = 0
5. with torch.no_grad():  # Disable gradient computation for evaluation
6.     for data in test_loader:
7.         images, labels = data
8.         outputs = model(images)
9.         _, predicted = torch.max(outputs.data, 1)
10.         total += labels.size(0)
11.         correct += (predicted == labels).sum().item()
13. print(f'Accuracy of the model on the test set: {100 * correct / total:.2f}%')
15. # Accuracy of the model on the test set: 70.78%

复制代码

• max（）：返回指定维度沿着最大值的索引，该维度对应于猜测类。
  
• 正确度盘算：将猜测标签与真实标签进行比较，以盘算正确度。
  

3.7、可视化结果

您还可以可视化一些猜测，以更好地相识模型的性能。

1. import numpy as np
2. import matplotlib.pyplot as plt
3. import torchvision
5. # Function to unnormalize and display images
6. def imshow(img):
7.     img = img / 2 + 0.5  # Unnormalize
8.     npimg = img.numpy()
9.     plt.imshow(np.transpose(npimg, (1, 2, 0)))
10.     plt.show()
12. # Get some random test images
13. dataiter = iter(test_loader)
14. images, labels = next(dataiter)  # Use Python's built-in next() function
16. # Display images
17. imshow(torchvision.utils.make_grid(images))
19. # Predict the labels
20. outputs = model(images)
21. _, predicted = torch.max(outputs, 1)
23. print('Predicted:', ' '.join(f'{predicted[j]}' for j in range(4)))

复制代码

4、进步模型性能

虽然CNN功能强大，但可以使用先进技能进一步加强其性能。
4.1：数据加强

数据加强是一种通过对输入图像应用随机变换来人为增长训练数据集的大小和多样性的技能。这有助于模型更好地泛化，将其袒露给更广泛的数据，而不需要额外的标记示例。
以下是如何使用PyTorch实现数据加强：

1. # Define data augmentation transformations
2. transform = transforms.Compose([
3.     transforms.RandomHorizontalFlip(p=0.5),  # Randomly flip images horizontally
4.     transforms.RandomRotation(10),           # Randomly rotate images by up to 10 degrees
5.     transforms.RandomResizedCrop(32, scale=(0.8, 1.0)),  # Randomly crop and resize images
6.     transforms.ToTensor(),                   # Convert images to PyTorch tensors
7.     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # Normalize pixel values
8. ])
10. # Load CIFAR-10 dataset with augmented data
11. train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
12. train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)

复制代码

• RandomHorizontalFlip：以给定概率程度随机翻转图像（例如，50%）。
  
• 随机旋转：在指定范围内以随机角度旋转图像。
  
• RandomResizedCrop：随机裁剪和调整图像大小，引入比例和纵横比的可变性。
  

这些转换确保模型不会过度拟合训练数据的特定特性，使其对真实世界图像的变革更加鲁棒。
4.2：Dropout

Dropout是一种正则化技能，它随机地“抛弃”（即，使神经元失活）。这可以防止网络变得过于依赖特定的神经元，从而减少过度拟合并进步泛化本事。

1. class CNNWithDropout(nn.Module):
2.     def __init__(self):
3.         super(CNNWithDropout, self).__init__()
4.         
5.         # Convolutional layers
6.         self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1)
7.         self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
8.         self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
9.         
10.         # Fully connected layers
11.         self.fc1 = nn.Linear(64 * 8 * 8, 128)
12.         self.fc2 = nn.Linear(128, 10)
13.         
14.         # Dropout layer
15.         self.dropout = nn.Dropout(p=0.5)  # Dropout with 50% probability
16.    
17.     def forward(self, x):
18.         x = self.pool(torch.relu(self.conv1(x)))
19.         x = self.pool(torch.relu(self.conv2(x)))
20.         x = x.view(-1, 64 * 8 * 8)  # Flatten the tensor
21.         x = torch.relu(self.fc1(x))
22.         x = self.dropout(x)  # Apply dropout before the final layer
23.         x = self.fc2(x)
24.         return x
26. model = CNNWithDropout()

复制代码

• nn.Dropout（p=0.5）：在训练期间随机将50%的元素归零。删除层通常在完全连接的层之后应用。
  
• 有效性：Dropout有助于防止神经元的共同适应，确保网络学习更强大的特性。
  

4.3：批量标准化

批量规范化（BatchNorm）将输入转换为每个层，稳固和加速训练过程。它减少了内部协变量移位，这种移位发生在训练过程中输入层的分布发生变革时。
以下是如何将批量归一化集成到CNN中：

1. class CNNWithBatchNorm(nn.Module):
2.     def __init__(self):
3.         super(CNNWithBatchNorm, self).__init__()
4.         
5.         # Convolutional layers with batch normalization
6.         self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1)
7.         self.bn1 = nn.BatchNorm2d(32)  # BatchNorm after first convolutional layer
8.         self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
9.         self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
10.         self.bn2 = nn.BatchNorm2d(64)  # BatchNorm after second convolutional layer
11.         
12.         # Fully connected layers
13.         self.fc1 = nn.Linear(64 * 8 * 8, 128)
14.         self.fc2 = nn.Linear(128, 10)
15.    
16.     def forward(self, x):
17.         x = self.pool(torch.relu(self.bn1(self.conv1(x))))  # Apply BatchNorm after conv1
18.         x = self.pool(torch.relu(self.bn2(self.conv2(x))))  # Apply BatchNorm after conv2
19.         x = x.view(-1, 64 * 8 * 8)  # Flatten the tensor
20.         x = torch.relu(self.fc1(x))
21.         x = self.fc2(x)
22.         return x
24. model = CNNWithBatchNorm()

复制代码

• nn.BatchNorm2d（num_features）：将批量归一化转换为2D特性图。它跨批次维度规范化激活。
  
• 利益：批量归一化进步了训练稳固性，允许更高的学习率，并减少了对细致权重初始化的需求。
  

4.4、迁移学习

迁移学习利用预先训练的模型（如ResNet，VGG或Inception），这些模型已经在ImageNet等大型数据集上训练过。通过根据您的特定任务对这些模型进行微调，纵然数据有限，您也可以实现高性能。
下面是一个使用预训练的ResNet-18模型进行迁移学习的例子：

1. import torchvision.models as models
3. # Load a pre-trained ResNet-18 model
4. pretrained_model = models.resnet18(pretrained=True)
6. # Freeze all layers except the final fully connected layer
7. for param in pretrained_model.parameters():
8.     param.requires_grad = False
10. # Replace the final fully connected layer for our specific task (10 classes)
11. num_ftrs = pretrained_model.fc.in_features
12. pretrained_model.fc = nn.Linear(num_ftrs, 10)
14. # Move the model to GPU if available
15. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
16. pretrained_model = pretrained_model.to(device)
18. # Define loss function and optimizer
19. criterion = nn.CrossEntropyLoss()
20. optimizer = optim.Adam(pretrained_model.fc.parameters(), lr=0.001)

复制代码

• 冻结层： 通过冻结预先训练的层，我们可以防止它们在训练过程中被更新，从而使我们可以或许专注于微调最终层。
  
• 微调： 冻结后，我们将最终的全连接层替换为针对特定分类任务定制的新层。
  
• 优点： 迁移学习大大减少了所需的数据量和盘算资源，使其成为小型数据集的抱负选择。
  

结论

卷积神经网络是现代深度学习的基石，可以在图像识别、物体检测等方面实现突破。通过使用PyTorch相识它们的架构、数学和实际实现，您可以构建适合您特定需求的健壮模型。借助数据加强、抛弃和迁移学习等技能，您可以进一步加强其性能并应对复杂的实际挑战。

---

好了，这篇文章就介绍到这里，喜欢的小同伴感谢给点个赞和关注，更多精彩内容连续更新~~
关于本篇文章大家有任何发起或意见，接待在评论区留言交换！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。