【Block总结】DBlock，结合膨胀空间注意模块（Di-SpAM）和频域模块Gated-FFN|即插即用|CVPR2025

news2025/6/7 15:32:04

论文信息

标题: DarkIR: Robust Low-Light Image Restoration
作者: Daniel Feijoo, Juan C. Benito, Alvaro Garcia, Marcos Conde
论文链接：https://arxiv.org/pdf/2412.13443
GitHub链接：https://github.com/cidautai/DarkIR
在这里插入图片描述

创新点

DarkIR提出了一种新的卷积神经网络（CNN）框架，旨在同时处理低光图像增强和去模糊任务。与现有方法通常分开处理这两项任务不同，DarkIR通过多任务学习的方式，利用图像退化之间的相关性来提高恢复效果。该模型在参数和计算量上均优于之前的方法，且在多个标准数据集（如LOLBlur、LOLv2和Real-LOLBlur）上取得了新的最先进结果。
在这里插入图片描述

方法

DarkIR的架构采用了编码器-解码器设计，主要包括以下几个部分：

  1. 编码器块（EBlock）: 主要在频域中改善低光条件，使用快速傅里叶变换（FFT）增强输入图像的幅度。 通过空间注意模块（SpAM）增强特征提取，确保网络能够关注重要的空间信息。
  2. 解码器块（DBlock）: 负责上采样编码器的低分辨率输出并减少模糊。 实现了膨胀空间注意模块（Di-SpAM），通过不同膨胀率的深度卷积捕捉多种感受野的特征。该方法结合了频域技术和创新的注意力机制，优化了低光图像的恢复过程。
    在这里插入图片描述

DBlock模块详解

**DBlock（解码器块）**是DarkIR模型中的重要组成部分，主要负责从编码器传递的特征中恢复高分辨率的清晰图像。其设计旨在有效地处理低光照条件下的图像模糊问题，具体实现如下：

1. 结构组成

DBlock的主要组成部分包括：

  • 深度卷积（Dilated Convolution）: DBlock利用多种膨胀因子的深度卷积来增大感受野，从而更好地捕捉图像中的细节和上下文信息。
  • 空间注意力模块（SCA）: 该模块用于增强特征的空间表示，确保网络能够关注到图像中的重要区域。
  • 门控机制（SimpleGate）: 通过门控机制对特征进行加权，进一步提升解码效果。

2. 工作原理
DBlock的工作流程如下：

  • 输入处理: DBlock接收来自编码器的特征图，并进行Layer Normalization以提高训练的稳定性。
  • 特征融合: 通过多个分支的深度卷积，DBlock能够在不同的膨胀率下捕捉多尺度的空间信息。各分支的输出通过门控机制进行融合，以增强特征的表达能力。
  • 上采样:DBlock执行上采样操作，将低分辨率特征图转换为高分辨率图像。通过1x1卷积层恢复到原始通道数，并与输入进行残差连接，以保持信息的完整性。

DBlock通过结合多种膨胀卷积和空间注意力机制，显著提高了低光照条件下图像的清晰度和细节恢复能力。其设计不仅提升了图像的质量，还有效减少了模糊，使得DarkIR在多个标准数据集上表现出色，达到了新的最先进结果。
在这里插入图片描述

效果

DarkIR在真实世界的夜间和暗光图像中表现出色，能够有效地减少噪声和模糊，同时保持高保真度。其在多个数据集上的表现超越了现有的最先进技术，展示了其在计算摄影、智能手机等资源受限设备上的应用潜力。
在这里插入图片描述

完整代码



import torch
import torch.nn as nn



class LayerNormFunction(torch.autograd.Function):
    @staticmethod
    def forward(ctx, x, weight, bias, eps):
        ctx.eps = eps
        N, C, H, W = x.size()
        mu = x.mean(1, keepdim=True)
        var = (x - mu).pow(2).mean(1, keepdim=True)
        y = (x - mu) / (var + eps).sqrt()
        ctx.save_for_backward(y, var, weight)
        y = weight.view(1, C, 1, 1) * y + bias.view(1, C, 1, 1)
        return y

    @staticmethod
    def backward(ctx, grad_output):
        eps = ctx.eps

        N, C, H, W = grad_output.size()
        y, var, weight = ctx.saved_variables
        g = grad_output * weight.view(1, C, 1, 1)
        mean_g = g.mean(dim=1, keepdim=True)

        mean_gy = (g * y).mean(dim=1, keepdim=True)
        gx = 1. / torch.sqrt(var + eps) * (g - y * mean_gy - mean_g)
        return gx, (grad_output * y).sum(dim=3).sum(dim=2).sum(dim=0), grad_output.sum(dim=3).sum(dim=2).sum(
            dim=0), None

