基于JAX的深度残差收缩网络程序实现

深度残差收缩网络(Deep Residual Shrinkage Networks, DRSN)是一种用于强噪声信号特征学习的改进型残差网络,其核心机制是在残差单元中嵌入可自动学习阈值的软阈值化层。该方法由发表在《IEEE Transactions on Industrial Informatics》上的论文《Deep Residual Shrinkage Networks for Fault Diagnosis》提出,并给出了通道共享阈值(DRSN-CS)和通道独立阈值(DRSN-CW)两种具体结构。本文将结合原论文的网络架构设计,介绍如何利用JAX及Flax框架完成这两类模型的程序实现。


一、网络结构概述

DRSN在经典深度残差网络(ResNet)的基础上,将传统的残差基本单元(RBU)替换为残差收缩基本单元(RSBU)。根据阈值作用粒度的不同,网络分为DRSN-CS与DRSN-CW两种架构,其基本单元与整体结构如图4所示。

ScreenShot_2026-11-18_205916_233

图4 RSBU-CS与RSBU-CW基本单元及DRSN-CS与DRSN-CW整体网络结构

1. 软阈值化非线性层

在信号去噪中,软阈值化函数用于将绝对值低于阈值 \(\tau\)(\(\tau > 0\))的近零特征置零,同时保留较大正负特征的幅值趋势:

\[y = \begin{cases} x - \tau, & x > \tau \\ 0, & -\tau \le x \le \tau \\ x + \tau, & x < -\tau \end{cases} \]

对应的等价紧凑形式为 \(y = \operatorname{sign}(x) \cdot \max(|x| - \tau, 0)\)。该函数关于输入 \(x\) 的导数在 \(|x| > \tau\) 时为 \(1\),在 \(-\tau \le x \le \tau\) 时为 \(0\),在反向传播过程中有助于抑制梯度消失与梯度爆炸问题。

2. 残差收缩基本单元(RSBU-CS与RSBU-CW)

在原论文的1D信号输入场景下,特征图张量记为 \(C \times W \times 1\)(通道数 \(C\)、宽度 \(W\)、高度 \(1\))。如图4(a)和图4(c)所示,两种基本单元的主干分支结构相同,均包含预激活形式的“批归一化(BN)— ReLU — 一维卷积(Conv)— BN — ReLU — Conv”,其输出特征图记为 \(x\)。区别在于用于估计阈值 \(\tau\) 的子网络结构:

  • RSBU-CS(通道共享阈值,图4(a)):

    1. 对主干输出特征图 \(x\) 取绝对值后进行全局平均池化(GAP),得到 \(C \times 1 \times 1\) 的一维向量;
    2. 一方面,将该向量送入一个两层全连接(FC)子网络(第一层神经元数 \(M = C\),经BN与ReLU后接入第二层,神经元数 \(M = 1\)),输出标量 \(z\),再经 Sigmoid 函数映射至 \((0, 1)\) 区间,得到缩放因子 \(\alpha = \frac{1}{1 + e^{-z}}\);
    3. 另一方面,对 Absolute + GAP 的输出沿通道维度求均值(Average),等价于计算 \(\operatorname{average}_{i,j,c}|x_{i,j,c}|\);
    4. 将两者相乘得到所有通道共享的阈值 \(\tau = \alpha \cdot \operatorname{average}_{i,j,c}|x_{i,j,c}|\),并对 \(x\) 执行软阈值化,最后与恒等快捷连接(Identity shortcut)逐元素相加。
  • RSBU-CW(通道独立阈值,图4(c)):

    1. 同样先对 \(x\) 计算 Absolute + GAP,得到各通道的绝对值均值向量 \(\operatorname{average}_{i,j}|x_{i,j,c}|\)(尺寸 \(C \times 1 \times 1\));
    2. 两层FC子网络的第二层神经元数设置为通道数 \(M = C\),经Sigmoid映射后得到长度为 \(C\) 的缩放参数向量 \(\alpha_c = \frac{1}{1 + e^{-z_c}}\);
    3. 将缩放向量与 Absolute + GAP 的输出按通道逐元素相乘,得到每个通道独立的阈值 \(\tau_c = \alpha_c \cdot \operatorname{average}_{i,j}|x_{i,j,c}|\);
    4. 在软阈值化层中对各通道分别收缩,再与恒等快捷连接相加。

