基于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所示。

图4 RSBU-CS与RSBU-CW基本单元及DRSN-CS与DRSN-CW整体网络结构
1. 软阈值化非线性层
在信号去噪中,软阈值化函数用于将绝对值低于阈值 \(\tau\)(\(\tau > 0\))的近零特征置零,同时保留较大正负特征的幅值趋势:
对应的等价紧凑形式为 \(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)):
- 对主干输出特征图 \(x\) 取绝对值后进行全局平均池化(GAP),得到 \(C \times 1 \times 1\) 的一维向量;
- 一方面,将该向量送入一个两层全连接(FC)子网络(第一层神经元数 \(M = C\),经BN与ReLU后接入第二层,神经元数 \(M = 1\)),输出标量 \(z\),再经 Sigmoid 函数映射至 \((0, 1)\) 区间,得到缩放因子 \(\alpha = \frac{1}{1 + e^{-z}}\);
- 另一方面,对
Absolute + GAP的输出沿通道维度求均值(Average),等价于计算 \(\operatorname{average}_{i,j,c}|x_{i,j,c}|\); - 将两者相乘得到所有通道共享的阈值 \(\tau = \alpha \cdot \operatorname{average}_{i,j,c}|x_{i,j,c}|\),并对 \(x\) 执行软阈值化,最后与恒等快捷连接(Identity shortcut)逐元素相加。
-
RSBU-CW(通道独立阈值,图4(c)):
- 同样先对 \(x\) 计算
Absolute + GAP,得到各通道的绝对值均值向量 \(\operatorname{average}_{i,j}|x_{i,j,c}|\)(尺寸 \(C \times 1 \times 1\)); - 两层FC子网络的第二层神经元数设置为通道数 \(M = C\),经Sigmoid映射后得到长度为 \(C\) 的缩放参数向量 \(\alpha_c = \frac{1}{1 + e^{-z_c}}\);
- 将缩放向量与
Absolute + GAP的输出按通道逐元素相乘,得到每个通道独立的阈值 \(\tau_c = \alpha_c \cdot \operatorname{average}_{i,j}|x_{i,j,c}|\); - 在软阈值化层中对各通道分别收缩,再与恒等快捷连接相加。
- 同样先对 \(x\) 计算
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.

浙公网安备 33010602011771号