Shiki

整体模型架构 - BearingNet

class BearingNet(nn.Module):
    def __init__(self, fs, centers_hz, ncls=4, in_ch_input=1):
        super().__init__()
        self.Cin = in_ch_input
        self.C = len(centers_hz)
        self.chan_se = ChannelSE(r=8)                    # 通道注意力
        self.fb = MechanismFilterBank(fs, centers_hz)    # 机理滤波器组
        self.gate = GateExplain(groups=4)                # 机理门控
        self.norm = nn.GroupNorm(num_groups=_best_gn_groups(self.C), num_channels=self.C, affine=False)
        self.enc = FeatNet1D(in_ch=self.C)              # 特征提取器
        self.cls = Classifier(128, ncls)                 # 分类器

数据流向：

输入信号 [B,C,T] → ChannelSE → MechanismFilterBank → GateExplain → GroupNorm → FeatNet1D → Classifier
                                    ↓
                               8个机理滤波器

1. 通道注意力机制 (ChannelSE)

设计思想

• 问题：多通道信号（DE/FE/BA）质量不均，需要自适应权衡
• 解决：学习每个通道的重要性权重，突出信息丰富的通道

实现细节

class ChannelSE(nn.Module):
    def __init__(self, r=8):  # r=压缩比
        super().__init__()
        self.r = r
        # 动态构建线性层（避免通道数未知问题）
        self.fc1 = None  # C → C//r
        self.fc2 = None  # C//r → C

工作流程：

def forward(self, x):  # x: [B,C,T]
    # 1. 全局平均池化：提取每个通道的全局统计信息
    w = x.mean(dim=-1)  # [B,C,T] → [B,C]
    
    # 2. 压缩-激励：学习通道间的相互依赖关系
    w = F.relu(self.fc1(w))      # [B,C] → [B,C//r]
    w = torch.sigmoid(self.fc2(w)) # [B,C//r] → [B,C]
    
    # 3. 重新校准：将权重应用到原始特征
    return x * w.unsqueeze(-1), w  # 广播到时间维度

2. 机理滤波器组 (MechanismFilterBank)

设计思想

这是模型的核心创新，基于轴承故障的物理机理设计：

• BPFI频段：内圈故障特征频率及其谐波
• BPFO频段：外圈故障特征频率及其谐波
• BSF频段：滚动体故障特征频率及其谐波
• FTF频段：保持架频率及其谐波

频率计算

def bearing_freqs(rpm, n, d, D, theta_deg=0.0):
    fr = float(rpm) / 60.0                    # 转频
    c = (d / D) * math.cos(math.radians(theta_deg))
    bpfo = 0.5 * n * fr * (1 - c)           # 外圈故障频率
    bpfi = 0.5 * n * fr * (1 + c)           # 内圈故障频率  
    bsf  = (D/(2*d)) * fr * (1 - c**2)      # 滚动体故障频率
    ftf  = 0.5 * fr * (1 - c)               # 保持架频率
    return fr, bpfo, bpfi, bsf, ftf

滤波器实现

class MechanismFilterBank(nn.Module):
    def __init__(self, fs, centers_hz, Q=12):
        # centers_hz: [bpfi, bpfi*2, bpfo, bpfo*2, bsf, bsf*2, ftf, ftf*2]
        self.M = len(centers_hz)  # 通常是8个滤波器
        L = 129  # FIR滤波器长度
        
        base = []
        for c in centers_hz:
            bw = c / Q  # 带宽 = 中心频率/品质因子
            f1 = max(5.0, c - bw/2.0)
            f2 = c + bw/2.0
            # 设计带通FIR滤波器
            h = sig.firwin(L, [f1, f2], pass_zero=False, fs=fs)
            base.append(h)
        
        # 将滤波器核注册为buffer（不参与梯度更新）
        self.register_buffer("kern", torch.from_numpy(np.stack(base,0)[:,None,:]))

滤波过程：

def forward(self, x_mono):  # x_mono: [B,1,T] 单通道信号
    # 1D卷积实现并行滤波
    y = F.conv1d(F.pad(x_mono, (self.pad,0)), self.kern, groups=1)
    return y  # [B,M,T] M=8个频段的响应

3. 机理门控 (GateExplain)

设计思想

• 问题：不同故障类型的特征能量分布在不同的机理频段
• 解决：学习4个机理组（BPFI/BPFO/BSF/FTF）的重要性权重
• 可解释性：门控权重直接反映了模型对不同故障机理的关注度

实现细节