3. 整体网络拓扑

如图4(b)和图4(d)所示,DRSN-CS与DRSN-CW的宏观拓扑一致,由输入层、初始卷积层、堆叠的RSBU模块以及分类输出头组成。按照论文实验部分的网络超参数配置(输入长度 \(W = 2048\)、类别数 \(8\)),各层结构与特征图尺寸如下:

模块名称 堆叠数量 输出特征图尺寸 (\(C \times W \times 1\)) 卷积核配置 \((K, \text{width}, \text{stride})\)
Input 1 \(1 \times 2048 \times 1\) —
Conv 1 \(4 \times 1024 \times 1\) 4个卷积核,宽度 3,步长 2
RSBU (/2) 1 \(4 \times 512 \times 1\) 4个卷积核,宽度 3,首层步长 2
RSBU 3 \(4 \times 512 \times 1\) 4个卷积核,宽度 3,步长 1
RSBU (/2) 1 \(8 \times 256 \times 1\) 8个卷积核,宽度 3,首层步长 2
RSBU 3 \(8 \times 256 \times 1\) 8个卷积核,宽度 3,步长 1
RSBU (/2) 1 \(16 \times 128 \times 1\) 16个卷积核,宽度 3,首层步长 2
RSBU 3 \(16 \times 128 \times 1\) 16个卷积核,宽度 3,步长 1
BN, ReLU, GAP 1 \(16\) 沿宽度维度全局平均池化
FC 1 \(8\) 全连接分类层

注:当RSBU的步长为2或输出通道数发生变化时,快捷连接分支需进行相应的维度对齐(如使用步长为2的 \(1 \times 1\) 卷积投影或平均池化配合通道补零),以保证逐元素相加时张量形状一致。


二、基于JAX/Flax的程序实现

本节使用 jax、flax.linen 与 optax 实现上述网络结构。需要注意张量维度的表示约定:原论文以 \(C \times W \times 1\) 描述单个样本的特征图,而在 Flax 的一维卷积 nn.Conv 中,默认输入张量格式为 (batch, width, channels),因此高度维度 1 可省略,输入张量形状对应为 (batch, 2048, 1)。

1. 基础组件与软阈值化函数

from typing import Literal
import jax
import jax.numpy as jnp
from flax import linen as nn
import optax


def soft_thresholding(x: jnp.ndarray, tau: jnp.ndarray) -> jnp.ndarray:
    """
    软阈值化算子: y = sign(x) * max(|x| - tau, 0)
    x: 形状为 (B, W, C) 的特征张量
    tau: 形状为 (B, 1, 1) [CS模式] 或 (B, 1, C) [CW模式] 的阈值张量
    """
    return jnp.sign(x) * jnp.maximum(jnp.abs(x) - tau, 0.0)

2. 残差收缩基本单元(RSBU)

下面通过 mode 参数('cs' 或 'cw')统一封装 RSBU-CS 与 RSBU-CW。当输入输出尺寸或通道数不一致时,快捷连接采用 \(1 \times 1\) 卷积进行投影匹配。

