深度学习篇---卷积网络结构

文章目录

前言
一、代码
二、网络介绍
- [1. 模型继承与初始化](#1. 模型继承与初始化)
- - 功能
  - 关键点
- [2. Stage 1：初始特征提取](#2. Stage 1：初始特征提取)
- - 解析
- [3. Stage 2：空间下采样](#3. Stage 2：空间下采样)
- - 解析
- [4. Stage 3：深层特征提取](#4. Stage 3：深层特征提取)
- - 解析
- [5. 特征聚合](#5. 特征聚合)
- [6. 回归头（预测分支）](#6. 回归头（预测分支）)
- [7. 前向传播](#7. 前向传播)
- - 解析
三、关键设计分析
- [1. 残差块 (ResidualBlock)](#1. 残差块 (ResidualBlock))
- [2. 特征聚合设计](#2. 特征聚合设计)
- [3. 回归头设计](#3. 回归头设计)
四、输入输出规范
五、预测示例代码
六、可能改进方向

前言

本文简单介绍了CNN卷积神经网络与残差块实现回归任务的代码以及接下来的优化方案。

一、代码

python 复制代码

class EnhancedCnnModel(nn.Layer):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            # Stage 1 (128x128 -> 64x64)
            nn.Conv2D(3, 32, 5, stride=2, padding=2),
            nn.BatchNorm2D(32),
            nn.LeakyReLU(0.2),
            ResidualBlock(32, 32, 3, 1),
            
            # Stage 2 (64x64 -> 32x32)
            nn.Conv2D(32, 64, 5, stride=2, padding=2),
            nn.BatchNorm2D(64),
            nn.LeakyReLU(0.2),
            ResidualBlock(64, 64, 3, 1),
            
            # Stage 3 (32x32 -> 16x16)
            nn.Conv2D(64, 128, 3, stride=2, padding=1),
            nn.BatchNorm2D(128),
            nn.LeakyReLU(0.2),
            ResidualBlock(128, 128, 3, 1),
            
            # Feature Aggregation
            nn.AdaptiveAvgPool2D(1),
            nn.Flatten(),
            
            # Regression Head
            nn.Linear(128, 64),
            nn.LayerNorm(64),
            nn.LeakyReLU(0.2),
            nn.Dropout(0.3),
            
            nn.Linear(64, 1)
        )

    def forward(self, x):
        return self.features(x)

二、网络介绍

1. 模型继承与初始化

python 复制代码

class EnhancedCnnModel(nn.Layer):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(...)

功能

功能：定义继承自 nn.Layer 的模型类，使用 nn.Sequential 容器按顺序堆叠各层。

关键点

关键点：super().init() 确保正确初始化父类。

2. Stage 1：初始特征提取

python 复制代码

nn.Conv2D(3, 32, 5, stride=2, padding=2),
nn.BatchNorm2D(32),
nn.LeakyReLU(0.2),
ResidualBlock(32, 32, 3, 1)

解析

输入： $B, 3, 128, 128$ （B为Batch Size）

操作：

卷积层：5x5卷积核，32个输出通道，stride=2，padding=2。

输出尺寸：(128-5+2*2)/2 +1 = 64 → $B, 32, 64, 64$

批归一化：加速训练，稳定梯度。

LeakyReLU：负区间斜率0.2，缓解神经元死亡。

残差块：保持输入输出维度一致（32通道，3x3卷积，stride=1）。

3. Stage 2：空间下采样

python 复制代码

nn.Conv2D(32, 64, 5, stride=2, padding=2),
nn.BatchNorm2D(64),
nn.LeakyReLU(0.2),
ResidualBlock(64, 64, 3, 1)

解析

输入： $B, 32, 64, 64$

操作：

卷积层：5x5卷积核，64通道，stride=2，padding=2。

输出尺寸：(64-5+4)/2 +1 = 32 → $B, 64, 32, 32$

批归一化 & 激活：同上。

残差块：维持64通道，无尺寸变化。

4. Stage 3：深层特征提取

python 复制代码

nn.Conv2D(64, 128, 3, stride=2, padding=1),
nn.BatchNorm2D(128),
nn.LeakyReLU(0.2),
ResidualBlock(128, 128, 3, 1)

解析

输入： $B, 64, 32, 32$

操作：

卷积层：3x3卷积核，128通道，stride=2，padding=1。

输出尺寸：(32-3+2)/2 +1 = 16 → $B, 128, 16, 16$

批归一化 & 激活：同上。

残差块：维持128通道，无尺寸变化。

5. 特征聚合

python 复制代码

nn.AdaptiveAvgPool2D(1),
nn.Flatten()

输入： $B, 128, 16, 16$

操作：

自适应平均池化：将每个通道的特征图压缩为1x1。

输出尺寸： $B, 128, 1, 1$

展平：转换为向量 → $B, 128$

6. 回归头（预测分支）

python 复制代码

nn.Linear(128, 64),
nn.LayerNorm(64),
nn.LeakyReLU(0.2),
nn.Dropout(0.3),
nn.Linear(64, 1)

操作：

全连接层：128 → 64维。

层归一化：稳定特征分布。

LeakyReLU：保持非线性。

Dropout：30%概率丢弃神经元，防止过拟合。

输出层：64 → 1维，直接输出回归值。

7. 前向传播

python 复制代码

def forward(self, x):
    return self.features(x)

解析

流程：输入依次通过所有层，输出最终预测值。

三、关键设计分析

1. 残差块 (ResidualBlock)

作用

作用：缓解梯度消失，允许训练更深网络。

实现：

python 复制代码

class ResidualBlock(nn.Layer):
    def __init__(self, in_channels, out_channels, kernel_size, stride):
        super().__init__()
        # 主分支
        self.conv1 = nn.Conv2D(in_channels, out_channels, kernel_size, stride, padding=kernel_size//2)
        self.bn1 = nn.BatchNorm2D(out_channels)
        self.relu = nn.LeakyReLU(0.2)
        self.conv2 = nn.Conv2D(out_channels, out_channels, kernel_size, 1, padding=kernel_size//2)
        self.bn2 = nn.BatchNorm2D(out_channels)
        
        # 捷径分支
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2D(in_channels, out_channels, 1, stride),
                nn.BatchNorm2D(out_channels)
            )

    def forward(self, x):
        identity = self.shortcut(x)
        out = self.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += identity
        return self.relu(out)

关键点：

当输入输出通道数或步长不一致时，使用1x1卷积调整维度。

跳跃连接后再次激活，增强非线性。

2. 特征聚合设计

AdaptiveAvgPool2D：将任意尺寸特征图统一为1x1，避免全连接层输入尺寸固定。

优势：支持可变输入尺寸（如不同分辨率图像）。

3. 回归头设计

层归一化：对小批量数据更鲁棒。

Dropout：减少全连接层的过拟合 风险。
输出层无激活 ：直接输出任意范围的值，适合回归任务。

四、输入输出规范

项目说明

输入 $B, 3, H, W$ ，建议H=W=128

数据类型 float32，像素值归一化到 $0,1$

输出 $B, 1$ ，回归值（如转向量）

五、预测示例代码

python 复制代码

import paddle
import cv2
import numpy as np

class LanePredictor:
    def __init__(self, model_path):
        self.model = EnhancedCnnModel()
        self.model.eval()
        state_dict = paddle.load(model_path)
        self.model.set_state_dict(state_dict)
        
        self.transform = paddle.vision.transforms.Compose([
            paddle.vision.transforms.Resize((128, 128)),
            paddle.vision.transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
        ])

    def preprocess(self, image):
        """处理单张OpenCV BGR图像"""
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        image = image.astype('float32') / 255.0
        image = self.transform(image).transpose((2, 0, 1))  # HWC → CHW
        return paddle.to_tensor(image[np.newaxis, ...])     # 增加Batch维度

    def predict(self, image):
        tensor = self.preprocess(image)
        with paddle.no_grad():
            output = self.model(tensor)
        return output.numpy()[0][0]  # 返回标量预测值

# 使用示例
predictor = LanePredictor("model.pdparams")
image = cv2.imread("test.jpg")
prediction = predictor.predict(image)
print("Predicted control value:", prediction)

六、可能改进方向

1.注意力机制

注意力机制：在残差块后加入SE模块，增强通道特征选择。

2.多尺度特征

多尺度特征：使用FPN结构融合不同层次特征。

3.时序建模

时序建模：添加LSTM处理连续帧，提升循迹稳定性。

4.轻量化

轻量化：替换深度可分离卷积，减少计算量。