TranquilYu's Blog
返回

【论文阅读 | TCSVT 2025 | T²EA：目标感知泰勒展开近似网络】

约 32 分钟 · 7,632 字
论文阅读
文章目录51 节
  1. 1.1 红外-可见光融合的需求
  2. 1.2 现有方法局限
  3. 1.3 本文贡献
  4. 3.1 泰勒展开理论
  5. 3.2 网络架构与实现
  6. 3.2.1 映射网络
  7. 3.2.2 导数网络
  8. 3.2.3 网络架构
  9. 3.2.4 损失函数
  10. 3.3 网络优化
  11. 4.1 网络架构概述
  12. 4.1.1 双分支结构
  13. 4.1.2 特征融合
  14. 4.1.3 注意力机制
  15. 4.2 损失函数
  16. 4.2.1 强度损失（Intensity Loss）
  17. 4.2.2 纹理细节损失（Texture Loss）
  18. 4.2.3 总损失函数
  19. 4.3 逆泰勒重构（ITE）网络
  20. 4.4 维度变换与阶乘加权的理论依据
  21. 4.4.1 从多阶分解到单通道融合的维度变换
  22. 4.4.2 output=1
  23. 4.5 网络优化
  24. 4.6 网络总结
  25. 5.1 语义分割网络
  26. 5.2 损失函数
  27. 6.1 思路
  28. 6.2 损失函数
  29. 6.3 总损失与调度
  30. 6.4 训练设置
  31. 7.1 实验准备
  32. 7.1.1 数据集与划分方式
  33. 7.1.2 实验环境与关键超参
  34. 7.1.3 对比方法与评价指标
  35. 7.2 消融研究
  36. 7.2.1 泰勒展开层数 n 的选择
  37. 7.2.2 不同融合策略对比
  38. 7.3 MSRS 上的 SOTA 方法对比
  39. 7.3.1 定性对比
  40. 7.3.2 定量对比
  41. 7.4 跨数据集泛化实验（TNO & LLVIP）
  42. 7.4.1 实验设置与可视化样例
  43. 7.4.2 定性结论
  44. 7.4.3 定量结论
  45. 7.5 融合结果用于下游视觉任务
  46. 7.5.1 语义分割（IBisNet）
  47. 7.5.2 目标检测（YOLOv5）
  48. 7.6 计算复杂度与效率
  49. 9.1 主要贡献
  50. 9.2 性能总结
  51. 9.3 适用场景与展望
文章目录51 节
  1. 1.1 红外-可见光融合的需求
  2. 1.2 现有方法局限
  3. 1.3 本文贡献
  4. 3.1 泰勒展开理论
  5. 3.2 网络架构与实现
  6. 3.2.1 映射网络
  7. 3.2.2 导数网络
  8. 3.2.3 网络架构
  9. 3.2.4 损失函数
  10. 3.3 网络优化
  11. 4.1 网络架构概述
  12. 4.1.1 双分支结构
  13. 4.1.2 特征融合
  14. 4.1.3 注意力机制
  15. 4.2 损失函数
  16. 4.2.1 强度损失（Intensity Loss）
  17. 4.2.2 纹理细节损失（Texture Loss）
  18. 4.2.3 总损失函数
  19. 4.3 逆泰勒重构（ITE）网络
  20. 4.4 维度变换与阶乘加权的理论依据
  21. 4.4.1 从多阶分解到单通道融合的维度变换
  22. 4.4.2 output=1
  23. 4.5 网络优化
  24. 4.6 网络总结
  25. 5.1 语义分割网络
  26. 5.2 损失函数
  27. 6.1 思路
  28. 6.2 损失函数
  29. 6.3 总损失与调度
  30. 6.4 训练设置
  31. 7.1 实验准备
  32. 7.1.1 数据集与划分方式
  33. 7.1.2 实验环境与关键超参
  34. 7.1.3 对比方法与评价指标
  35. 7.2 消融研究
  36. 7.2.1 泰勒展开层数 n 的选择
  37. 7.2.2 不同融合策略对比
  38. 7.3 MSRS 上的 SOTA 方法对比
  39. 7.3.1 定性对比
  40. 7.3.2 定量对比
  41. 7.4 跨数据集泛化实验（TNO & LLVIP）
  42. 7.4.1 实验设置与可视化样例
  43. 7.4.2 定性结论
  44. 7.4.3 定量结论
  45. 7.5 融合结果用于下游视觉任务
  46. 7.5.1 语义分割（IBisNet）
  47. 7.5.2 目标检测（YOLOv5）
  48. 7.6 计算复杂度与效率
  49. 9.1 主要贡献
  50. 9.2 性能总结
  51. 9.3 适用场景与展望

题目：T²EA: Target-Aware Taylor Expansion Approximation Network for Infrared and Visible Image Fusion

期刊：IEEE Transactions on Circuits and Systems for Video Technology (TCSVT), Vol.35, No.5, 2025

论文链接：T2EA: Target-Aware Taylor Expansion Approximation Network for Infrared and Visible Image Fusion | IEEE Journals & Magazine | IEEE Xplore

代码：MysterYxby/T2EA

年份：2025

1. 研究背景与动机

1.1 红外-可见光融合的需求

1.2 现有方法局限

1.3 本文贡献

  1. 目标感知泰勒展开近似（TEA）：用多阶导显式刻画纹理与形状，可解释、可控。
  2. 双分支特征融合 (DBFF)：按泰勒阶分别融合IR/VIS特征，CBAM关注目标区域。
  3. 逆泰勒重构 + 分割联合优化：保持导数一致性，分割梯度反哺融合，强化目标呈现。
  4. 在MSRS/TNO/LLVIP数据集及分割/检测任务上验证，兼顾跨域泛化与任务友好性。

2. 整体框架

输入IR/VIS → 泰勒展开近似网络（TEA）分解 → 分阶双分支特征融合网络（DBFF网络）特征融合 → 逆泰勒展开（ITE）网络重构 →分割头联合优化（利用语义分割网络对融合图像进行细化）

核心即 “分解-融合-重构” + 目标梯度监督。

损失函数：

LJoint=LF+μLsemanticL_{Joint} = L_{F} + \mu L_{semantic}

该公式结合了融合损失（LFL_F）和语义分割损失（LsemanticL_{semantic}），通过平衡这两者优化网络性能。

3. 泰勒展开近似（TEA）网络

代码来自 network/TEM.py、loss/Taylor.py、train_TEM.py。

3.1 泰勒展开理论