class LayerNorm2d(nn.Module):

    def __init__(self, channels, eps=1e-6):
        super(LayerNorm2d, self).__init__()
        self.register_parameter('weight', nn.Parameter(torch.ones(channels)))
        self.register_parameter('bias', nn.Parameter(torch.zeros(channels)))
        self.eps = eps

    def forward(self, x):
        return LayerNormFunction.apply(x, self.weight, self.bias, self.eps)


class SimpleGate(nn.Module):
    def forward(self, x):
        x1, x2 = x.chunk(2, dim=1)
        return x1 * x2


class Adapter(nn.Module):

    def __init__(self, c, ffn_channel=None):
        super().__init__()
        if ffn_channel:
            ffn_channel = 2
        else:
            ffn_channel = c
        self.conv1 = nn.Conv2d(in_channels=c, out_channels=ffn_channel, kernel_size=1, padding=0, stride=1, groups=1,
                               bias=True)
        self.conv2 = nn.Conv2d(in_channels=ffn_channel, out_channels=c, kernel_size=1, padding=0, stride=1, groups=1,
                               bias=True)
        self.depthwise = nn.Conv2d(in_channels=c, out_channels=ffn_channel, kernel_size=3, padding=1, stride=1,
                                   groups=c, bias=True, dilation=1)

    def forward(self, input):

        x = self.conv1(input) + self.depthwise(input)
        x = self.conv2(x)

        return x


class FreMLP(nn.Module):

    def __init__(self, nc, expand=2):
        super(FreMLP, self).__init__()
        self.process1 = nn.Sequential(
            nn.Conv2d(nc, expand * nc, 1, 1, 0),
            nn.LeakyReLU(0.1, inplace=True),
            nn.Conv2d(expand * nc, nc, 1, 1, 0))

    def forward(self, x):
        _, _, H, W = x.shape
        x_freq = torch.fft.rfft2(x, norm='backward')
        mag = torch.abs(x_freq)
        pha = torch.angle(x_freq)
        mag = self.process1(mag)
        real = mag * torch.cos(pha)
        imag = mag * torch.sin(pha)
        x_out = torch.complex(real, imag)
        x_out = torch.fft.irfft2(x_out, s=(H, W), norm='backward')
        return x_out


class Branch(nn.Module):
    '''
    Branch that lasts lonly the dilated convolutions
    '''

    def __init__(self, c, DW_Expand, dilation=1):
        super().__init__()
        self.dw_channel = DW_Expand * c

        self.branch = nn.Sequential(
            nn.Conv2d(in_channels=self.dw_channel, out_channels=self.dw_channel, kernel_size=3, padding=dilation,
                      stride=1, groups=self.dw_channel,
                      bias=True, dilation=dilation)  # the dconv
        )

    def forward(self, input):
        return self.branch(input)


