深度残差收缩网络:原理及第三方代码复现

6 阅读4分钟

在处理含有较高背景噪声的输入数据时,深度卷积神经网络和残差网络提取的特征中往往会混入噪声相关成分,从而干扰判别性特征的学习。针对这一问题,论文《Deep Residual Shrinkage Networks for Fault Diagnosis》发表于《IEEE Transactions on Industrial Informatics》(2020年第16卷第7期),提出了深度残差收缩网络(Deep Residual Shrinkage Networks, DRSN)。该方法将软阈值化(Soft Thresholding)作为非线性变换层嵌入深度残差网络(ResNet)的构建单元中,并利用子网络自适应地估计阈值,以在网络前向传播过程中抑制噪声相关特征。


一、技术原理

深度残差收缩网络的核心是将信号去噪领域常用的软阈值化函数与深度残差网络的构建单元相结合,并通过注意力机制风格的轻量级子网络实现阈值的端到端学习。

1. 软阈值化(Soft Thresholding)

软阈值化在传统信号处理中通常用于将绝对值低于某一阈值的近零特征置零。给定输入特征 xx 与正阈值 τ\tau,软阈值化函数定义为:

y={x−τ,x>τ0,−τ≤x≤τx+τ,x<−τy = \begin{cases} x - \tau, & x > \tau \\ 0, & -\tau \le x \le \tau \\ x + \tau, & x < -\tau \end{cases}

与ReLU激活函数直接将所有负值特征置零不同,软阈值化仅将位于 [−τ,τ][-\tau, \tau] 区间内的近零特征置零,同时向零收缩并保留了绝对值较大的正特征与负特征。

软阈值化函数关于输入 xx 的导数为:

∂y∂x={1,x>τ0,−τ≤x≤τ1,x<−τ\frac{\partial y}{\partial x} = \begin{cases} 1, & x > \tau \\ 0, & -\tau \le x \le \tau \\ 1, & x < -\tau \end{cases}

其导数仅取 00 或 11,这一性质在反向传播过程中有助于避免梯度消失和梯度爆炸问题。

2. 残差收缩构建单元与网络结构

在经典残差网络的基础上,论文提出了两种残差收缩构建单元(Residual Shrinkage Building Unit, RSBU),分别对应通道共享阈值的 DRSN-CS 和通道独立阈值的 DRSN-CW。二者的构建单元及整体网络结构如图4所示。

QQ20261117-221345.jpg (原论文Fig. 4,其中 C,W,1C, W, 1 分别表示特征图的通道数、宽度和高度,KK 表示卷积层中卷积核的数量,MM 表示全连接层中的神经元数量。)

(1)RSBU-CS与DRSN-CS(通道共享阈值)

如图4(a)所示,RSBU-CS的主干部分采用预激活(Pre-activation)结构,输入特征图(尺寸为 C×W×1C \times W \times 1)依次经过两组“批归一化(BN)— ReLU激活 — 卷积(Conv)”操作后,得到中间特征图 xx。随后,通过一条分支子网络自动计算用于软阈值化的阈值 τ\tau:

  1. 对特征图 xx 取绝对值 ∣x∣|x|,并经过全局平均池化(GAP)得到尺寸为 C×1×1C \times 1 \times 1 的一维向量;
  2. 将该向量送入一个两层全连接网络(第一层神经元数 M=CM=C,中间经过BN和ReLU,第二层神经元数 M=1M=1),输出标量 zz;
  3. 通过Sigmoid函数将 zz 缩放至 (0,1)(0, 1) 区间,得到缩放因子 α\alpha: α=11+e−z\alpha = \frac{1}{1 + e^{-z}}
  4. 将上述GAP结果在通道维度上再次求平均(等价于对 ∣x∣|x| 的所有通道与空间位置求均值),并与 α\alpha 相乘,得到最终阈值 τ\tau: τ=α⋅average⁡i,j,c∣xi,j,c∣\tau = \alpha \cdot \operatorname{average}_{i,j,c} |x_{i,j,c}|

这种设计保证了阈值 τ\tau 恒为正值,且不会超过特征图绝对值的最大值(避免软阈值化后特征全部变为零)。利用 τ\tau 对特征图 xx 的所有通道执行软阈值化后,再与恒等快捷连接(Identity Shortcut)进行逐元素相加,即完成一个 RSBU-CS 的计算。将多个RSBU-CS堆叠,并在末端接入BN、ReLU、GAP以及用于分类输出的全连接层(FC),即构成图4(b)所示的DRSN-CS。

(2)RSBU-CW与DRSN-CW(通道独立阈值)

与所有通道共享单一阈值 τ\tau 的RSBU-CS不同,RSBU-CW为特征图的每个通道分别估计一个独立的阈值,其结构如图4(c)所示:

  1. 同样对中间特征图 xx 取绝对值 ∣x∣|x| 并进行GAP,得到尺寸为 C×1×1C \times 1 \times 1 的通道均值向量;
  2. 在两层全连接网络中,第二层全连接层的神经元数量设置为与输入特征图通道数相等(即 M=CM=C),输出尺寸为 C×1×1C \times 1 \times 1 的向量 zz;
  3. 对向量 zz 的每个元素应用Sigmoid函数,得到各个通道的缩放因子 αc\alpha_c: αc=11+e−zc\alpha_c = \frac{1}{1 + e^{-z_c}}
  4. 将 αc\alpha_c 与对应通道的特征绝对值均值相乘,得到第 cc 个通道的阈值 τc\tau_c: τc=αc⋅average⁡i,j∣xi,j,c∣\tau_c = \alpha_c \cdot \operatorname{average}_{i,j} |x_{i,j,c}|

随后使用各通道对应的 τc\tau_c 对 xx 进行软阈值化,并与恒等快捷连接相加。堆叠多个RSBU-CW即构成图4(d)所示的DRSN-CW。对于步长为2或通道数加倍的下采样构建单元,其主体构造与标准残差单元相同,并在快捷连接路径上通过尺寸为 11、步长为 22 的卷积调整特征图维度以实现相加。


二、PyTorch代码复现

原论文针对高度为 11 的一维信号输入(特征图形状为 C×W×1C \times W \times 1),在PyTorch中可直接采用一维卷积 nn.Conv1d 与 nn.BatchNorm1d(张量形状为 (batch_size, channels, width))进行复现。

实现要点说明:

  1. 软阈值化操作:利用恒等式 y=sign⁡(x)⋅max⁡(∣x∣−τ,0)y = \operatorname{sign}(x) \cdot \max(|x| - \tau, 0) 实现,在 PyTorch 中可表示为 torch.sign(x) * F.relu(torch.abs(x) - tau),其前向计算与反向梯度均与上文公式一致;
  2. 快捷连接维度对齐:当构建单元的步长不为1或输入输出通道数不一致时,在快捷连接分支使用 kernel_size=1 的卷积对齐张量尺寸;
  3. 整体网络配置:参考论文结构(输入 -> 卷积降采样 -> 多组步长交替为2和1的 RSBU -> BN -> ReLU -> GAP -> FC),实现同时支持 DRSN-CS 和 DRSN-CW 的完整模型。
import torch
import torch.nn as nn
import torch.nn.functional as F


class SoftThresholding(nn.Module):
    """软阈值化层"""
    def __init__(self):
        super().__init__()

    def forward(self, x: torch.Tensor, tau: torch.Tensor) -> torch.Tensor:
        # x: (B, C, W)
        # tau: (B, 1, 1) for CS or (B, C, 1) for CW
        return torch.sign(x) * F.relu(torch.abs(x) - tau)


class RSBU_CS(nn.Module):
    """通道共享阈值的残差收缩构建单元 (Residual Shrinkage Building Unit with Channel-Shared Thresholds)"""
    def __init__(self, in_channels: int, out_channels: int, kernel_size: int = 3, stride: int = 1):
        super().__init__()
        padding = kernel_size // 2

        self.bn1 = nn.BatchNorm1d(in_channels)
        self.relu1 = nn.ReLU(inplace=True)
        self.conv1 = nn.Conv1d(in_channels, out_channels, kernel_size, stride=stride, padding=padding)

        self.bn2 = nn.BatchNorm1d(out_channels)
        self.relu2 = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv1d(out_channels, out_channels, kernel_size, stride=1, padding=padding)

        # 阈值估计子网络: FC(M=C) -> BN -> ReLU -> FC(M=1) -> Sigmoid
        self.fc = nn.Sequential(
            nn.Linear(out_channels, out_channels),
            nn.BatchNorm1d(out_channels),
            nn.ReLU(inplace=True),
            nn.Linear(out_channels, 1),
            nn.Sigmoid(),
        )
        self.shrinkage = SoftThresholding()

        # 若维度发生变化,通过 1x1 卷积对齐快捷连接
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Conv1d(in_channels, out_channels, kernel_size=1, stride=stride)
        else:
            self.shortcut = nn.Identity()

    def forward(self, x_in: torch.Tensor) -> torch.Tensor:
        residual = self.shortcut(x_in)

        x = self.conv1(self.relu1(self.bn1(x_in)))
        x = self.conv2(self.relu2(self.bn2(x)))

        # 计算通道共享阈值 tau
        x_abs = torch.abs(x)
        abs_mean = torch.mean(x_abs, dim=2)                # GAP: (B, C)
        alpha = self.fc(abs_mean)                          # (B, 1)
        global_abs_mean = torch.mean(abs_mean, dim=1, keepdim=True)  # (B, 1)
        tau = (alpha * global_abs_mean).unsqueeze(-1)      # (B, 1, 1)

        out = self.shrinkage(x, tau)
        return out + residual


class RSBU_CW(nn.Module):
    """通道独立阈值的残差收缩构建单元 (Residual Shrinkage Building Unit with Channel-Wise Thresholds)"""
    def __init__(self, in_channels: int, out_channels: int, kernel_size: int = 3, stride: int = 1):
        super().__init__()
        padding = kernel_size // 2

        self.bn1 = nn.BatchNorm1d(in_channels)
        self.relu1 = nn.ReLU(inplace=True)
        self.conv1 = nn.Conv1d(in_channels, out_channels, kernel_size, stride=stride, padding=padding)

        self.bn2 = nn.BatchNorm1d(out_channels)
        self.relu2 = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv1d(out_channels, out_channels, kernel_size, stride=1, padding=padding)

        # 阈值估计子网络: FC(M=C) -> BN -> ReLU -> FC(M=C) -> Sigmoid
        self.fc = nn.Sequential(
            nn.Linear(out_channels, out_channels),
            nn.BatchNorm1d(out_channels),
            nn.ReLU(inplace=True),
            nn.Linear(out_channels, out_channels),
            nn.Sigmoid(),
        )
        self.shrinkage = SoftThresholding()

        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Conv1d(in_channels, out_channels, kernel_size=1, stride=stride)
        else:
            self.shortcut = nn.Identity()

    def forward(self, x_in: torch.Tensor) -> torch.Tensor:
        residual = self.shortcut(x_in)

        x = self.conv1(self.relu1(self.bn1(x_in)))
        x = self.conv2(self.relu2(self.bn2(x)))

        # 计算通道独立阈值 tau_c
        x_abs = torch.abs(x)
        abs_mean = torch.mean(x_abs, dim=2)                # GAP: (B, C)
        alpha = self.fc(abs_mean)                          # (B, C)
        tau = (alpha * abs_mean).unsqueeze(-1)             # (B, C, 1)

        out = self.shrinkage(x, tau)
        return out + residual


class DRSN(nn.Module):
    """深度残差收缩网络 (支持DRSN-CS与DRSN-CW)"""
    def __init__(self, in_channels: int = 1, num_classes: int = 8, mode: str = "CW"):
        super().__init__()
        if mode.upper() == "CS":
            block = RSBU_CS
        elif mode.upper() == "CW":
            block = RSBU_CW
        else:
            raise ValueError("mode 必须为 'CS' 或 'CW'")

        self.conv_in = nn.Conv1d(in_channels, 4, kernel_size=3, stride=2, padding=1)

        self.blocks = nn.Sequential(
            block(4, 4, kernel_size=3, stride=2),
            block(4, 4, kernel_size=3, stride=1),
            block(4, 8, kernel_size=3, stride=2),
            block(8, 8, kernel_size=3, stride=1),
            block(8, 16, kernel_size=3, stride=2),
            block(16, 16, kernel_size=3, stride=1),
        )

        self.bn_out = nn.BatchNorm1d(16)
        self.relu_out = nn.ReLU(inplace=True)
        self.gap = nn.AdaptiveAvgPool1d(1)
        self.fc_out = nn.Linear(16, num_classes)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.conv_in(x)
        x = self.blocks(x)
        x = self.relu_out(self.bn_out(x))
        x = self.gap(x).squeeze(-1)
        out = self.fc_out(x)
        return out


if __name__ == "__main__":
    # 构造形状为 (batch_size, channels, length) 的测试张量
    dummy_input = torch.randn(4, 1, 2048)

    model_cs = DRSN(in_channels=1, num_classes=8, mode="CS")
    model_cw = DRSN(in_channels=1, num_classes=8, mode="CW")

    out_cs = model_cs(dummy_input)
    out_cw = model_cw(dummy_input)

    print("DRSN-CS 输出形状:", out_cs.shape)  # torch.Size([4, 8])
    print("DRSN-CW 输出形状:", out_cw.shape)  # torch.Size([4, 8])

参考文献

Deep Residual Shrinkage Networks for Fault Diagnosis[J]. IEEE Transactions on Industrial Informatics, 2020.