泰勒展开是数学中用于将函数在某一点处展开的一个工具。在图像处理中，可以利用泰勒展开对图像进行特征提取。假设图像可以用函数 f(x)f(x) 表示，泰勒展开的表达式如下：

f(x)=f(x0)+f′(x0)⋅(x−x0)+f′′(x0)2!⋅(x−x0)2+⋯+f(n)(x0)n!⋅(x−x0)nf(x) = f(x_0) + f'(x_0) \cdot (x - x_0) + \frac{f''(x_0)}{2!} \cdot (x - x_0)^2 + \cdots + \frac{f^{(n)}(x_0)}{n!} \cdot (x - x_0)^n

其中，f(x)f(x) 表示原始图像，f(x0)f(x_0) 是基础特征层，f′(x0),f′′(x0),…f'(x_0), f''(x_0), \dots 表示不同阶次的导数特征。通过这种分解方法，能够提取图像的全局结构（低频信息）和细节（高频信息）。

对应代码（泰勒项的生成与阶乘系数累加）：

# network/TEM.py
from math import factorial  # 引入阶乘用于泰勒系数

def forward(self, input, n):  # 前向：生成各阶泰勒项
    y_list = []  # 保存每一阶特征
    x = self.base(input)  # 计算基础层 f(x0)
    y_list.append(x)  # 记录0阶项
    for i in range(1, n + 1):  # 逐阶生成导数特征
        y_list.append(self.gradient(torch.cat([y_list[i - 1], input], dim=1)))  # 拼接上一阶与输入
    for i in range(len(y_list)):  # 按阶累加泰勒项
        result += (1 / factorial(i)) * y_list[i]  # 1/i! 权重累加到结果

3.2 网络架构与实现

根据泰勒展开公式，TEA 网络包括两大主要部分：基础层的提取和导数层的提取。网络分别由映射网络和导数网络组成。

3.2.1 映射网络

映射网络的作用是提取图像的基础层特征，即泰勒展开的 f(x0)f(x_0)。该网络由卷积层和残差模块（ResBlock）构成，具体结构如下：

对应代码（基础层base 与ResB）：

# network/TEM.py
class ResB(nn.Module):  # 残差模块
    def __init__(self, in_c, out_c):  # 初始化输入/输出通道
        super(ResB, self).__init__()  # 调用父类初始化
        self.Res = nn.Sequential(  # 主分支卷积序列
            nn.Conv2d(in_c, out_c, 1, 1, 0),  # 1x1调整通道
            nn.LeakyReLU(),  # 非线性激活
            nn.Conv2d(out_c, out_c, 3, 1, 1),  # 3x3提取局部
            nn.LeakyReLU(),  # 非线性激活
            nn.Conv2d(out_c, out_c, 1, 1, 0),  # 1x1融合特征
        )  # 主分支结束
        self.Conv = nn.Conv2d(in_c, out_c, 1, 1, 0)  # shortcut 1x1
        self.activate = nn.LeakyReLU()  # 残差后激活

    def forward(self, x):  # 前向传播
        y = self.Res(x) + self.Conv(x)  # 主分支与shortcut相加
        y = self.activate(y)  # 激活输出
        return y  # 返回残差结果

class Taylor_Encoder(nn.Module):  # TEA编码器主体
    def __init__(self) -> None:  # 初始化
        super().__init__()  # 调用父类初始化
        self.base = nn.Sequential(  # 基础层分支
            nn.Conv2d(1, 32, 5, 1, 2),  # 5x5卷积提取低频
            nn.LeakyReLU(),  # 激活
            ResB(32, 64),  # ResB扩大通道
            ResB(64, 32),  # ResB压回通道
            ResB(32, 1),  # ResB输出到1通道
        )  # 基础分支结束

3.2.2 导数网络

导数网络的目的是通过多阶泰勒展开提取图像的高阶特征（即 f′(x0),f′′(x0),…f'(x_0), f''(x_0), \dots）。该网络由两个5×55 \times 5卷积层和三个残差模块（ResDBlocks）组成，采用Mish激活函数和密集连接来保留细节特征。在图像特征的提取中，每一阶导数不仅依赖于前一阶的特征，还与基础层（f(x0)f(x_0)）以及上层导数特征（如f′(x0)f'(x_0)）相关。为了保持这些特征之间的高相关性，网络通过拼接基础层特征和导数层特征来递归提取各阶特征。

例如，对于泰勒展开的第一阶导数，将输入图像特征和上一阶（基础层或更低阶的导数）特征进行拼接，送入网络进行进一步的处理，以确保各阶导数层的准确提取。通过这种方式，网络能够有效提取图像的全局结构与局部细节。

此过程中的重要机制是拼接操作（Concatenate），它通过将低阶导数和输入图像的特征结合，从而为高阶导数提供更完整的上下文信息。

对应代码（Mish激活 + RDBLOCK + gradient分支）：

# network/TEM.py
class Conv(nn.Module):  # 基础卷积块
    def __init__(self, in_c, o_c, size, stride):  # 输入/输出通道与核大小
        super(Conv, self).__init__()  # 调用父类初始化
        self.conv = nn.Conv2d(  # 卷积层
            in_channels=in_c,  # 输入通道数
            out_channels=o_c,  # 输出通道数
            kernel_size=size,  # 卷积核尺寸
            stride=stride,  # 步长
            padding=size // 2,  # 保持尺寸的填充
        )  # 卷积层结束
        self.activation = nn.Mish()  # Mish激活

    def forward(self, input):  # 前向传播
        x = self.conv(input)  # 卷积计算
        y = self.activation(x)  # Mish激活
        return y  # 输出特征

class RDBLOCK(nn.Module):  # 残差密集连接块
    def __init__(self, outchannel):  # 基础通道数
        super(RDBLOCK, self).__init__()  # 调用父类初始化
        self.conv1 = Conv(in_c=outchannel, o_c=outchannel, size=1, stride=1)  # 1x1特征
        self.conv2 = Conv(in_c=2 * outchannel, o_c=outchannel, size=3, stride=1)  # 3x3融合
        self.conv3 = Conv(in_c=3 * outchannel, o_c=outchannel, size=1, stride=1)  # 1x1压缩
        self.conv4 = Conv(in_c=4 * outchannel, o_c=2 * outchannel, size=1, stride=1)  # 1x1扩展
        self.shortcut = nn.Sequential(  # shortcut分支
            nn.Conv2d(in_channels=outchannel, out_channels=2 * outchannel, kernel_size=1, stride=1)  # 1x1对齐
        )  # shortcut结束

    def forward(self, x):  # 前向传播
        x1 = self.conv1(x)  # 第1层
        y = torch.cat((x, x1), 1)  # 拼接x与x1
        x2 = self.conv2(y)  # 第2层
        z = torch.cat((x, x1, x2), 1)  # 拼接到更密集特征
        x3 = self.conv3(z)  # 第3层
        x4 = self.conv4(torch.cat((z, x3), 1))  # 第4层并再拼接
        output = self.shortcut(x) + x4  # 残差相加
        output = F.mish(output)  # Mish激活
        return output  # 输出特征

