改进系列（8）：基于UNet+CBAM+联合损失改进的水体分割

最新推荐文章于 2025-04-24 23:49:54 发布
最新推荐文章于 2025-04-24 23:49:54 发布
阅读量1.1k 收藏 14
点赞数 30
分类专栏： 改进系列 文章标签： 深度学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44886601/article/details/147387959
版权

目录

1. UNet

2. CBAM、联合损失

2.1 CBAM

2.2 联合损失

3. UNet+CBAM+联合损失

4. 水体分割

4.1准备工作

4.2 train 训练脚本

4.3 训练过程

4.4 训练生成的结果---->runs

4.5 推理

5. 项目下载

1. UNet

UNet是一种广泛应用于图像分割任务的卷积神经网络架构，由Olaf Ronneberger等人于2015年提出。

其核心设计采用独特的U形对称结构，主要由编码器（下采样）和解码器（上采样）两部分组成。

编码器通过连续卷积和池化操作逐步提取高层次特征并缩小空间维度，而解码器则通过转置卷积或插值操作逐步恢复空间细节。两者之间的跳跃连接（skip connections）将浅层定位信息与深层语义特征融合，有效解决了梯度消失问题并提升了小目标分割精度。

UNet的创新性在于其端到端的训练方式、对少量标注数据的高效利用能力，以及适应不同尺寸输入的灵活性。

该模型最初针对生物医学图像设计，现已成为语义分割领域的基准模型，广泛应用于医学影像分析（如肿瘤检测）、卫星图像解译、自动驾驶场景理解等任务。后续改进版本（如UNet++、3D UNet）通过引入嵌套跳跃连接或三维卷积进一步扩展了其应用场景。

2. CBAM、联合损失

2.1 CBAM

CBAM（Convolutional Block Attention Module）是一种轻量级的注意力模块，由Sanghyun Woo等人在2018年的论文《CBAM: Convolutional Block Attention Module for Channel and Spatial Attention》中提出。它通过结合​​通道注意力​​和​​空间注意力​​机制，帮助卷积神经网络（CNN）动态聚焦于图像中的重要区域和特征通道，从而提升模型性能。

​​CBAM的核心结构​​

CBAM包含两个串联的子模块：

  1. ​​通道注意力模块（Channel Attention Module）​​

    • ​​作用​​：学习不同通道的权重，突出重要的特征通道。

    • ​​实现步骤​​：

      1. 对输入特征图分别进行全局平均池化（GAP）和全局最大池化（GMP），得到两个1D向量。

      2. 通过共享的多层感知机（MLP）生成通道注意力权重。

      3. 将GAP和GMP的结果相加后通过Sigmoid激活，得到最终的通道注意力图。

    • ​​公式​​：
      Mc​(F)=σ(MLP(GAP(F))+MLP(GMP(F)))

  2. ​​空间注意力模块（Spatial Attention Module）​​

    • ​​作用​​：学习空间位置的权重，关注特征图中的关键区域。

    • ​​实现步骤​​：

      1. 沿通道维度对特征图进行平均池化和最大池化，得到两个2D特征图。

      2. 将两者拼接后通过卷积层压缩为单通道，再通过Sigmoid生成空间注意力图。

    • ​​公式​​：
      Ms​(F)=σ(f7×7([AvgPool(F);MaxPool(F)]))

​​CBAM的工作流程​​

  1. 输入特征图 F 先经过通道注意力模块，得到加权后的特征 F′=F⊗Mc​(F)。

  2. F′ 再经过空间注意力模块，得到最终输出 F′′=F′⊗Ms​(F′)。

​​特点与优势​​

  1. ​​轻量高效​​：仅增加少量计算开销，可嵌入任何CNN架构（如ResNet、MobileNet）。

  2. ​​即插即用​​：无需修改网络结构，直接插入卷积模块后。

  3. ​​双重注意力​​：同时优化通道和空间维度，比单一注意力（如SENet）更全面。

  4. ​​显著提升性能​​：在分类、检测、分割等任务中验证有效（如ImageNet top-1准确率提升1-2%）。

​​代码示例（PyTorch）​​