class GateExplain(nn.Module):
    def __init__(self, groups=4):
        super().__init__()
        # 4个可学习的门控参数
        self.alpha = nn.Parameter(torch.ones(groups))
        self.groups = groups
    
    def forward(self, x):  # x: [B,8,T]
        # 软门控：确保权重和为1
        g = torch.softmax(self.alpha, dim=0)  # [4]
        
        # 将8个滤波器分为4组
        m_per = max(1, 8 // 4)  # 每组2个滤波器
        outs = []
        for i in range(4):
            s, e = i*m_per, min((i+1)*m_per, 8)
            xi = x[:, s:e, :] * g[i]  # 按组加权
            outs.append(xi)
        
        return torch.cat(outs, 1), g  # [B,8,T], [4]

物理意义：

• g[0]：BPFI组权重（内圈故障敏感度）
• g[1]：BPFO组权重（外圈故障敏感度）
• g[2]：BSF组权重（滚动体故障敏感度）
• g[3]：FTF组权重（保持架相关敏感度）

4. 特征提取器 (FeatNet1D)

设计思想

使用1D CNN提取时序特征，适配经过机理滤波后的8通道信号：

class FeatNet1D(nn.Module):
    def __init__(self, in_ch=8):
        super().__init__()
        self.net = nn.Sequential(
            # 第1层：7×1卷积，步长2，降采样
            nn.Conv1d(in_ch, 32, 7, 2, 3), 
            nn.BatchNorm1d(32), 
            nn.ReLU(), 
            nn.MaxPool1d(2),  # 进一步降采样
            
            # 第2层：5×1卷积，提取局部模式
            nn.Conv1d(32, 64, 5, 1, 2), 
            nn.BatchNorm1d(64), 
            nn.ReLU(), 
            nn.MaxPool1d(2),
            
            # 第3层：3×1卷积，高级特征
            nn.Conv1d(64, 128, 3, 1, 1), 
            nn.BatchNorm1d(128), 
            nn.ReLU(),
            
            # 全局平均池化：时间维度 → 标量
            nn.AdaptiveAvgPool1d(1)
        )

特征演化：

[B,8,T] → [B,32,T/4] → [B,64,T/16] → [B,128,1] → [B,128]

5. 分类器 (Classifier)

简单的线性分类头：

class Classifier(nn.Module):
    def __init__(self, d=128, ncls=4):
        super().__init__()
        self.fc = nn.Linear(d, ncls)  # 128 → 4类

6. 数据预处理与输入适配

ensure_bct函数

确保输入维度一致性：

def ensure_bct(x, C=None):
    if x.dim()==1: x = x.unsqueeze(0).unsqueeze(0)    # [T] → [1,1,T]
    elif x.dim()==2: x = x.unsqueeze(1)               # [B,T] → [B,1,T]  
    elif x.dim()==3: pass                             # [B,C,T] 保持
    return x.contiguous()

完整前向传播

def forward(self, x):
    # 1. 维度标准化
    x = ensure_bct(x)  # → [B,C,T]
    
    # 2. 通道注意力
    x_se, w = self.chan_se(x)  # → [B,C,T], [B,C]
    
    # 3. 多通道融合为单通道
    x_mono = x_se.sum(dim=1, keepdim=True)  # → [B,1,T]
    
    # 4. 机理滤波器组
    y = self.fb(x_mono)  # → [B,8,T]
    
    # 5. 机理门控
    y, gate_w = self.gate(y)  # → [B,8,T], [4]
    
    # 6. 组归一化
    y = self.norm(y)
    
    # 7. 特征提取
    h = self.enc(y)  # → [B,128]
    
    # 8. 分类
    logits = self.cls(h)  # → [B,4]
    
    return logits, h, gate_w, w

7. 模型优势总结

物理机理驱动

• 滤波器中心频率基于轴承几何参数精确计算
• 不是黑盒学习，而是有明确物理意义的特征提取

多尺度注意力

• 通道级：ChannelSE自适应选择最优传感器通道
• 频段级：GateExplain学习不同故障机理的重要性

端到端可解释

• Gate权重直接反映模型对BPFI/BPFO/BSF/FTF的关注度
• 通道权重揭示不同传感器位置的贡献
• 整个决策过程透明可追溯

迁移友好

• 特征提取器学习通用的故障模式表示
• 机理滤波器基于物理规律，跨域稳定
• 分离的编码器-分类器结构便于域适应

这种设计巧妙地将信号处理理论、故障诊断机理和深度学习技术相结合，既保证了模型的可解释性，又提升了跨域泛化能力。