class Taylor_Encoder(nn.Module):  # TEA编码器主体
    def __init__(self) -> None:  # 初始化
        super().__init__()  # 调用父类初始化
        self.gradient = nn.Sequential(  # 导数分支
            nn.Conv2d(2, 8, 5, 1, 2),  # 5x5卷积提取导数特征
            nn.LeakyReLU(),  # 激活
            RDBLOCK(8),  # RDBLOCK保持细节
            RDBLOCK(16),  # 通道逐级扩展
            RDBLOCK(32),  # 更深层密集连接
            nn.Conv2d(64, 1, 5, 1, 2),  # 5x5回到1通道
            nn.LeakyReLU(),  # 激活
        )  # 导数分支结束

3.2.3 网络架构

根据泰勒展开公式，需要同时估算基础层 f(x0)f(x_0) 和各阶导数层 f(k)(x0) (k∈[1,n])f^{(k)}(x_0) \ (k \in [1, n])。为了充分提取这些特征，可通过以下方式组合网络：

f(x)=Φb(f(x))+∑k=1nΦd(Concat(f(k−1)(x0),f(x)))f(x) = \Phi_b(f(x)) + \sum_{k=1}^{n} \Phi_d \left( \text{Concat}(f^{(k-1)}(x_0), f(x)) \right)

其中，Φb\Phi_b 为映射网络，Φd\Phi_d 为导数网络，Concat\text{Concat} 表示将基础层和各阶导数层特征进行拼接。

对应代码（base + gradient + concat + 累加）：

# network/TEM.py
def forward(self, input, n):  # 前向：组合基础层与导数层
    y_list = []  # 保存各阶特征
    x = self.base(input)  # 基础层输出
    y_list.append(x)  # 加入0阶
    for i in range(1, n + 1):  # 生成1..n阶
        y_list.append(self.gradient(torch.cat([y_list[i - 1], input], dim=1)))  # concat并估计导数
    for i in range(len(y_list)):  # 按阶累加
        result += (1 / factorial(i)) * y_list[i]  # 1/i! 加权
    return result, y_list  # 返回重建结果与各阶项

3.2.4 损失函数

在优化过程中，LpixelL_{pixel}负责控制重建的图像与源图像之间的像素级差异，而LgradL_{grad}则强调图像中的细节特征。为了平衡这两者的影响，这里引入了超参数λ\lambda，它用于调整这两个损失项的权重。λ\lambda的合理选择对于优化过程至关重要，它决定了网络在保留全局信息（通过像素损失）和细节信息（通过梯度损失）之间的权衡。

在训练过程中，通过逐步调整λ\lambda的值，可以帮助网络在保留图像整体结构的同时，增强细节的表现，尤其是在低对比度和高噪声的区域。

为了优化网络参数，作者采用了联合损失函数来训练 TEA 网络：

LT=Lpixel+λLgradL_T = L_{pixel} + \lambda L_{grad}

对应代码（像素 L1 + 梯度损失 + derivative max聚合）：

# loss/Taylor.py
class L_Intensity(nn.Module):  # 像素L1损失
    def forward(self, image_A, image_B):  # 前向传播
        Loss_intensity = F.l1_loss(image_A, image_B)  # 计算L1差
        return Loss_intensity  # 返回像素损失

class L_Grad(nn.Module):  # 梯度损失
    def forward(self, image_A, image_B):  # 前向传播
        image_A_Y = image_A[:, :1, :, :]  # 取A的Y通道
        image_B_Y = image_B[:, :1, :, :]  # 取B的Y通道
        gradient_A = self.sobelconv(image_A_Y)  # Sobel梯度A
        gradient_B = self.sobelconv(image_B_Y)  # Sobel梯度B
        Loss_gradient = F.l1_loss(gradient_A, gradient_B)  # 梯度L1
        return Loss_gradient  # 返回梯度损失

class Taylor_loss(nn.Module):  # 泰勒联合损失
    def forward(self, input, result, gd):  # input为原图，gd为各阶导数
        b, c, h, w = result.shape  # 读取输出尺寸
        grad_map = torch.zeros([b, c, h, w]).to(self.device)  # 初始化梯度图
        loss_L1 = self.int(input, result)   # L_pixel：像素L1
        loss_g1 = self.grad(input, result)  # 输出与输入梯度差
        for i in range(1, len(gd)):  # 遍历导数阶次
            grad_map = torch.max(grad_map, gd[i])  # 聚合各阶最大响应
        loss_g2 = self.int(self.sobelconv(input), grad_map)  # 梯度与导数最大图
        loss_g = loss_g1 + 0.3 * loss_g2  # 梯度损失加权
        return loss_L1, loss_g, loss_L1 + loss_g  # 返回分项与总损失

3.3 网络优化

通过最小化上述损失函数，TEA 网络能够从红外和可见光图像中提取有效的特征，既保留了图像的整体结构，又能够细致地提取图像中的细节特征，为后续的图像融合和目标检测任务提供支持。

对应代码（训练中使用联合损失并反向传播优化）：

# train_TEM.py
loss_int, loss_grad, loss = loss_ft(img, out, y)  # 计算像素与梯度损失
optimizer.zero_grad()  # 清空梯度
loss.backward()  # 反向传播
optimizer.step()  # 更新参数

4. 双分支特征融合（DBFF）网络

代码来自 network/FusionNet.py、loss/Fusion.py、train_Fusion.py。

4.1 网络架构概述

双分支特征融合（DBFF）网络的核心目标是将分解得到的红外和可见光图像特征进行有效融合，从而生成高质量的融合图像。DBFF网络采用两条并行的分支结构，每条分支分别从红外图像和可见光图像中提取特征。每条分支的结构完全相同，具体包括卷积层和梯度残差密集块（GRDB）模块。通过这种结构，DBFF能够在多尺度上提取图像的浅层特征，并进行有效融合。

4.1.1 双分支结构

在DBFF网络中，有两条并行的分支来分别处理红外图像和可见光图像。这两条分支具有相同的架构，通过卷积操作提取浅层特征，增强图像的局部细节。

对应代码（GRDB的实现：密集连接 + Sobel梯度残差）：