class DBlock(nn.Module):
    '''
    Change this block using Branch
    '''

    def __init__(self, c, DW_Expand=2, FFN_Expand=2, dilations=[1], extra_depth_wise=False):
        super().__init__()
        # we define the 2 branches
        self.dw_channel = DW_Expand * c

        self.conv1 = nn.Conv2d(in_channels=c, out_channels=self.dw_channel, kernel_size=1, padding=0, stride=1,
                               groups=1, bias=True, dilation=1)
        self.extra_conv = nn.Conv2d(self.dw_channel, self.dw_channel, kernel_size=3, padding=1, stride=1, groups=c,
                                    bias=True, dilation=1) if extra_depth_wise else nn.Identity()  # optional extra dw
        self.branches = nn.ModuleList()
        for dilation in dilations:
            self.branches.append(Branch(self.dw_channel, DW_Expand=1, dilation=dilation))

        assert len(dilations) == len(self.branches)
        self.dw_channel = DW_Expand * c
        self.sca = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Conv2d(in_channels=self.dw_channel // 2, out_channels=self.dw_channel // 2, kernel_size=1, padding=0,
                      stride=1,
                      groups=1, bias=True, dilation=1),
        )
        self.sg1 = SimpleGate()
        self.sg2 = SimpleGate()
        self.conv3 = nn.Conv2d(in_channels=self.dw_channel // 2, out_channels=c, kernel_size=1, padding=0, stride=1,
                               groups=1, bias=True, dilation=1)
        ffn_channel = FFN_Expand * c
        self.conv4 = nn.Conv2d(in_channels=c, out_channels=ffn_channel, kernel_size=1, padding=0, stride=1, groups=1,
                               bias=True)
        self.conv5 = nn.Conv2d(in_channels=ffn_channel // 2, out_channels=c, kernel_size=1, padding=0, stride=1,
                               groups=1, bias=True)

        self.norm1 = LayerNorm2d(c)
        self.norm2 = LayerNorm2d(c)

        self.gamma = nn.Parameter(torch.zeros((1, c, 1, 1)), requires_grad=True)
        self.beta = nn.Parameter(torch.zeros((1, c, 1, 1)), requires_grad=True)

    def forward(self, inp):

        y = inp
        x = self.norm1(inp)
        # x = self.conv1(self.extra_conv(x))
        x = self.extra_conv(self.conv1(x))
        z = 0
        for branch in self.branches:
            z += branch(x)
        z = self.sg1(z)
        x = self.sca(z) * z
        x = self.conv3(x)
        y = inp + self.beta * x
        # second step
        x = self.conv4(self.norm2(y))  # size [B, 2*C, H, W]
        x = self.sg2(x)  # size [B, C, H, W]
        x = self.conv5(x)  # size [B, C, H, W]
        x = y + x * self.gamma
        return x


class EBlock(nn.Module):
    '''
    Change this block using Branch
    '''

    def __init__(self, c, DW_Expand=2,  dilations = [1], extra_depth_wise=False):
        super().__init__()
        # we define the 2 branches
        self.dw_channel = DW_Expand * c
        self.extra_conv = nn.Conv2d(c, c, kernel_size=3, padding=1, stride=1, groups=c, bias=True,
                                    dilation=1) if extra_depth_wise else nn.Identity()  # optional extra dw
        self.conv1 = nn.Conv2d(in_channels=c, out_channels=self.dw_channel, kernel_size=1, padding=0, stride=1,
                               groups=1, bias=True, dilation=1)

        self.branches = nn.ModuleList()
        for dilation in dilations:
            self.branches.append(Branch(c, DW_Expand, dilation=dilation))

        assert len(dilations) == len(self.branches)
        self.dw_channel = DW_Expand * c
        self.sca = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Conv2d(in_channels=self.dw_channel // 2, out_channels=self.dw_channel // 2, kernel_size=1, padding=0,
                      stride=1,
                      groups=1, bias=True, dilation=1),
        )
        self.sg1 = SimpleGate()
        self.conv3 = nn.Conv2d(in_channels=self.dw_channel // 2, out_channels=c, kernel_size=1, padding=0, stride=1,
                               groups=1, bias=True, dilation=1)
        # second step

        self.norm1 = LayerNorm2d(c)
        self.norm2 = LayerNorm2d(c)
        self.freq = FreMLP(nc=c, expand=2)
        self.gamma = nn.Parameter(torch.zeros((1, c, 1, 1)), requires_grad=True)
        self.beta = nn.Parameter(torch.zeros((1, c, 1, 1)), requires_grad=True)


    def forward(self, inp):
        y = inp
        x = self.norm1(inp)
        x = self.conv1(self.extra_conv(x))
        z = 0
        for branch in self.branches:
            z += branch(x)

        z = self.sg1(z)
        x = self.sca(z) * z
        x = self.conv3(x)
        y = inp + self.beta * x
        # second step
        x_step2 = self.norm2(y)  # size [B, 2*C, H, W]
        x_freq = self.freq(x_step2)  # size [B, C, H, W]
        x = y * x_freq
        x = y + x * self.gamma

        return x


if __name__ == "__main__":
    # 定义输入张量大小（Batch、Channel、Height、Wight）
    B, C, H, W = 16, 64, 8, 8
    input_tensor = torch.randn(B,C,H,W)  # 随机生成输入张量
    dim=C
    # 创建 DynamicTanh 实例
    block = DBlock(dim,dilations=[1, 4, 9])
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    block = block.to(device)
    print(block)
    input_tensor = input_tensor.to(device)
    # 执行前向传播
    output = block(input_tensor)
    # 打印输入和输出的形状
    print(f"Input: {input_tensor.shape}")
    print(f"Output: {output.shape}")

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2403059.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

