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

---

文章目录

• 前言
• 一、代码
• 二、网络介绍
• • [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. 回归头设计)
• 四、输入输出规范
• 五、预测示例代码
• 六、可能改进方向
• • 1.注意力机制
  • 2.多尺度特征
  • 3.时序建模
  • 4.轻量化

---

前言

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

---

一、代码

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. 模型继承与初始化

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

功能

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

关键点

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

2. Stage 1：初始特征提取

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：空间下采样

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：深层特征提取

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. 特征聚合

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

输入：[B, 128, 16, 16]

操作：

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

输出尺寸：[B, 128, 1, 1]

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

6. 回归头（预测分支）

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. 前向传播

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

解析

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

三、关键设计分析

1. 残差块 (ResidualBlock)

作用

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

实现：

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]，回归值（如转向量）

五、预测示例代码

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.轻量化

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

---