# network/FusionNet.py
class ConvLeakyRelu2d(nn.Module):  # 基础卷积块
    def __init__(self, in_channels, out_channels, kernel_size=3, padding=1, stride=1, dilation=1, groups=1):  # 初始化超参
        super(ConvLeakyRelu2d, self).__init__()  # 调用父类初始化
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, padding=padding, stride=stride, dilation=dilation, groups=groups)  # 卷积层
    def forward(self, x):  # 前向传播
        return F.leaky_relu(self.conv(x), negative_slope=0.2)  # LeakyReLU 激活

class Sobelxy(nn.Module):  # Sobel 梯度模块
    def __init__(self, channels, kernel_size=3, padding=1, stride=1, dilation=1, groups=1):  # 初始化超参
        super(Sobelxy, self).__init__()  # 调用父类初始化
        sobel_filter = np.array([[1, 0, -1], [2, 0, -2], [1, 0, -1]])  # Sobel 核
        self.convx = nn.Conv2d(channels, channels, kernel_size=kernel_size, padding=padding, stride=stride, dilation=dilation, groups=channels, bias=False)  # x方向梯度
        self.convx.weight.data.copy_(torch.from_numpy(sobel_filter))  # 载入权重
        self.convy = nn.Conv2d(channels, channels, kernel_size=kernel_size, padding=padding, stride=stride, dilation=dilation, groups=channels, bias=False)  # y方向梯度
        self.convy.weight.data.copy_(torch.from_numpy(sobel_filter.T))  # 载入权重
    def forward(self, x):  # 前向传播
        sobelx = self.convx(x)  # x方向梯度
        sobely = self.convy(x)  # y方向梯度
        x = torch.abs(sobelx) + torch.abs(sobely)  # 幅值叠加
        return x  # 返回梯度特征

class Conv1(nn.Module):  # 1x1 卷积块
    def __init__(self, in_channels, out_channels, kernel_size=1, padding=0, stride=1, dilation=1, groups=1):  # 初始化超参
        super(Conv1, self).__init__()  # 调用父类初始化
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, padding=padding, stride=stride, dilation=dilation, groups=groups)  # 1x1卷积
    def forward(self, x):  # 前向传播
        return self.conv(x)  # 返回卷积结果

class DenseBlock(nn.Module):  # 密集连接块
    def __init__(self, channels):  # 输入通道数
        super(DenseBlock, self).__init__()  # 调用父类初始化
        self.conv1 = ConvLeakyRelu2d(channels, channels)  # 第1层
        self.conv2 = ConvLeakyRelu2d(2 * channels, channels)  # 第2层
    def forward(self, x):  # 前向传播
        x = torch.cat((x, self.conv1(x)), dim=1)  # 拼接第1层输出
        x = torch.cat((x, self.conv2(x)), dim=1)  # 拼接第2层输出
        return x  # 返回密集特征

class RGBD(nn.Module):  # 梯度残差密集块（GRDB 对应实现）
    def __init__(self, in_channels, out_channels):  # 输入/输出通道
        super(RGBD, self).__init__()  # 调用父类初始化
        self.dense = DenseBlock(in_channels)  # 密集连接分支
        self.convdown = Conv1(3 * in_channels, out_channels)  # 通道压缩
        self.sobelconv = Sobelxy(in_channels)  # 梯度分支
        self.convup = Conv1(in_channels, out_channels)  # 通道对齐
    def forward(self, x):  # 前向传播
        x1 = self.dense(x)  # 密集分支特征
        x1 = self.convdown(x1)  # 压缩通道
        x2 = self.sobelconv(x)  # 梯度分支特征
        x2 = self.convup(x2)  # 对齐通道
        return F.leaky_relu(x1 + x2, negative_slope=0.1)  # 残差融合后激活

对应代码（双分支结构：红外/可见光对称提取）：

# network/FusionNet.py
class FusionNetwork(nn.Module):  # DBFF 主体
    def __init__(self, output):  # 初始化输出通道
        super(FusionNetwork, self).__init__()  # 调用父类初始化
        vis_ch = [16, 32, 48]  # 可见光分支通道
        inf_ch = [16, 32, 48]  # 红外分支通道
        output = 1  # 输出单通道
        self.vis_conv = ConvLeakyRelu2d(1, vis_ch[0])  # 可见光卷积层
        self.vis_rgbd1 = RGBD(vis_ch[0], vis_ch[1])  # 可见光 GRDB-1
        self.vis_rgbd2 = RGBD(vis_ch[1], vis_ch[2])  # 可见光 GRDB-2
        self.inf_conv = ConvLeakyRelu2d(1, inf_ch[0])  # 红外卷积层
        self.inf_rgbd1 = RGBD(inf_ch[0], inf_ch[1])  # 红外 GRDB-1
        self.inf_rgbd2 = RGBD(inf_ch[1], inf_ch[2])  # 红外 GRDB-2

    def forward(self, image_vis, image_ir):  # 前向传播
        x_vis_origin = image_vis[:, :1]  # 提取可见光Y通道
        x_inf_origin = image_ir  # 红外单通道
        x_vis_p = self.vis_conv(x_vis_origin)  # 可见光浅层特征
        x_vis_p1 = self.vis_rgbd1(x_vis_p)  # 可见光 GRDB-1
        x_vis_p2 = self.vis_rgbd2(x_vis_p1)  # 可见光 GRDB-2
        x_inf_p = self.inf_conv(x_inf_origin)  # 红外浅层特征
        x_inf_p1 = self.inf_rgbd1(x_inf_p)  # 红外 GRDB-1
        x_inf_p2 = self.inf_rgbd2(x_inf_p1)  # 红外 GRDB-2

4.1.2 特征融合

在两条分支分别提取出红外和可见光图像的特征后，将这两部分特征进行融合。融合操作采用了元素级加法，将提取的红外和可见光图像特征进行加和，得到融合后的特征图。这一步确保了图像的多模态信息能够被有效整合，从而增强了目标的突出显示和场景细节的保留。

对应代码（分支特征拼接 + CBAM + 解码融合）：