class RSBU(nn.Module):
    channels: int
    kernel_size: int = 3
    strides: int = 1
    mode: Literal["cs", "cw"] = "cw"

    @nn.compact
    def __call__(self, x: jnp.ndarray, training: bool = True) -> jnp.ndarray:
        in_channels = x.shape[-1]
        shortcut = x

        # 主干分支: BN -> ReLU -> Conv -> BN -> ReLU -> Conv
        y = nn.BatchNorm(use_running_average=not training)(x)
        y = nn.relu(y)
        y = nn.Conv(
            features=self.channels,
            kernel_size=(self.kernel_size,),
            strides=(self.strides,),
            padding="SAME",
        )(y)

        y = nn.BatchNorm(use_running_average=not training)(y)
        y = nn.relu(y)
        y = nn.Conv(
            features=self.channels,
            kernel_size=(self.kernel_size,),
            strides=(1,),
            padding="SAME",
        )(y)

        # 阈值估计子网络
        # 1) Absolute + GAP: 沿宽度维度 (axis=1) 求绝对值均值, 输出形状 (B, C)
        abs_gap = jnp.mean(jnp.abs(y), axis=1)

        # 2) 两层全连接网络计算缩放因子 alpha
        fc_out_dim = 1 if self.mode == "cs" else self.channels
        z = nn.Dense(features=self.channels)(abs_gap)
        z = nn.BatchNorm(use_running_average=not training)(z)
        z = nn.relu(z)
        z = nn.Dense(features=fc_out_dim)(z)
        alpha = nn.sigmoid(z)  # (B, 1) 或 (B, C)

        # 3) 计算阈值 tau
        if self.mode == "cs":
            # 通道共享: 对 abs_gap 沿通道维度求均值, 得到 (B, 1)
            avg_abs = jnp.mean(abs_gap, axis=1, keepdims=True)
            tau = alpha * avg_abs  # (B, 1)
        else:
            # 通道独立: 逐通道相乘, 得到 (B, C)
            tau = alpha * abs_gap  # (B, C)

        # 扩展宽度维度以便与 y (B, W, C) 进行广播运算
        tau = tau[:, None, :]
        y = soft_thresholding(y, tau)

        # 若发生下采样或通道数改变, 对快捷连接分支进行维度对齐
        if self.strides != 1 or in_channels != self.channels:
            shortcut = nn.Conv(
                features=self.channels,
                kernel_size=(1,),
                strides=(self.strides,),
                padding="SAME",
            )(shortcut)

        return y + shortcut

3. 整体网络架构(DRSN)

按照前文表中的层级配置构建完整的 DRSN 类,通过 mode="cs" 或 mode="cw" 即可分别实例化 DRSN-CS 与 DRSN-CW。

class DRSN(nn.Module):
    num_classes: int = 8
    mode: Literal["cs", "cw"] = "cw"

    @nn.compact
    def __call__(self, x: jnp.ndarray, training: bool = True) -> jnp.ndarray:
        # 初始卷积层: Conv(4, 3, /2) -> (B, 1024, 4)
        y = nn.Conv(
            features=4,
            kernel_size=(3,),
            strides=(2,),
            padding="SAME",
        )(x)

        # Stage 1: 1个带下采样的 RSBU + 3个恒等维度 RSBU -> (B, 512, 4)
        y = RSBU(channels=4, kernel_size=3, strides=2, mode=self.mode)(y, training=training)
        for _ in range(3):
            y = RSBU(channels=4, kernel_size=3, strides=1, mode=self.mode)(y, training=training)

        # Stage 2: 1个带下采样的 RSBU + 3个恒等维度 RSBU -> (B, 256, 8)
        y = RSBU(channels=8, kernel_size=3, strides=2, mode=self.mode)(y, training=training)
        for _ in range(3):
            y = RSBU(channels=8, kernel_size=3, strides=1, mode=self.mode)(y, training=training)

        # Stage 3: 1个带下采样的 RSBU + 3个恒等维度 RSBU -> (B, 128, 16)
        y = RSBU(channels=16, kernel_size=3, strides=2, mode=self.mode)(y, training=training)
        for _ in range(3):
            y = RSBU(channels=16, kernel_size=3, strides=1, mode=self.mode)(y, training=training)

        # 尾部输出层: BN -> ReLU -> GAP -> FC
        y = nn.BatchNorm(use_running_average=not training)(y)
        y = nn.relu(y)
        y = jnp.mean(y, axis=1)  # GAP -> (B, 16)
        logits = nn.Dense(features=self.num_classes)(y)  # (B, 8)

        return logits

4. 模型初始化与训练步实现

在训练配置上,原论文采用了带动量(0.9)的 SGD 优化器、L2 正则化(系数 1e-4)以及交叉熵损失函数。在 JAX/Flax 中,由于 BatchNorm 存在需要原地更新的统计量 batch_stats,前向调用时需显式传入 mutable=['batch_stats'],并在 train_step 中同步返回更新后的状态。