口罩佩戴检测算法AI智能分析网关V4工厂/工业等多场景守护公共卫生安全

口罩佩戴检测算法AI智能分析网关V4工厂/工业等多场景守护公共卫生安全

一、引言​ 在公共卫生安全日益受到重视的当下，口罩佩戴成为预防病毒传播、保障人员健康的重要措施。为了高效、精准地实现对人员口罩佩戴情况的监测，AI智能分析网关V4口罩检测方案应运而生。该方案依托先进的人工智能技术与强大的硬件性能，…
阅读更多...
Double/Debiased Machine Learning

Double/Debiased Machine Learning

独立同步分布的观测数据 { W i ( Y i , D i , X i ) ∣ i ∈ { 1 , . . . , n } } \{W_i(Y_i,D_i,X_i)| i\in \{1,...,n\}\} {Wi​(Yi​,Di​,Xi​)∣i∈{1,...,n}}，其中 Y i Y_i Yi​表示结果变量， D i D_i Di​表示因变量， X i X_i Xi​表…
阅读更多...
HarmonyOS Next 弹窗系列教程（4）

HarmonyOS Next 弹窗系列教程（4）

HarmonyOS Next 弹窗系列教程（4） 介绍 本章主要介绍和用户点击关联更加密切的菜单控制（Menu） 和 气泡提示（Popup） 它们出现显示弹窗出现的位置都是在用户点击屏幕的位置相关 菜单控制（Menu&…
阅读更多...
【C】-递归

【C】-递归

1、递归概念 递归（Recursion）是编程中一种重要的解决问题的方法，其核心思想是函数通过调用自身来解决规模更小的子问题，直到达到最小的、可以直接解决的基准情形（Base Case）。 核心：自己调用…
阅读更多...
飞马LiDAR500雷达数据预处理

飞马LiDAR500雷达数据预处理

0 引言 在使用飞马D2000无人机搭载LiDAR500进行作业完成后，需要对数据进行预处理，方便给内业人员开展点云分类等工作。在开始操作前，先了解一下使用的软硬件及整体流程。 0.1 外业测量设备 无人机：飞马D2000S激光模块&#xff…
阅读更多...
嵌入式鸿蒙开发环境搭建操作方法与实现

嵌入式鸿蒙开发环境搭建操作方法与实现

Linux环境搭建镜像下载链接： 链接：https://pan.baidu.com/s/1F2f8ED5V1KwLjyYzKVx2yQ 提取码：Leun vscode和Linux系统连接的详细过程1.下载Visual Studio Code
阅读更多...
QT常用控件（1）

QT常用控件（1）

控件是构成QT的基础元素，例如Qwidget也是一个控件，提供了一个‘空’的矩形，我们可以往里面添加内容和处理用户输入，例如：按钮（QpushButton），基础显示控件（Lable&#xff…
阅读更多...
明基编程显示器终于有优惠了，程序员快来，错过等一年！

明基编程显示器终于有优惠了，程序员快来，错过等一年！

最近618的活动已经陆续开始了，好多人说这是买数码产品的好时候，作为一名资深程序员，我做了不少功课，决定给自己升级办公设备，入手明基 RD 系列的显示器，这是市面上首家专注于我们程序员痛点和需求的产品&am…
阅读更多...
【计算机网络】非阻塞IO——select实现多路转接

【计算机网络】非阻塞IO——select实现多路转接

🔥个人主页🔥：孤寂大仙V 🌈收录专栏🌈：计算机网络 🌹往期回顾🌹：【计算机网络】NAT、代理服务器、内网穿透、内网打洞、局域网中交换机 🔖流水不争&#xff0…
阅读更多...
LeetCode--23.合并k个升序链表

LeetCode--23.合并k个升序链表

解题思路： 1.获取信息： 给出了多个升序链表，要求合并成一个升序链表，返回首元结点 2.分析题目： 外面在21题的时候，讲了怎样合并两个升序链表为一个升序链表，不了解的，建议去看一下21…
阅读更多...
【推荐算法】NeuralCF：深度学习重构协同过滤的革命性突破