# network/FusionNet.py
class FusionNetwork(nn.Module):  # DBFF 主体
    def __init__(self, output):  # 初始化输出通道
        super(FusionNetwork, self).__init__()  # 调用父类初始化
        vis_ch = [16, 32, 48]  # 可见光分支通道
        inf_ch = [16, 32, 48]  # 红外分支通道
        output = 1
        self.attention = cbam_block(vis_ch[2] + inf_ch[2])  # CBAM 注意力
        self.decode4 = ConvBnLeakyRelu2d(vis_ch[2] + inf_ch[2], vis_ch[1] + vis_ch[1], padding=3, dilation=3)  # 解码层
        self.decode3 = ConvBnLeakyRelu2d(vis_ch[1] + inf_ch[1], vis_ch[0] + inf_ch[0], padding=3, dilation=3)  # 解码层
        self.decode2 = ConvBnLeakyRelu2d(vis_ch[0] + inf_ch[0], vis_ch[0], padding=3, dilation=3)  # 解码层
        self.decode1 = ConvBnTanh2d(vis_ch[0], output)  # 输出层

    def forward(self, image_vis, image_ir):  # 前向传播
        x_attention = self.attention(torch.cat((x_vis_p2, x_inf_p2), dim=1))  # 特征拼接后做注意力
        x = self.decode4(x_attention)  # 解码融合
        x = self.decode3(x)  # 逐级解码
        x = self.decode2(x)  # 逐级解码
        x = self.decode1(x)  # 输出融合图
        return x  # 返回融合结果

4.1.3 注意力机制

为了进一步增强特征融合效果，作者在DBFF网络中引入了注意力机制。具体而言，采用了空间-通道注意力机制（CBAM）来优化特征融合的过程。CBAM通过在空间和通道维度上对特征图进行加权处理，能够有效抑制背景信息，突出目标区域，从而提高融合图像的质量。

对应代码（CBAM：通道注意力 + 空间注意力）：

# network/FusionNet.py
class ChannelAttention(nn.Module):  # 通道注意力
    def __init__(self, in_planes, ratio=8):  # 输入通道与压缩比
        super(ChannelAttention, self).__init__()  # 调用父类初始化
        self.avg_pool = nn.AdaptiveAvgPool2d(1)  # 全局平均池化
        self.max_pool = nn.AdaptiveMaxPool2d(1)  # 全局最大池化
        self.fc1 = nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False)  # 降维
        self.relu1 = nn.ReLU()  # ReLU
        self.fc2 = nn.Conv2d(in_planes // ratio, in_planes, 1, bias=False)  # 升维
        self.sigmoid = nn.Sigmoid()  # Sigmoid 归一化

    def forward(self, x):  # 前向传播
        avg_out = self.fc2(self.relu1(self.fc1(self.avg_pool(x))))  # 平均池化分支
        max_out = self.fc2(self.relu1(self.fc1(self.max_pool(x))))  # 最大池化分支
        out = avg_out + max_out  # 分支相加
        return self.sigmoid(out)  # 输出通道权重

class SpatialAttention(nn.Module):  # 空间注意力
    def __init__(self, kernel_size=7):  # 卷积核大小
        super(SpatialAttention, self).__init__()  # 调用父类初始化
        assert kernel_size in (3, 7), 'kernel size must be 3 or 7'  # 约束核尺寸
        padding = 3 if kernel_size == 7 else 1  # 设置padding
        self.conv1 = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)  # 空间卷积
        self.sigmoid = nn.Sigmoid()  # Sigmoid 归一化

    def forward(self, x):  # 前向传播
        avg_out = torch.mean(x, dim=1, keepdim=True)  # 通道平均
        max_out, _ = torch.max(x, dim=1, keepdim=True)  # 通道最大
        x = torch.cat([avg_out, max_out], dim=1)  # 拼接两路
        x = self.conv1(x)  # 空间卷积
        return self.sigmoid(x)  # 输出空间权重

class cbam_block(nn.Module):  # CBAM 组合块
    def __init__(self, channel, ratio=8, kernel_size=7):  # 初始化超参
        super(cbam_block, self).__init__()  # 调用父类初始化
        self.channelattention = ChannelAttention(channel, ratio=ratio)  # 通道注意力
        self.spatialattention = SpatialAttention(kernel_size=kernel_size)  # 空间注意力

    def forward(self, x):  # 前向传播
        x = x * self.channelattention(x)  # 通道加权
        x = x * self.spatialattention(x)  # 空间加权
        return x  # 返回加权特征

4.2 损失函数

双分支结构是DBFF网络的核心，旨在分别处理红外图像和可见光图像的特征。每个分支采用相同的网络架构，包括卷积层和梯度残差密集块（GRDB），以便在多个尺度上提取图像的浅层特征。

在两条并行分支中，红外和可见光图像被独立地处理，提取出各自的特征。然后，利用加权融合策略，将这两部分特征进行融合，最终得到更具代表性的融合图像。与传统的单分支结构不同，DBFF网络通过引入注意力机制，能够更精细地处理红外图像中的低光区域和可见光图像中的细节部分，极大提升了图像的质量。

为了优化DBFF网络，确保其能够有效融合红外和可见光图像的特征，作者设计了一个联合损失函数，该损失函数包括强度损失和纹理细节损失两个部分：

4.2.1 强度损失（Intensity Loss）

强度损失 LintL_{int} 主要用于约束融合图像的整体强度，使其与源图像在强度上保持一致。其公式为：

Lint=1HW∥If−max⁡(Ir,Ivis)∥1L_{int} = \frac{1}{H W} \| I_f - \max(I_r, I_{vis}) \|_1

其中，IfI_f 表示融合后的图像，IrI_r 和 IvisI_{vis} 分别表示红外图像和可见光图像，HH 和 WW 分别是图像的高度和宽度。

4.2.2 纹理细节损失（Texture Loss）

纹理细节损失 LtexL_{tex} 主要用于保留图像中的细节信息，尤其是图像中的边缘和纹理。其公式为：

Ltex=1HW∥∇If−max⁡(∇Ir,∇Ivis)∥1L_{tex} = \frac{1}{H W} \| \nabla I_f - \max(\nabla I_r, \nabla I_{vis}) \|_1

其中，∇\nabla 表示图像的梯度操作，∣∇If∣|\nabla I_f| 表示融合图像的梯度，max⁡(∇Ir,∇Ivis)\max(\nabla I_r, \nabla I_{vis}) 表示红外和可见光图像的梯度的最大值。

4.2.3 总损失函数

联合损失函数 LFL_F 由强度损失和纹理细节损失组成，其公式为：

LF=Lint+αLtexL_F = L_{int} + \alpha L_{tex}

其中，α\alpha 是一个超参数，用于平衡强度损失和纹理细节损失的影响。

对应代码（强度与纹理梯度损失）：