def create_train_state(rng: jax.Array, mode: Literal["cs", "cw"] = "cw"):
    model = DRSN(num_classes=8, mode=mode)
    dummy_input = jnp.ones((1, 2048, 1), dtype=jnp.float32)
    variables = model.init(rng, dummy_input, training=True)

    # 分段常数学习率调度: 0.1 -> 0.01 -> 0.001 (对应论文 40/40/20 epoch 策略)
    # 此处 steps_per_epoch 可按实际数据集大小设定
    steps_per_epoch = 250
    schedule = optax.piecewise_constant_schedule(
        init_value=0.1,
        boundaries_and_scales={
            40 * steps_per_epoch: 0.1,
            80 * steps_per_epoch: 0.1,
        },
    )
    optimizer = optax.sgd(learning_rate=schedule, momentum=0.9)
    opt_state = optimizer.init(variables["params"])
    return model, variables["params"], variables["batch_stats"], optimizer, opt_state


def compute_loss_and_metrics(
    params,
    batch_stats,
    model: DRSN,
    x: jnp.ndarray,
    labels: jnp.ndarray,
    weight_decay: float = 1e-4,
    training: bool = True,
):
    variables = {"params": params, "batch_stats": batch_stats}
    if training:
        logits, updates = model.apply(
            variables, x, training=True, mutable=["batch_stats"]
        )
        new_batch_stats = updates["batch_stats"]
    else:
        logits = model.apply(variables, x, training=False)
        new_batch_stats = batch_stats

    # 交叉熵损失
    ce_loss = optax.softmax_cross_entropy_with_integer_labels(logits, labels).mean()
    # L2 正则化惩罚项
    l2_loss = 0.5 * sum(
        jnp.sum(jnp.square(p)) for p in jax.tree_util.tree_leaves(params)
    )
    total_loss = ce_loss + weight_decay * l2_loss

    acc = jnp.mean(jnp.argmax(logits, axis=-1) == labels)
    return total_loss, (acc, new_batch_stats)


def make_train_step(model: DRSN, optimizer: optax.GradientTransformation):
    @jax.jit
    def train_step(params, batch_stats, opt_state, x, labels):
        grad_fn = jax.value_and_grad(compute_loss_and_metrics, has_aux=True)
        (loss, (acc, new_batch_stats)), grads = grad_fn(
            params, batch_stats, model, x, labels, training=True
        )
        updates, new_opt_state = optimizer.update(grads, opt_state, params)
        new_params = optax.apply_updates(params, updates)
        return new_params, new_batch_stats, new_opt_state, loss, acc

    return train_step


if __name__ == "__main__":
    rng = jax.random.PRNGKey(0)
    model, params, batch_stats, optimizer, opt_state = create_train_state(rng, mode="cw")
    train_step = make_train_step(model, optimizer)

    # 构造随机批次数据验证前向与反向传播通路
    x_batch = jax.random.normal(rng, (128, 2048, 1))
    y_batch = jax.random.randint(rng, (128,), minval=0, maxval=8)

    params, batch_stats, opt_state, loss, acc = train_step(
        params, batch_stats, opt_state, x_batch, y_batch
    )
    print(f"Loss: {float(loss):.4f}, Accuracy: {float(acc):.4f}")

三、小结

上述代码在Flax中以纯函数式状态管理的方式复现了DRSN-CS与DRSN-CW的完整网络结构。在工程实现时,主要需注意两点:一是将论文中的 \(C \times W \times 1\) 特征描述映射为JAX一维卷积所需的 (B, W, C) 维度顺序,并据此调整全局平均池化与阈值张量的广播轴;二是在执行 @jax.jit 编译的训练步时,确保 BatchNorm 的 batch_stats 状态随梯度更新一并传出,以保证推理阶段统计量的准确性。


参考文献

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

posted @ 2026-11-18 20:59  翼下之峰  阅读(3)  评论(0)    收藏  举报