【推荐算法】NeuralCF：深度学习重构协同过滤的革命性突破

NeuralCF：深度学习重构协同过滤的革命性突破 一、算法背景知识：协同过滤的演进与局限1.1 协同过滤的发展历程1.2 传统矩阵分解的缺陷 二、算法理论/结构：NeuralCF架构设计2.1 基础NeuralCF结构2.2 双塔模型进阶结构2.3 模型实现流程对比 三、…
阅读更多...
负载均衡相关基本概念

负载均衡相关基本概念

负载均衡在系统架构设计中至关重要，其核心目标是合理分配负载，提升系统整体性能和可靠性。本文简要介绍了负载均衡的基本概念，包括四层和七层负载均衡、负载均衡的使用场景和实现方式、负载均衡的常用算法以及一些配置相关知识。 1、负载均衡…
阅读更多...
集成电路设计：从概念到实现的完整解析优雅草卓伊凡

集成电路设计：从概念到实现的完整解析优雅草卓伊凡

集成电路设计：从概念到实现的完整解析优雅草卓伊凡 一、集成电路设计：芯片制造的”灵魂蓝图” 1.1 什么是集成电路设计？ 集成电路（IC）设计是指通过电子设计自动化（EDA）工具，将数百…
阅读更多...
动态规划之网格图模型（二）

动态规划之网格图模型（二）

文章目录 动态规划之网格图模型（二）LeetCode 931. 下降路径最小和思路Golang 代码 LeetCode 2684. 矩阵中移动的最大次数思路Golang 代码 LeetCode 2304. 网格中的最小路径代价思路Golang 代码 LeetCode 1289. 下降路径最小和 II思路Golang 代码 LeetCod…
阅读更多...
robot_lab——rsl_rl的train.py整体逻辑

robot_lab——rsl_rl的train.py整体逻辑

文章目录 Go2机器人训练流程详细分析概述1. 训练启动流程1.1 命令行参数解析RSL-RL相关参数组Isaac Sim应用启动参数组 1.2 RL配置1.3 Isaac Sim启动 2. 环境配置加载2.1 Hydra配置系统 3. 环境创建与初始化3.1 Gym环境创建3.2 Manager系统初始化3.2.1 ObservationManager3.2.2…
阅读更多...
.NET 原生驾驭 AI 新基建实战系列（三）：Chroma ── 轻松构建智能应用的向量数据库

.NET 原生驾驭 AI 新基建实战系列（三）：Chroma ── 轻松构建智能应用的向量数据库

在人工智能AI和机器学习ML迅猛发展的今天，数据的存储和检索需求发生了巨大变化。传统的数据库擅长处理结构化数据，但在面对高维向量数据时往往力不从心。向量数据库作为一种新兴技术，专为AI应用设计，能够高效地存储和查询高维向量…
阅读更多...
8.RV1126-OPENCV 视频中添加LOGO

8.RV1126-OPENCV 视频中添加LOGO

一.视频中添加 LOGO 图像大体流程 首先初始化VI,VENC模块并使能，然后创建两个线程：1.把LOGO灰度化，然后获取VI原始数据，其次把VI数据Mat化并创建一个感兴趣区域，最后把LOGO放感兴趣区域里并把数据发送给VENC。2.专门获…
阅读更多...
API管理是什么？API自动化测试怎么搭建？

API管理是什么？API自动化测试怎么搭建？

目录 一、API管理是什么 （一）API管理的定义 （二）API管理的重要性 二、API管理的主要内容 （一）API设计 1. 遵循标准规范 2. 考虑可扩展性 3. 保证接口的易用性 （二）API开发 …
阅读更多...
GIC v3 v4 虚拟化架构

GIC v3 v4 虚拟化架构

ARMV8-A架构中包含了对虚拟化的支持。为了与架构保持匹配，GICV3也对虚拟化做了支持。新增了以下特性： 对CPU interface的硬件虚拟化虚拟中断maintenance 中断：用于通知监管程序（例如hypervisor）一些特定的虚拟机事件 …
阅读更多...
2025远离Deno和Fresh

2025远离Deno和Fresh

原创作者：庄晓立（LIIGO） 原创时间：2025年6月6日 原创链接：https://blog.csdn.net/liigo/article/details/148479884 版权所有，转载请注明出处！ 相识 Deno，是Nodejs原开发者Ryan Da…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023