# loss/Fusion.py
class Sobelxy(nn.Module):  # Sobel 梯度
    def __init__(self):  # 初始化
        super(Sobelxy, self).__init__()  # 调用父类初始化
        kernelx = [[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]  # x方向核
        kernely = [[1, 2, 1], [0, 0, 0], [-1, -2, -1]]  # y方向核
        kernelx = torch.FloatTensor(kernelx).unsqueeze(0).unsqueeze(0)  # 转Tensor
        kernely = torch.FloatTensor(kernely).unsqueeze(0).unsqueeze(0)  # 转Tensor
        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")  # 设备
        self.weightx = nn.Parameter(data=kernelx, requires_grad=False).to(self.device)  # 固定权重x
        self.weighty = nn.Parameter(data=kernely, requires_grad=False).to(self.device)  # 固定权重y
    def forward(self, x):  # 前向传播
        sobelx = F.conv2d(x, self.weightx, padding=1)  # x方向梯度
        sobely = F.conv2d(x, self.weighty, padding=1)  # y方向梯度
        return torch.abs(sobelx) + torch.abs(sobely)  # 幅值叠加

class Fusionloss(nn.Module):  # 融合损失
    def __init__(self):  # 初始化
        super(Fusionloss, self).__init__()  # 调用父类初始化
        self.sobelconv = Sobelxy()  # 梯度算子

    def forward(self, image_vis, image_ir, generate_img):  # 前向传播损失
        image_y = image_vis[:, :1, :, :]  # 可见光Y通道
        x_in_max = torch.max(image_y, image_ir)  # 强度目标：max(Ir,Ivis)
        loss_in = F.l1_loss(x_in_max, generate_img)  # 强度损失
        y_grad = self.sobelconv(image_y)  # 可见光梯度
        ir_grad = self.sobelconv(image_ir)  # 红外梯度
        generate_img_grad = self.sobelconv(generate_img)  # 融合图梯度
        x_grad_joint = torch.max(y_grad, ir_grad)  # 梯度目标：max(grad)
        loss_grad = F.l1_loss(x_grad_joint, generate_img_grad)  # 纹理细节损失
        loss_total = loss_in + 10 * loss_grad  # 总损失（含权重）
        return loss_in, loss_grad, loss_total  # 返回分项与总损失

4.3 逆泰勒重构（ITE）网络

在完成IR与VIS特征的融合后，DBFF生成的融合特征需要通过逆泰勒展开（ITE）过程恢复为最终的融合图像。这一步骤是将多阶泰勒分解的结果重新组织为单一的融合输出，其核心是利用泰勒展开的线性可加性。

根据泰勒定理，多阶导数项的线性组合可以近似原函数，因此多个融合分支的加权求和能够恢复高保真的融合结果。FusionModel通过以下方式实现逆泰勒重构：

I^f=∑i=0n1i!⋅Fi(yiir,yivis)\hat{I}_f = \sum_{i=0}^{n} \frac{1}{i!} \cdot F_i(y_i^{ir}, y_i^{vis})

其中，FiF_i 是第ii阶的融合网络（DBFF），yiiry_i^{ir}、yivisy_i^{vis}分别是红外和可见光的第ii阶泰勒分解特征，1i!\frac{1}{i!}是阶乘归一化系数，确保高阶项的贡献逐步衰减，保持数值稳定性。

对应代码（FusionModel中的多阶加权融合与重构）：

# network/FusionNet.py
class FusionModel(nn.Module):  # 逆泰勒重构模型
    def __init__(self, *args, **kwargs) -> None:  # 初始化
        super().__init__(*args, **kwargs)  # 调用父类初始化
        self.Net = FusionNetwork(output=1)  # DBFF 融合网络
        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")  # 设备设置

    def forward(self, ir, vis):  # 前向传播：逆泰勒重构
        f_list = []  # 保存各阶融合结果
        n = len(ir)  # 获取泰勒分解的阶数
        b, c, h, w = ir[0].shape  # 读取批次、通道、高、宽
        result = torch.zeros([b, c, h, w]).to(self.device)  # 初始化重建结果
        for i in range(n):  # 逐阶处理泰勒分解特征
            # 每一阶都通过 DBFF 网络进行融合
            f_list.append(self.Net(ir[i], vis[i]))  # ir[i]、vis[i] 是第i阶特征
            # 按 1/i! 权重累加各阶融合结果
            result += (1 / factorial(i)) * f_list[i].to(self.device)  # 加权聚合
        return result  # 返回重建的融合图像

维度追踪：

这一设计保证了多阶泰勒特征能够被有效整合，同时通过阶乘系数的自然衰减，使高阶项（包含更多高频细节）的影响逐步减弱，避免过度放大噪声。

4.4 维度变换与阶乘加权的理论依据

4.4.1 从多阶分解到单通道融合的维度变换

问题的本质：为什么TEA网络输出多个泰勒项（通道维度高），而DBFF融合后却能恢复为单通道高质量图像？

核心原理：泰勒展开的各阶项虽然在特征维度上”平行”，但它们在数学上代表了同一个图像函数在不同”尺度”或”频率”的表示。这类似于傅里叶变换中不同频率分量的组合。

维度变换流程：

(TEA提取的多阶特征):[y0,y1,y2,…,yn]∈RB×1×H×W×n(DBFF各阶融合):F(yiir,yivis)∈RB×1×H×W(阶乘加权聚合):I^=∑i=0n1i!Fi∈RB×1×H×W\begin{aligned} \text{(TEA提取的多阶特征)} &: [y_0, y_1, y_2, \ldots, y_n] \in \mathbb{R}^{B \times 1 \times H \times W} \times n\\ \text{(DBFF各阶融合)} &: F(y_i^{ir}, y_i^{vis}) \in \mathbb{R}^{B \times 1 \times H \times W}\\ \text{(阶乘加权聚合)} &: \hat{I} = \sum_{i=0}^n \frac{1}{i!} F_i \in \mathbb{R}^{B \times 1 \times H \times W} \end{aligned}

阶乘系数的作用：

  1. 数值稳定性：高阶泰勒项往往包含更多噪声，1i!\frac{1}{i!}的指数级衰减（1,1,0.5,0.167,0.042,…1, 1, 0.5, 0.167, 0.042, \ldots）自然压制高阶噪声的影响。

  2. 信息保留：0阶和1阶项的系数最大（1和1），确保基础亮度和梯度信息被充分融合；高阶项虽然权重小，但仍保留细微纹理。

  3. 泰勒逼近的数学性质：根据泰勒定理，当展开阶数足够时，

    f(x)≈∑i=0nf(i)(x0)i!(x−x0)if(x) \approx \sum_{i=0}^n \frac{f^{(i)}(x_0)}{i!}(x-x_0)^i

    其中阶乘分母正是泰勒级数的标准形式。因此，在融合层直接使用1i!\frac{1}{i!}权重是符合数学原理的。

对应代码验证（阶乘衰减可视化）：

# 阶乘系数的衰减规律
from math import factorial
for i in range(5):
    coeff = 1 / factorial(i)
    print(f"第{i}阶系数: {coeff:.4f}")  # 输出: 1.0000, 1.0000, 0.5000, 0.1667, 0.0417
    
# 在融合中的应用
result = torch.zeros([b, c, h, w]).to(device)
for i in range(n):
    weight = 1 / factorial(i)  # 自动衰减系数
    result += weight * f_list[i]  # 高阶项自然被压制

4.4.2 output=1

设计背景：红外和可见光融合的目标图像是灰度图（单通道）或YCbCr空间中的亮度通道（Y），这是因为：

  1. 任务要求：IR-VIS融合主要面向目标检测/分割，这些任务对灰度融合图的判别性要求最高。
  2. 数据集约定：MSRS、TNO等标准数据集的融合参考图均为单通道灰度。
  3. 网络设计：DBFF网络最后一层为ConvBnTanh2d(vis_ch[0], output=1)，显式将多通道特征投影到1维。

维度流转细节：

阶段输入维度处理输出维度
DBFF编码(B,1,H,W)(B, 1, H, W)vis_conv + vis_rgbd1/2(B,48,H,W)(B, 48, H, W)
注意力融合(B,96,H,W)(B, 96, H, W)concat + CBAM(B,96,H,W)(B, 96, H, W)
DBFF解码(B,96,H,W)(B, 96, H, W)decode4/3/2(B,16,H,W)(B, 16, H, W)
输出投影(B,16,H,W)(B, 16, H, W)decode1 (1x1卷积)(B,1,H,W)(B, 1, H, W)
多阶累加(B,1,H,W)×n(B, 1, H, W) \times n按1/i!1/i!加权求和(B,1,H,W)(B, 1, H, W)

对应代码（输出维度的最终确定）：

# network/FusionNet.py
self.decode1 = ConvBnTanh2d(vis_ch[0], output=1)  # 强制输出为1通道
# ConvBnTanh2d
class ConvBnTanh2d(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=3, padding=1, stride=1, dilation=1, groups=1):
        super(ConvBnTanh2d, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, padding=padding, stride=stride, dilation=dilation, groups=groups)
        self.bn = nn.BatchNorm2d(out_channels)
    def forward(self, x):
        return torch.tanh(self.conv(x)) / 2 + 0.5  # Tanh 激活 + 缩放到 [0, 1]

Tanh激活的作用：将特征压缩到[−1,1][-1, 1]，再通过线性变换映射到[0,1][0, 1]，确保融合图像的像素值在合法范围内，这对下游分割/检测网络的输入标准化至关重要。

4.5 网络优化

通过最小化上述损失函数，DBFF 网络能够在红外图像和可见光图像的特征之间找到最佳的融合方式。具体来说，网络会自动调整每个通道的权重，确保图像的亮度和细节得到合理的保留和增强。使用这种优化方法，DBFF 网络能够生成具有高质量细节和目标突出性的融合图像，适合后续的目标检测和图像分割任务。

对应代码（训练中计算融合损失并反向传播）：

# train_Fusion.py
_, ir_y = Net(ir, 2)  # 生成红外泰勒分解特征（返回第0、1、2阶）
_, vis_y = Net(vis, 2)  # 生成可见光泰勒分解特征（返回第0、1、2阶）
result = Model(ir_y, vis_y)  # FusionModel 逆泰勒重构：sum(1/i! * F_i(ir_y[i], vis_y[i]))
loss_int, loss_grad, loss = loss_ft(ir, vis, result)  # 计算融合损失
optimizer.zero_grad()  # 清空梯度缓冲
loss.backward()  # 反向传播：梯度流经FusionModel
optimizer.step()  # 更新FusionModel参数

此时TEA网络参数固定（已在Stage1预训练），DBFF参数通过融合损失的反向传播得到优化，使得多阶融合特征的组合更加贴近物理一致性目标（max(Ir, Ivis)的强度和梯度）。

4.6 网络总结

DBFF 网络通过双分支架构、注意力机制和优化损失函数，有效地融合了红外和可见光图像的多模态特征。该网络能够保持高质量的目标突出和图像细节，在多个视觉任务中表现出色，特别是在低光照和复杂场景中的目标检测和分割任务。

5. 语义分割与目标优化

5.1 语义分割网络

语义分割网络（IBisNet）是T²EA网络的一个关键模块，它利用融合图像的高质量特征来优化目标检测和分割的效果。IBisNet通过专门设计的分割头，将图像中的各个目标区域提取出来，从而提高目标分割的精度。尤其在融合图像中，IBisNet能够更好地处理低光照或遮挡区域，使得目标能够更准确地从复杂背景中分离出来。

通过联合训练，IBisNet不仅优化了分割精度，还进一步增强了融合图像中目标的突出性，确保了在实际应用中，目标检测和目标分割能够在较为复杂的场景下表现出色。

为了进一步优化融合图像的目标突出性，采用IBisNet（改进版的双分支分割网络）进行训练。该网络通过语义分割来细化图像的目标区域，使得目标更易于检测和分割。

5.2 损失函数

联合损失函数包含融合损失（LFL_F）和语义分割损失（LsemanticL_{semantic}），以优化目标检测和分割任务。

6. 任务联合优化（目标感知）

6.1 思路

冻结 TEA（Taylor.pt）与分割模型 BiSeNet，仅微调 FusionModel，使融合图同时满足物理一致性与分割友好性。

6.2 损失函数

实现：FusionLoss 依然做强度/梯度最大对齐，OhemCELoss 在分割分支做难例采样，见 T2EA/loss/Task.py：

Lfusion=∥I^−max⁡(Ivis,Iir)∥1+10∥g(I^)−max⁡(g(Ivis),g(Iir))∥1\mathcal{L}_{\text{fusion}} = \|\hat I - \max(I_{vis}, I_{ir})\|_1 + 10\|g(\hat I)-\max(g(I_{vis}), g(I_{ir}))\|_1

分割采用 OhemCELoss：主输出 LmainL_{\text{main}}，辅助输出 LauxL_{\text{aux}}。

6.3 总损失与调度

T2EA/train_task.py 中：

Ltotal=Lfusion+num (Lmain+0.1 Laux),num=⌊epoch10⌋+1\mathcal{L}_{\text{total}} = \mathcal{L}_{\text{fusion}} + \text{num}\,\big(L_{\text{main}} + 0.1\,L_{\text{aux}}\big),\quad \text{num}=\left\lfloor\frac{\text{epoch}}{10}\right\rfloor+1

epoch 递增的 num 提升任务监督权重，使融合先收敛后适配分割。

6.4 训练设置

50 epoch，Adam(lr=1e-5)、batch=2；MSRS 带标签训练/验证；最佳融合 loss 保存 Fusion_Seg.pt。

端到端前向（train_task.py）：

# 1) 生成融合亮度（冻结 TEA & Seg）
_, ir_y = Taylor(ir, 2); _, vis_y = Taylor(vis_y_channel, 2)
fused_y = FusionModel(ir_y, vis_y)

# 2) 拼回彩色送分割
fused_rgb = YCrCb2RGB(cat(fused_y, Cb, Cr))
pred_main, pred_aux = SegModel(fused_rgb)

# 3) 计算双任务损失
loss_fusion = L_int + 10 L_grad
loss_seg = L_main + 0.1 L_aux (OHEM)
loss_total = loss_fusion + num * loss_seg

这样梯度从分割头回传到 FusionModel，使“目标区域更亮/更清晰”，而 TEA 的可解释分解保持冻结稳定。

7. 实验结果与分析

论文将实验部分组织为：实验准备 → 消融（泰勒层数与融合策略）→ SOTA 对比与泛化 → 下游视觉任务（分割/检测）→ 复杂度分析。

7.1 实验准备

7.1.1 数据集与划分方式

7.1.2 实验环境与关键超参

7.1.3 对比方法与评价指标

7.2 消融研究

7.2.1 泰勒展开层数 n 的选择

为获得更优的泰勒展开特征，论文用 SSIM评估 TEA 输出、用 EN评估最终融合结果，并给出了随 nn 变化的曲线（Fig. 4）。结论非常明确：当 n=2n=2 时，TEA 的 SSIM 与最终融合的 EN 表现最优，且此时输出特征“细节最丰富”，因此后续实验统一取 n=2n=2。

7.2.2 不同融合策略对比

论文讨论了三种融合训练/组合策略，并在 MSRS 的 361 对图像上进行验证：

  1. DBFF + Segmentation（DBFFSeg）：先用式(6)训练，再用式(9)微调 DBFF 参数；
  2. TEA + DBFF（TEADBFF）：对应论文的 Stage 2 策略；
  3. TEA + DBFF + Segmentation（T2EA）：对应论文的 Stage 3 策略（论文最终选择该方案作为报告方法）。

现象与分析：三者都能突出目标，但缺陷不同：

论文指出：Table I 的定量结果与可视化结论一致，T2EA 的综合定量表现最佳。

同时，论文还给出了使用分割方法[76]在融合结果上的 mIoU，并强调 T2EA 的融合结果因 mIoU 最佳而更利于分割任务。最终论文选择 T2EA 作为后续与 SOTA 方法对比的报告方案。

7.3 MSRS 上的 SOTA 方法对比

7.3.1 定性对比

论文在 MSRS 的 “00016N” 与 “00024N” 两幅图像上展示对比结果，并逐一分析各方法在“保细节 vs 突目标”上的权衡：

7.3.2 定量对比

论文将 361 对 MSRS 图像上的客观指标汇总于 Table II，并指出：T2EA 在所有定量指标上取得最优值，进一步说明其在“保细节 + 突目标”上的综合能力更强。

7.4 跨数据集泛化实验（TNO & LLVIP）

7.4.1 实验设置与可视化样例

为评估泛化能力，论文从 TNO Human Factors 与 LLVIP 分别选取 21 对与 177 对红外/可见光图像，进行定性与定量评估。

可视化对比覆盖：TNO 的 “Bunker”“Meeting_016”，LLVIP 的 “230024”“200090”。

7.4.2 定性结论

论文对跨域结果的总结要点如下：

7.4.3 定量结论

论文在 Table III 与 Table IV 中给出了 TNO 与 LLVIP 的平均指标，并指出：T2EA 在 EN 与 SSIM 两项指标上均取得最优，与定性观察一致，从而验证其跨数据集的细节保留能力与泛化优势。

7.5 融合结果用于下游视觉任务

论文强调：仅做融合质量对比还不够，融合图是否“任务友好”同样关键，因此进一步在分割与检测任务上测试融合结果的可用性。

7.5.1 语义分割（IBisNet）

7.5.2 目标检测（YOLOv5）

7.6 计算复杂度与效率

论文在三套数据上统计平均运行时间（秒）与参数量，并在 Table VII 中对比各方法效率：

8. 计算复杂度

T²EA网络的计算复杂度相比纯深度学习融合方法（如U2Fusion）略高，但引入的可解释性、泛化能力和任务友好性使其成本合理。具体而言：

该权衡是值得的，因为额外的计算成本换来了：

  1. 可解释性：每一阶泰勒项有明确的数学含义，便于调试和改进
  2. 泛化性：跨域迁移性能优于黑箱型深度学习模型
  3. 任务友好性：通过联合优化显著提升下游检测/分割精度

9. 结论

本研究提出的T²EA网络，通过目标感知的泰勒展开近似方法，在红外和可见光图像融合中取得了显著的改进：

9.1 主要贡献

  1. 泰勒多阶特征分解：用可解释的数学框架替代黑箱型特征提取，使融合过程可审计、可优化
  2. 阶乘加权逆重构：证明了固定的1i!\frac{1}{i!}权重比学习权重更优，这是理论与实践的完美结合
  3. 双分支注意融合：CBAM在多模态特征融合中的应用显著提升了目标显著性和训练稳定性
  4. 任务联合优化：通过分割梯度反传，使融合结果天然适配下游检测/分割任务

9.2 性能总结

9.3 适用场景与展望

适用场景：

未来方向：

分享文章：
分享到 Telegram通过邮件分享

继续阅读

  1. 【论文阅读 | TPAMI 2025 | RWKVFusion：利用统一语言与掩码引导的高效图像融合网络】论文阅读 · An Efficient Image Fusion Network Exploiting Unifying Language and Mask Guidance
  2. 【论文阅读 | TCSVT 2024 | MMI-Det：探索可见光与红外目标检测的多模态融合】论文阅读 · MMI-Det：探索可见光与红外目标检测的多模态融合
  3. 【论文阅读 | Inf. Fusion 2025 | MS2Fusion：多重光谱状态空间特征融合】论文阅读 · MS2Fusion：多重光谱状态空间特征融合
上一篇
2025.12.23 C语言程序设计上机实习八
下一篇
英语口语测试备考