import torch
import torch.nn as nn

class ChannelAttention(nn.Module):
    def __init__(self, in_channels, reduction_ratio=16):
        super().__init__()
        self.gap = nn.AdaptiveAvgPool2d(1)
        self.gmp = nn.AdaptiveMaxPool2d(1)
        self.mlp = nn.Sequential(
            nn.Linear(in_channels, in_channels // reduction_ratio),
            nn.ReLU(),
            nn.Linear(in_channels // reduction_ratio, in_channels)
        )
    
    def forward(self, x):
        gap = self.mlp(self.gap(x).squeeze(-1).squeeze(-1))
        gmp = self.mlp(self.gmp(x).squeeze(-1).squeeze(-1))
        attention = torch.sigmoid(gap + gmp).unsqueeze(-1).unsqueeze(-1)
        return x * attention

class SpatialAttention(nn.Module):
    def __init__(self, kernel_size=7):
        super().__init__()
        self.conv = nn.Conv2d(2, 1, kernel_size, padding=kernel_size//2)
    
    def forward(self, x):
        avg = torch.mean(x, dim=1, keepdim=True)
        max = torch.max(x, dim=1, keepdim=True)[0]
        attention = torch.sigmoid(self.conv(torch.cat([avg, max], dim=1)))
        return x * attention

class CBAM(nn.Module):
    def __init__(self, in_channels):
        super().__init__()
        self.ca = ChannelAttention(in_channels)
        self.sa = SpatialAttention()
    
    def forward(self, x):
        x = self.ca(x)
        x = self.sa(x)
        return x

2.2 联合损失

​​联合损失（Joint Loss 或 Combined Loss）​​ 是深度学习中常用的策略，通过结合多个损失函数的优势，解决单一损失函数可能存在的局限性（如梯度不平衡、任务冲突等）。它在多任务学习、分类与回归联合任务、对抗训练等场景中尤为重要。

​​1. 联合损失的核心思想​​

  • ​​互补性​​：不同损失函数关注不同方面的优化（如分类误差和位置误差）。

  • ​​平衡权重​​：通过权重系数调节各损失的贡献，避免某一项主导梯度。

  • ​​端到端优化​​：统一优化多个目标，提升模型整体性能。

​​2. 常见联合损失组合​​

以下是几种典型的联合损失应用场景及公式：

​​(1) 分类 + 回归任务​​

​​场景​​：目标检测（如Faster R-CNN）、人脸关键点检测等。
​​组成​​：

  • ​​分类损失​​（如交叉熵损失）确保正确分类。

  • ​​回归损失​​（如Smooth L1损失）精确定位边界框或关键点。

​​公式​​：

Ltotal​=λcls​⋅Lcls​+λreg​⋅Lreg​

​​示例​​：

  • Faster R-CNN中，分类用交叉熵，回归用Smooth L1，权重通常为1:1。

​​(2) 分类 + 对比学习​​

​​场景​​：人脸识别、表征学习。
​​组成​​：

  • ​​Softmax交叉熵损失​​：区分不同类别。

  • ​​Triplet Loss 或 ArcFace​​：拉近同类样本，推开异类样本。

​​公式​​：

Ltotal​=LCE​+α⋅Ltriplet​

​​作用​​：提升特征的判别性和泛化能力。

​​(3) 生成对抗网络（GAN）​​

​​场景​​：图像生成、风格迁移。
​​组成​​：

  • ​​对抗损失​​（GAN Loss）：让生成器欺骗判别器。

  • ​​重构损失​​（L1/L2 Loss）：保证生成内容与真实数据的相似性。

​​公式​​：

Ltotal​=LGAN​+λ⋅LL1​

​​示例​​：

  • Pix2Pix中，联合对抗损失（BCE）和L1损失（λ=100）。

​​(4) 多任务学习（Multi-Task Learning）​​

​​场景​​：语义分割 + 深度估计、文本分类 + 情感分析。
​​组成​​：

  • 各任务独立损失加权求和，如交叉熵（分类） + 均方误差（回归）。

​​公式​​：

Ltotal​=i=1∑N​λi​⋅Li​

​​关键点​​：需动态调整权重（如GradNorm方法）。

​​3. 权重分配策略​​

联合损失的核心挑战是平衡不同损失的权重，常见方法包括：

  • ​​手动调参​​：通过实验固定权重（如λ1​=1.0,λ2​=0.5）。

  • ​​动态调整​​：

    • ​​Uncertainty Weighting​​（ICLR 2018）：根据任务不确定性自动调整。

    • ​​GradNorm​​：平衡各任务的梯度量级。

  • ​​损失归一化​​：对各损失进行标准化（如除以初始值或均值）。

​​4. 代码示例（PyTorch）​​

​​(1) 分类 + 回归联合损失​​

import torch
import torch.nn as nn

class JointLoss(nn.Module):
    def __init__(self, lambda_cls=1.0, lambda_reg=1.0):
        super().__init__()
        self.lambda_cls = lambda_cls
        self.lambda_reg = lambda_reg
        self.ce_loss = nn.CrossEntropyLoss()
        self.reg_loss = nn.SmoothL1Loss()

    def forward(self, cls_pred, reg_pred, cls_target, reg_target):
        loss_cls = self.ce_loss(cls_pred, cls_target)
        loss_reg = self.reg_loss(reg_pred, reg_target)
        return self.lambda_cls * loss_cls + self.lambda_reg * loss_reg

​​任务类型​​

​​联合损失组成​​

​​典型应用​​

目标检测

分类损失 + 回归损失

Faster R-CNN, YOLO

人脸识别

Softmax + Triplet Loss

FaceNet, ArcFace

图像生成

GAN Loss + L1/L2 Loss

Pix2Pix, CycleGAN

语义分割

交叉熵 + Dice Loss

U-Net, DeepLab

多任务学习

加权各任务损失

NLP联合模型（如BERT）

3. UNet+CBAM+联合损失

实现思路是，在最后的输出层前加入inception模块

网络结构如下：

CBAM_UNet(
  (in_conv): DoubleConv(
    (double_conv): Sequential(
      (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
  )
  (down1): Down(
    (downsampling): Sequential(
      (0): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
      (1): DoubleConv(
        (double_conv): Sequential(
          (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
          (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU(inplace=True)
          (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
          (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (5): ReLU(inplace=True)
        )
      )
    )
  )
  (down2): Down(
    (downsampling): Sequential(
      (0): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
      (1): DoubleConv(
        (double_conv): Sequential(
          (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
          (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU(inplace=True)
          (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
          (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (5): ReLU(inplace=True)
        )
      )
    )
  )
  (down3): Down(
    (downsampling): Sequential(
      (0): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
      (1): DoubleConv(
        (double_conv): Sequential(
          (0): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
          (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU(inplace=True)
          (3): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
          (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (5): ReLU(inplace=True)
        )
      )
    )
  )
  (down4): Down(
    (downsampling): Sequential(
      (0): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
      (1): DoubleConv(
        (double_conv): Sequential(
          (0): Conv2d(512, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
          (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU(inplace=True)
          (3): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
          (4): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (5): ReLU(inplace=True)
        )
      )
    )
  )
  (up1): Up(
    (upsampling): ConvTranspose2d(1024, 512, kernel_size=(2, 2), stride=(2, 2))
    (conv): DoubleConv(
      (double_conv): Sequential(
        (0): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
      )
    )
  )
  (up2): Up(
    (upsampling): ConvTranspose2d(512, 256, kernel_size=(2, 2), stride=(2, 2))
    (conv): DoubleConv(
      (double_conv): Sequential(
        (0): Conv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
      )
    )
  )
  (up3): Up(
    (upsampling): ConvTranspose2d(256, 128, kernel_size=(2, 2), stride=(2, 2))
    (conv): DoubleConv(
      (double_conv): Sequential(
        (0): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
      )
    )
  )
  (up4): Up(
    (upsampling): ConvTranspose2d(128, 64, kernel_size=(2, 2), stride=(2, 2))
    (conv): DoubleConv(
      (double_conv): Sequential(
        (0): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (5): ReLU(inplace=True)
      )
    )
  )
  (cbam): CBAM(
    (ca): ChannelAttention(
      (avg_pool): AdaptiveAvgPool2d(output_size=1)
      (max_pool): AdaptiveMaxPool2d(output_size=1)
      (fc1): Conv2d(64, 4, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (relu1): ReLU()
      (fc2): Conv2d(4, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (sigmoid): Sigmoid()
    )
    (sa): SpatialAttention(
      (conv1): Conv2d(2, 1, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), bias=False)
      (sigmoid): Sigmoid()
    )
  )
  (out_conv): OutConv(
    (conv): Conv2d(64, 3, kernel_size=(1, 1), stride=(1, 1))
  )
)

联合损失采用交叉熵+dice loss：


class DiceLoss(nn.Module):
    """多分类Dice Loss（按类别计算后取平均）"""

    def __init__(self, smooth=1e-6):
        super(DiceLoss, self).__init__()
        self.smooth = smooth

    def forward(self, pred, target):
        # pred: [B, C, H, W] (未归一化，需先Softmax)
        # target: [B, H, W] (值为0,1,2)
        pred = F.softmax(pred, dim=1)
        num_classes = pred.shape[1]
        dice_loss = 0.0

        # 将target转为one-hot编码 [B, C, H, W]
        target_onehot = F.one_hot(target, num_classes).permute(0, 3, 1, 2).float()

        for c in range(num_classes):
            pred_c = pred[:, c, :, :]
            target_c = target_onehot[:, c, :, :]
            intersection = (pred_c * target_c).sum()
            union = pred_c.sum() + target_c.sum()
            dice_loss += 1 - (2. * intersection + self.smooth) / (union + self.smooth)

        return dice_loss / num_classes  # 平均各类别Dice Loss


class JointLoss(nn.Module):

    def __init__(self, lambda_dice=0.5, lambda_ce=0.5):
        super(JointLoss, self).__init__()
        self.dice = DiceLoss()
        self.ce = nn.CrossEntropyLoss()  # 自动处理Softmax
        self.lambda_dice = lambda_dice
        self.lambda_ce = lambda_ce

    def forward(self, pred, target):
        # pred: [B, C, H, W] (原始logits)
        # target: [B, H, W] (值为0,1,2)
        dice_loss = self.dice(pred, target)
        ce_loss = self.ce(pred, target)
        return self.lambda_dice * dice_loss + self.lambda_ce * ce_loss

4. 水体分割

数据集采用水体分割，标签如下

对黄色和绿色两种水体进行分割 

项目目录结构：

分别为数据、训练的结果、代码三部分

4.1准备工作

本人项目运行的环境为：python版本为3.10

einops==0.8.0
matplotlib==3.9.3
numpy==2.2.0
opencv_python==4.9.0.80
opencv_python_headless==4.10.0.84
Pillow==11.0.0
torch==2.0.1+cu118
tqdm==4.66.4


训练的时候，摆放好数据如下即可：

4.2 train 训练脚本


训练参数如下：

  • 如果数据集是CT格式的话，将ct参数设置为True在加载数据的时候会运用windowing方法自动增强数据
  • results 是返回的结果，这里默认保存在runs目录下
  • 如果有测试集的话，按照train和val摆放好，设置为True，会自动进行测试

--data--train---images   训练集的图像
--data--train---masks    训练集的图像标签
--data--val---images     验证集的图像
--data--val---masks      验证集的图像标签
--data--test---images    测试集的图像（如果有的话）
--data--test---masks     测试集的图像标签

    parser.add_argument("--ct", default=False,type=bool,help='is CT?')    # Ct --> True
    parser.add_argument("--model", default='unet',help='unet')

    parser.add_argument("--base-size",default=(224,224),type=tuple)         # 根据图像大小更改

    parser.add_argument("--batch-size", default=8, type=int)
    parser.add_argument("--epochs", default=50, type=int)

    parser.add_argument('--lr', default=0.0001, type=float)
    parser.add_argument('--lrf',default=0.001,type=float)                  # 最终学习率 = lr * lrf

    parser.add_argument("--img_f", default='.jpg', type=str)               # 数据图像的后缀
    parser.add_argument("--mask_f", default='_mask.png', type=str)              # mask图像的后缀

    parser.add_argument("--results", default='runs', type=str)                  # 保存目录
    parser.add_argument("--data-train", default='./data/train/images', type=str)
    parser.add_argument("--data-val", default='./data/val/images', type=str)
    parser.add_argument("--data-test", default=False, type=bool,help='if exists test sets')

4.3 训练过程

这里简单训练了500轮，可以自行训练：

    "train parameters": {
        "model": "unet",
        "input size": [
            224,
            224
        ],
        "batch size": 4,
        "lr": 0.0001,
        "lrf": 0.001,
        "ct": false,
        "epochs": 500,
        "num classes": 3
    },
    "Parameter:": 31038373.0,
    "FLOPs:": 41923152960.0,
    "Inference time:": 0.042989253997802734,

 

4.4 训练生成的结果---->runs

这里训练的结果保存在runs下，自行查看即可，这里只做简单展示

所有的结果都在json文件里，曲线啥的都是根据该文件生成

最好的一轮指标：

    "epoch:499": {
        "train log:": {
            "info": {
                "pixel accuracy": [
                    0.8883134722709656
                ],
                "Precision": [
                    "0.8361",
                    "0.8701"
                ],
                "Recall": [
                    "0.8971",
                    "0.8732"
                ],
                "F1 score": [
                    "0.8655",
                    "0.8716"
                ],
                "Dice": [
                    "0.8655",
                    "0.8716"
                ],
                "IoU": [
                    "0.7629",
                    "0.7724"
                ],
                "mean precision": 0.8530791997909546,
                "mean recall": 0.8851511478424072,
                "mean f1 score": 0.8685768842697144,
                "mean dice": 0.8685768842697144,
                "mean iou": 0.7676980495452881
            }
        },
        "val log:": {
            "info": {
                "pixel accuracy": [
                    0.8461740612983704
                ],
                "Precision": [
                    "0.7993",
                    "0.8683"
                ],
                "Recall": [
                    "0.9044",
                    "0.8151"
                ],
                "F1 score": [
                    "0.8486",
                    "0.8409"
                ],
                "Dice": [
                    "0.8486",
                    "0.8409"
                ],
                "IoU": [
                    "0.7371",
                    "0.7254"
                ],
                "mean precision": 0.8338322639465332,
                "mean recall": 0.8597488403320312,
                "mean f1 score": 0.8447480201721191,
                "mean dice": 0.8447479605674744,
                "mean iou": 0.7312436699867249
            }

loss+iou+dice曲线：

各类的指标曲线：截图工具截取的可能有点模糊

4.5 推理

推理的时候，直接运行infer_ui即可：

5. 项目下载

关于更多的ai改进：AI 改进系列_听风吹等浪起的博客-CSDN博客

本文的项目下载：

Unet+CBAM+联合损失改进：遥感水体图像分割数据集（3类图像分割任务）资源-CSDN文库

YOLOv8改进：利用UNetV2主干网络提升图像分割检测性能
走向CTO的路上...
08-11 1647
YOLOv8模型作为目前最先进的目标检测算法之一，在精度和速度方面取得了显著进步。然而，YOLOv8模型的图像分割性能仍有提升空间。本文介绍了一种利用UNetV2图像分割网络作为主干网络来改进YOLOv8模型的图像分割检测性能的方法，该方法可以有效提升YOLOv8模型的分割精度和语义分割能力。利用UNetV2图像分割网络作为YOLOv8模型的主干网络，可以有效提升YOLOv8模型的图像分割性能，并拓展其在医学图像分析、遥感图像分析。
Unet++改进2：添加CBAM注意力机制
AIcurator的博客
11-07 545
摘要。我们提出了卷积块注意模块(CBAM)，这是一种简单而有效的前馈卷积神经网络注意模块。给定一个中间特征映射，我们的模块沿着两个独立的维度依次推断注意力映射，通道和空间，然后将注意力映射乘以输入特征映射以进行自适应特征细化。因为CBAM是一个轻量级的通用模块，它可以无缝地集成到任何CNN架构中，开销可以忽略不计，并且可以与基础CNN一起进行端到端训练。我们通过在ImageNet-1K、MS COCO检测和VOC 2007检测数据集上进行大量实验来验证我们的CBAM。
2020 CCF BDCI 地块分割Top1方案 & 语义分割trick整理
我爱计算机视觉
01-26 1448
本文转载自知乎，已获作者授权转载。链接：https://zhuanlan.zhihu.com/p/346862877赛题分析赛题分析这次比赛也是第一次正式参加的比赛，地块分割本质上也是个...
2020 CCF BDCI 遥感影像地块分割冠军竞赛方案 & 语义分割trick整理
3D视觉工坊
02-01 3966
点击上方“3D视觉工坊”，选择“星标”干货第一时间送达作者丨Sakura.D@知乎（已授权）来源丨https://zhuanlan.zhihu.com/p/346862877编辑丨极市平...
第29周：文献阅读
benbenxinchen的博客
01-18 825
该文献提出的LEFormer模型是一个混合CNN-Transformer架构，专门用于从遥感图像中准确提取湖泊。其结构包括CNN编码器以恢复局部空间信息、Transformer编码器以捕获长距离依赖、交叉编码器融合模块以整合局部和全局特征，以及一个轻量级解码器用于掩码预测。模型的特点在于结合了CNN对细节的敏感性和Transformer对上下文的捕获能力，优势在于实现了高精度和低计算成本。它应用于湖泊提取领域，因为该领域需要精确的边界和前景建模，而现有方法存在局限性。
Unet +CBAM+联合损失改进：遥感水体图像分割数据集（3类图像分割任务）
04-21
代码实现了一个基于UNet架构的医学图像分割系统，支持标准UNet模型，能够自动处理CT等医学影像数据的分割任务。 系统采用PyTorch框架构建，包含完整的数据加载、模型训练、评估和可视化功能，使用交叉熵损失函数和...
Unet++舌象图像分割数据集+代码+模型+系统界面+教学视频.zip
03-10
UNet++，它是一种深度监督的编码器-解码器网络，通过一系列嵌套的密集跳跃连接将编码器和解码器子网连接起来。UNet++的设计目标是减少编码器和解码器子网特征图之间的语义差距，使得优化器在面对语义相似的特征图时...
"语义分割图像处理：Unet、Unet++、Swin UNet等变体模型的优化与改进及PaddleSeg算法开发落地",语义分割图像分割Unet Unet++ swin unet transforme
01-31
"语义分割图像处理：Unet、Unet++、Swin UNet等变体模型的优化与改进及PaddleSeg算法开发落地",语义分割图像分割Unet Unet++ swin unet transformer 等变体模型网络 语义分割模型改进，语义分割模型优化 Unet Unet++...
遥感图像分割：UNet++嵌套密集连接结构在土地覆盖分类任务中的性能对比.pdf
02-21
UNet++作为一种改进型的编码器-解码器结构，其嵌套密集连接的设计使得它在遥感图像的土地覆盖分类任务中表现出色。UNet模型具有编码器和解码器部分，通过逐层的卷积和池化操作，编码器部分能够提取高级特征并缩减...
基于深度学习Yolo8的驾驶员疲劳与分心行为检测系统
XiaoCoder的博客
04-23 210
③：技术栈：Python、PySide6、OpenCV、YOLOv8、Matplotlib、NumPy。②：开发环境：Python3.8+、PyCharm/VSCode。①：疲劳检测：眨眼频率监测、哈欠检测、Perclos模型评分。②：分心行为识别：手机使用检测、抽烟行为检测、喝水行为检测。④：数据统计：行为数据可视化、疲劳指标统计、数据导出功能。①：系统环境：Windows/Mac/Linux。③：实时监控：摄像头实时画面显示、状态实时更新。【三】疲劳检测模型与行为分析统计。
2025-04-22 李沐深度学习5 —— 线性回归
zheliku的博客
04-22 1232
​ 在美国买房时，买家需根据房屋信息（如卧室数量、卫生间数量、面积等）预测合理的成交价。输入数据：房屋特征（如X1=卧室数X2=卫生间数X3=面积输出目标：预测成交价Y。实际挑战：卖家的标价和网站估价（如Redfin）仅为参考，最终需通过竞价决定成交价，因此准确预测至关重要。​ 计算输入特征X\mathbf{X}X和模型权重w\mathbf{w}w的矩阵-向量乘法后加上偏置bbb。​ 注意，上面的XwXw是一个向量，而bbb是一个标量。
RNN的理解
olssa的博客
04-20 904
注：生成的 W_xh 会是一个形状为 (4, 3) 的张量，可能是这样的（数字是随机生成的）：这个张量有 4 行 3 列。注：x 是输入数据，形状是 (3, 5, 4)，其中：3 是批量大小（batch_size），即我们一次性输入网络的样本数是 3。5 是序列长度（seq_len），每个样本有 5 个时间步。4 是每个时间步的输入特征数量。self.hidden_size 假设是 6，表示隐藏层的维度是 6。
卷积神经网络综述
XU157303764的博客
04-20 1907
本文对卷积神经网络（Convolutional Neural Network，CNN）进行了全面综述。首先介绍了卷积神经网络的发展历程，包括早期的理论基础和关键突破。接着详细阐述了卷积神经网络的结构组成，包括卷积层、池化层、全连接层等，分析了各层的作用和特点。然后探讨了卷积神经网络在图像识别、目标检测、语义分割等多个领域的应用，并介绍了一些典型的应用案例。此外，还讨论了卷积神经网络的训练方法和优化技巧，包括数据增强、正则化、超参数调整等。最后，对卷积神经网络的未来发展趋势进行了展望。
深度学习视觉应用平台特色功能介绍
tipdm0301的博客
04-22 529
深度学习视觉应用平台是面向高校人工智能相关专业课程教学的工具。平台内置丰富有趣的视觉应用案例，将深度学习算法与视觉应用结合，实现图像分类、图像生成、图像增强等交互式实验场景，形象展示算法原理和结构。
深度学习预训练和微调
weixin_56054625的博客
04-21 696
预训练：在大数据集上学通用特征。微调：在小数据集上调整模型以适应新任务。意义：提升小数据性能、节省资源、避免过拟合。
深度学习-全连接神经网络-2
precious_35的博客
04-21 1004
在使用Torch构建网络模型时，每个网络层的参数都有默认的初始化方法，同时还可以通过以上方法来对网络参数进行初始化。当输出层使用softmax多分类时，使用交叉熵损失函数；当输出层使用sigmoid二分类时，使用二分类交叉熵损失函数， 比如在逻辑回归中使用；当功能为线性回归时，使用均方差损失-L2 loss；梯度下降算法通过不断更新参数来最小化损失函数，是反向传播算法中计算权重调整的基础。
目标检测：视觉系统中的CNN-Transformer融合网络
Hello大家好，我是Dream，如果帮得到你，那我深感荣幸！想进粉丝福利群及免费送书群，直接私信我拉你。交流学习、商务合作：https://bbs.csdn.net/topics/614347534
04-21 1378
RTD-Net是一个单阶段检测网络，它直接从输入图像预测目标的位置和类别，然后通过非最大抑制（NMS）处理来获取最终检测结果。网络设计考虑了检测精度和速度的平衡，特别适用于资源受限的嵌入式设备。
NLP高频面试题（五十三）——深度学习正则化详解
最新发布
WeLearnNLP
04-24 166
R1w∑i∣wi∣R1​wi∑​∣wi​∣.它会在优化过程中倾向于将许多权重压缩为零，实现稀疏化（sparsity）。稀疏模型不仅在存储和推理时更高效，也能自动完成特征选择，因为被置零的参数对应的输入特征被认为不重要。R2w∑iwi2R2​wi∑​wi2​它会使得权重均匀收缩，但很少将其精确推到零。相比 L1，L2 更强调平滑性（smoothness），防止任意一个权重过大，从而降低模型对某一维特征的过度依赖。
问题 | RAIM + LSTM 你怎么看？？？
尘世冰封的专栏
04-21 273
RAIM与LSTM结合完成完好性故障监测
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

听风吹等浪起

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值