基于深度学习的滚动轴承故障诊断：CWRU数据预处理与一维CNN实战

简介：基于深度学习的滚动轴承故障诊断方法项目源码与全部数据，是一套面向计算机相关专业毕业设计的完整Python项目。资源针对正在准备毕设、课程设计或期末大作业的学生，也适合需要项目实战的深度学习学习者。压缩包共41个文件，主要类型包括30个mat格式实验数据、6个md说明文档、4个Python源码文件及1个使用说明txt，整体大小约34.87MB。源码覆盖数据读取与预处理、深度网络搭建、模型训练与结果可视化等环节，并附有README和使用说明，项目经过严格调试，解压即可运行。工程内置不同转速工况下的轴承振动数据，可快速复现并进行多工况对比实验。资源已有970人学习下载，既能直接作为毕业设计主体，也可用于课程项目拓展与算法分析，整体实用价值较高。

1. 基于深度学习的滚动轴承故障诊断：拿到 Python 源码包后，第一件事该做数据体检

刚接触基于深度学习的滚动轴承故障诊断的人，最容易踩的第一个坑，是把大量时间花在调网络上，却忽略了数据切分方式。同样一份公开的滚动轴承振动数据，如果对滑窗样本做了错误的随机划分，测试准确率可能虚高到 99%，换成按原始文件划分，立刻回到 90% 上下。这类项目源码和全部数据，看起来是两件事，其实是被数据绑定的一套。它要解决的事情很直接：给轴承的运行状态（正常、内圈、外圈、滚动体故障）打标签，再用 Python 搭一个深度模型把振动信号分类。适合做毕业设计、课程设计或工程预研的人快速拿到可复现结果，也适合想把 CNN 基础吃透的初学者。

2. 数据与预处理：把 CWRU 振动 .mat 切成模型能吃的样本，滑窗长度和划分顺序都在这

2.1 为什么毕业设计里绕不开 CWRU：数据集结构与读取 .mat 的通用写法

滚动轴承故障诊断方向最常用的公开数据，是凯斯西储大学（CWRU）轴承数据中心的数据。这类源码包里通常会把.mat文件放在data/目录下，文件名按“故障位置_故障尺寸_负载”组织，比如内圈_0.007_0.mat表示负载为 0 hp、故障直径 0.007 英寸的内圈故障，normal_0.mat是健康基准信号。CWRU 的驱动端采样率是 12kHz，一个 1024 点的滑窗大约对应 85ms 振动信号。在 1797 rpm 附近，转频约 30Hz，1024 点大约覆盖两圈半的旋转周期，这个尺度对滚动体、内圈、外圈故障是能分辨的。

读取这类.mat文件并不复杂，scipy.io就够用，但字段名在不同版本里不太一样：

import numpy as np import scipy.io as sio def load_cwru_mat(file_path: str, prefer_key: str = "DE") -> np.ndarray: """读取 CWRU 的 .mat 振动信号，返回一维 float32 数组。""" mat = sio.loadmat(file_path) # 有的版本字段名是 DE_time，有的直接叫 DE，尽量都兼容 matched_keys = [ k for k in mat.keys() if k.startswith(prefer_key) or ("DE" in k and "time" in k.lower()) ] if not matched_keys: raise KeyError(f"文件 {file_path} 里没有找到驱动端振动信号字段") # 取第一个匹配字段，通常就是驱动端振动信号 signal = mat[matched_keys[0]].ravel() return signal.astype(np.float32)

这段代码的逻辑是：先在.mat的字段列表里找以DE开头的键，找不到再退一步找包含DE和time的键。CWRU 数据的字段名确实有这两种风格，写通用一点能省掉后续换数据源的麻烦。loadmat 读出来的信号是二维矩阵，ravel()拉平成一维序列，类型转成float32，后面进 PyTorch 就不用再转一次。

2.2 滑窗切片：样本长度、重叠率怎么定，切完怎么防止数据泄漏

原始振动信号是几万到十几万点的长序列，不能直接整段喂给模型。常见做法是滑窗切片，把长信号切成固定长度的样本。样本长度我一般取 1024，既有足够的时域尺度，又不会让输入维度太大。重叠率是另一个要拍的参数：重叠 50%，步长就是 512；重叠 0，步长就是 1024。重叠越大，样本数越多，但相邻窗口的相似度也越高，这是后面数据泄漏的源头之一。

def sliding_window(signal: np.ndarray, sample_length: int = 1024, overlap: float = 0.5) -> np.ndarray: """滑窗切片，返回 (样本数, sample_length) 的二维数组。""" stride = max(1, int(sample_length * (1.0 - overlap))) starts = np.arange(0, len(signal) - sample_length + 1, stride) windows = [signal[s: s + sample_length] for s in starts] return np.stack(windows) # 对某个 .mat 文件切 1024 点、50% 重叠 signal = load_cwru_mat("data/CWRU/内圈_0.007_0.mat") windows = sliding_window(signal, sample_length=1024, overlap=0.5) print(windows.shape) # 大约 (样本数, 1024)

重叠率的取值会影响模型对相位起点的敏感度。50% 重叠是比较稳妥的起点，样本量够，也不会让相邻窗口几乎一样。100% 重叠的步长为 1，样本之间只差一个点，训练集和测试集只要来自同一个原始文件，基本上就是“背答案”，这种操作在毕业设计里一定要避免。实践里我会先把每个.mat文件切成窗口，并把每个窗口所属的文件名记下来，后续划分要按文件名分，而不是把所有窗口混在一起随机分。

2.3 归一化与数据集划分：按文件级划分比随机切分更可靠

数据切完之后，归一化方式直接影响训练稳定性。CWRU 数据在不同负载下振幅差异明显，直接喂原始幅值，模型容易把“幅值大小”当成主要分类依据。我常用的做法是：先按训练集统计每个样本的均值和标准差，做 z-score 归一化，再把它应用到验证集和测试集。注意统计量要从训练集算，不能拿全局统计量去算，否则测试集的信息提前进入了训练流程，严格说也是一种泄漏。

from pathlib import Path from sklearn.model_selection import GroupShuffleSplit def map_label(filename: str) -> int: """把 CWRU 文件名映射成 10 类标签。""" if filename.startswith("normal"): return 0 if "内圈" in filename: base = 0 elif "滚动体" in filename: base = 3 elif "外圈" in filename: base = 6 else: raise ValueError(f"未识别的故障位置: {filename}") if "0.021" in filename: size_index = 2 elif "0.014" in filename: size_index = 1 else: size_index = 0 return base + size_index + 1 def build_dataset(data_dir: Path, sample_length=1024, overlap=0.5): X, y, groups = [], [], [] for mat_path in sorted(data_dir.glob("*.mat")): filename = mat_path.stem if not filename.endswith("_0"): continue # 这里只取 0 hp 负载，先把工况固定下来 label = map_label(filename) signal = load_cwru_mat(str(mat_path)) windows = sliding_window(signal, sample_length, overlap) X.append(windows) y.extend([label] * len(windows)) groups.extend([filename] * len(windows)) # 记录原始文件，按文件划分 X = np.vstack(X) return X, np.array(y), np.array(groups) X, y, groups = build_dataset(Path("data/CWRU")) # 按文件分组切分，同一原始文件的滑动窗口不会被拆到训练/测试两侧 gss = GroupShuffleSplit(n_splits=1, test_size=0.2, random_state=42) train_idx, test_idx = next(gss.split(X, y, groups)) X_train, y_train = X[train_idx], y[train_idx] X_test, y_test = X[test_idx], y[test_idx]

GroupShuffleSplit是这里的关键。它不按单个样本随机切，而是按groups里的原始文件整体切，保证同一个.mat文件的所有窗口要么全在训练集，要么全在测试集。这样测试准确率才有参考价值，尤其是样本重叠率高的时候。

3. 一维 CNN 诊断模型：网络结构怎么选、PyTorch 训练脚本怎么写才不翻车

3.1 先用一维 CNN 而不是 LSTM/Transformer：样本量和时序尺度的选型理由

滚动轴承故障诊断的深度学习模型，最常见的是直接用原始振动信号做输入的一维 CNN。CWRU 这类数据集不大，一个负载下十个类，每类几百个窗口，总共也就两三千个样本。这个量级上，LSTM 和 Transformer 很容易过拟合，因为它们对序列内部的时序依赖建模能力很强，但需要更多数据来约束参数空间。一维 CNN 通过局部卷积核共享权重，参数少，归纳偏置恰好适合“故障冲击在局部波形上周期性出现”这个物理特点。

动手学习深度学习时我也会强调，模型选型首先要看样本量。样本量只有几千的时候，与其上一套复杂网络，不如先把特征提取和分类边界做清楚。第一层用大卷积核覆盖多个振动周期，后续小卷积核细化局部模式，这就是滚动轴承信号分类里最稳的架构。如果后面数据扩到几万样本，再考虑 Transformer 或更深的 ResNet 不迟。

3.2 搭建一个能跑通的最小一维 CNN：卷积层、池化层的参数计算与代码

这个 Cnn1d 结构有两条分支：features负责从原始波形提取特征，classifier负责把特征映射到十个类别。卷积核第一层取 64，而不是常见的 3 或 5，是为了让第一个卷积层在一个样本里覆盖足够长的冲击序列。stride 取 4，先把信号下采样到四分之一长度，后续通道数翻倍，池化层再把长度减半两次。

import torch.nn as nn class Cnn1d(nn.Module): """一维 CNN，输入 (B, 1, 1024)，输出 (B, n_classes)。""" def __init__(self, n_classes: int = 10, sample_length: int = 1024): super().__init__() self.features = nn.Sequential( nn.Conv1d(1, 16, kernel_size=64, stride=4), nn.BatchNorm1d(16), nn.ReLU(inplace=True), nn.MaxPool1d(2), nn.Conv1d(16, 32, kernel_size=7), nn.BatchNorm1d(32), nn.ReLU(inplace=True), nn.MaxPool1d(2), ) # 长度计算：1024 -> (1024-64)//4+1=241 -> 120 -> 114 -> 57 # 第一层输出 241 点，池化得 120；第二层卷积得 114，池化得 57 flattened = 32 * 57 self.classifier = nn.Sequential( nn.Flatten(), nn.Linear(flattened, 128), nn.ReLU(inplace=True), nn.Dropout(0.5), nn.Linear(128, n_classes), ) def forward(self, x): # x: (B, 1, 1024) features = self.features(x) return self.classifier(features)

这里最容易算错的是全连接层的输入维度。卷积输出长度公式是floor((L_in + 2*padding - kernel) / stride + 1)。1024 点输入，第一层卷积后长度是 241，MaxPool 后变 120；第二层卷积 kernel 为 7，120 变 114，MaxPool 后变 57。所以flattened = 32 * 57，32 是第二层卷积的输出通道数。改网络时记得同步改这个数，否则会直接报维度错误。也可以把flattened写成一个函数动态计算，但在固定输入长度下，直接注释清楚更直观。

3.3 训练脚本的四个关键设置：损失函数、优化器、学习率策略与随机种子

多分类任务用CrossEntropyLoss，不需要在模型最后一层手动加 Softmax，CrossEntropyLoss内部已经做了 log-softmax 和 NLLLoss 的合并。优化器用 Adam，学习率取 3e-4 而不是默认的 1e-3。CWRU 数据样本量不大，默认值偏激进，前期容易震荡。配合 StepLR 每 10 个 epoch 把学习率乘 0.5，后面几个 epoch 的 loss 会更稳定。

import random import numpy as np import torch from torch.utils.data import TensorDataset, DataLoader from torch.optim import Adam from torch.optim.lr_scheduler import StepLR import torch.nn as nn def set_seed(seed: int = 42) -> None: random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) torch.cuda.manual_seed_all(seed) torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False set_seed(42) X_train_t = torch.from_numpy(X_train[:, None, :]).float() # (B, 1, 1024) y_train_t = torch.from_numpy(y_train).long() train_ds = TensorDataset(X_train_t, y_train_t) train_loader = DataLoader(train_ds, batch_size=64, shuffle=True, drop_last=True) model = Cnn1d(n_classes=10) optimizer = Adam(model.parameters(), lr=3e-4, weight_decay=1e-4) criterion = nn.CrossEntropyLoss() scheduler = StepLR(optimizer, step_size=10, gamma=0.5) for epoch in range(30): model.train() total_loss, total_num = 0.0, 0 for xb, yb in train_loader: optimizer.zero_grad() out = model(xb) loss = criterion(out, yb) loss.backward() optimizer.step() total_loss += loss.item() * xb.size(0) total_num += xb.size(0) scheduler.step() avg_loss = total_loss / total_num print(f"epoch {epoch + 1:02d}, loss {avg_loss:.4f}")

weight_decay=1e-4是 L2 正则化，能压住过拟合。drop_last=True会在最后一个 batch 不等于 64 时丢掉它，避免 BatchNorm 在 batch 太小的时候统计量不稳定。随机种子这套代码必须放最前面，最好放在独立脚本开头，后面每一章跑结果都要基于同一个种子。PyTorch 在 GPU 上的卷积默认有非确定性算法，cudnn.deterministic = True和benchmark = False就是为了消除这个差异，代价是推理速度略慢，但毕业设计这种规模无所谓。

4. 评估与可视化：混淆矩阵、t-SNE 和超参记录表，让结果可解释、可复现

4.1 混淆矩阵：看哪两个故障类别最容易被混，反推模型感受野够不够

准确率只能给一个总数，答辩时真正能说明问题的是混淆矩阵。CWRU 十类任务里，最常见的混淆出现在同一故障位置的不同尺寸之间，尤其是 0.007 英寸的小故障，特征弱，容易被模型当成正常类别；还有就是内圈故障和滚动体故障，某些转速下冲击频率接近，模型容易混。

from sklearn.metrics import confusion_matrix, classification_report def predict(model, loader): preds, labels = [], [] model.eval() with torch.no_grad(): for xb, yb in loader: out = model(xb) preds.extend(torch.argmax(out, dim=1).cpu().numpy()) labels.extend(yb.cpu().numpy()) return np.array(preds), np.array(labels) y_pred, y_true = predict(model, test_loader) cm = confusion_matrix(y_true, y_pred) print(classification_report(y_true, y_pred, target_names=class_names))

画图时直接用 seaborn 的 heatmap，annot 显示数字，fmt 用d表示整数。看到混淆比较严重的两个类别，先别急着加训练轮数，回头检查第一层卷积核尺寸。如果 kernel_size=64 覆盖了两个冲击周期还分不开，那问题可能出在特征提取的尺度上，可以在第一层后面并联一个不同步长的分支，或者把输入样本长度从 1024 加到 2048，让每个窗口包含更多故障周期。

4.2 t-SNE 特征可视化：把卷积特征压到二维，确认类别可分性

混淆矩阵反映的是最终分类结果，t-SNE 能看到模型在倒数第二层是否已经把类别分开了。t-SNE 是流形学习算法，计算量随样本数快速上涨，没必要跑全量测试集，随机抽 1000 到 2000 个样本就够。抽取时固定随机种子，不然两张图之间没法对比。

from sklearn.manifold import TSNE from sklearn.decomposition import PCA def extract_features(model, loader, max_samples=2000): feats, labels = [], [] model.eval() with torch.no_grad(): for xb, yb in loader: f = model.features(xb) # 用卷积层输出，而不是最终 logits f = torch.flatten(f, 1) feats.append(f.cpu().numpy()) labels.extend(yb.cpu().numpy()) if len(labels) >= max_samples: break return np.vstack(feats)[:max_samples], np.array(labels[:max_samples]) feat_val, lab_val = extract_features(model, test_loader) # 特征维度是 1824，先用 PCA 降到 50 维再跑 t-SNE，速度快且更稳 feat_pca = PCA(n_components=50, random_state=42).fit_transform(feat_val) emb = TSNE(n_components=2, perplexity=30, learning_rate=200, n_iter=1000, random_state=42).fit_transform(feat_pca)

model.features是我这个 Cnn1d 里的卷积特征提取部分。如果你想取分类器中间层的 128 维特征，代码逻辑也一样，只是把 forward 内部改一下，让中间结果暴露出来。t-SNE 的结果里如果十个类别聚成了十个清晰的团，说明模型学到的是结构化的故障特征；如果类别交织在一起，多半是卷积层感受野或者样本长度不合适。

4.3 超参记录表：毕业设计答辩前必须补上的复现信息

毕业设计最容易被追问的就是“这个结果怎么复现”。我习惯在项目里维护一张超参记录表，不用很花哨，Markdown 表格就够。重点不是罗列所有默认参数，而是把影响结果的关键项记录下来，包括数据划分方式、每类样本数、滑窗参数、优化器和学习率策略。

做这张表的另一个好处是排查问题时能快速定位。比如换了优化器之后准确率掉了 2%，如果表里记录了原来用的优化器和学习率，可以立刻回退，不用重新翻训练日志。

5. 避坑与常见问题排查：数据泄漏、随机性玄学和跨工况翻车的 5 条真实记录

5.1 现象：训练准确率 99%，测试准确率却崩了 —— 数据泄漏是头号嫌疑

随机划分后训练和测试都接近 99%，改成按文件划分后测试准确率掉到 90% 以下，这是典型的数据泄漏。原因在于同一个.mat文件的滑窗样本之间高度相似，重叠率越高相似度越大，模型记住的是“这个文件的波形细节”，而不是“这类故障的共性特征”。它压根没做泛化，测试集里的窗口只是换了个起点位置的同一段信号。

解决方法是 2.3 节里的GroupShuffleSplit，按原始文件分组。更严格的做法是连分组都不够，得保证训练和测试来自不同负载或不同传感器位置，那是 5.4 的跨工况场景，这里先把文件级划分做对。

5.2 现象：同一份代码跑两次结果不一样 —— 随机种子和设备差异

PyTorch 默认的权重初始化、DataLoader 的 shuffle、Dropout 都依赖随机数，单靠torch.manual_seed管住一部分。CPU 上跑几次差别不明显，GPU 上如果不设置torch.backends.cudnn.deterministic = True，即便同一个种子，cuDNN 的算法选择也会带来微小差异，累积起来就是准确率波动 1% 到 2%。

解决方法是把 3.3 节的set_seed放在脚本最前面，并且在训练日志里记下 PyTorch 和 CUDA 版本。很多人会漏掉cudnn.benchmark = False，这个开关默认是 True，PyTorch 会在运行时自动尝试不同卷积算法选最快的，但“最快”在不同批次下可能不一样，结果自然不稳定。

5.3 现象：测试准确率卡在 85% 上不去 —— 优化器和学习率调节

如果 loss 曲线在训练中段开始震荡，准确率长期停在某个值附近，最常见的是学习率不合适。默认 Adam 的 1e-3 在 CWRU 这种小样本上偏大，前期 loss 降得快，后期在最优解附近反复横跳。改成 3e-4 通常能看到 loss 平稳下降；如果再配上余弦退火调度器，后期会收敛得更干净。

optimizer = Adam(model.parameters(), lr=3e-4) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( optimizer, T_max=30, eta_min=1e-6 )

T_max设成和总 epoch 数一致，让学习率从 3e-4 平滑降到 1e-6。如果降到 85% 后训练集准确率已经 99%，测试集不动，那是过拟合，应该优先加 Dropout 或者调大weight_decay；如果训练集本身也只有 90%，那是欠拟合，需要加大模型容量或增加输入长度，方向完全不同。

5.4 现象：训练一切正常、换负载工况就翻车 —— 跨工况泛化的边界

CWRU 数据有 0、1、2、3 hp 四挡负载，很多毕业设计只用了 0 hp 训练和测试，答辩时被评委问“换一挡负载还能不能跑”就卡住了。负载变化会影响转速和振动幅度，模型在 0 hp 上学到的幅值特征在 3 hp 上不成立，准确率可能下降 15% 甚至更多。这不一定是模型 bug，而是数据分布变了。

常见做法有两种：一种是把多挡负载混进训练集，让模型见过不同工况，但这只能做插值；另一种是把它当成一个迁移学习问题，用 0 hp 的模型作为预训练，用少量 3 hp 数据微调最后几层。毕业设计里至少要把这层边界讨论清楚，别把单工况结果包装成通用能力。

5.5 现象：训练 loss 直接变 NaN —— 输入数据与梯度检查顺序

NaN 出现的原因按概率排序：输入里本身有 NaN、幅值过大导致梯度爆炸、学习率太高。CWRU 的.mat文件绝大多数是干净的，但下载到一半出问题或者某些版本转换工具会引入空值。训练前做一次数值检查，比训练中排查节省太多时间。

if not np.isfinite(X_train).all(): raise ValueError("训练数据里存在 NaN 或无穷值，先检查数据预处理") # 训练循环里加梯度裁剪，防止个别 batch 梯度爆炸 torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0)

梯度裁剪是“后悔药”，加了之后 loss 偶尔冲高也能被拉回来。但不要一上来就依赖它，先检查数据和归一化，再调学习率。如果所有检查都做完了还会 NaN，再把卷积核尺寸和步长打印出来看看。数据标准化我建议 z-score 而不是 min-max，min-max 对异常值非常敏感，一个离群点就可能把整个样本推到 0 或 1 两端。

6. 从源码包到可交付：项目目录组织、复现清单和真实工业场景的最后一公里

6.1 让同学和评委能复现的最小项目目录与 README 模板

源码包能不能被顺利跑通，不在代码多漂亮，而在目录结构是否清晰。我交付这类项目时会按下面这样组织：

bearing_fault_diagnosis/ ├── data/CWRU/ # 原始 .mat，只读不写 ├── preprocess.py # 滑窗切片、标签映射、归一化 ├── model.py # Cnn1d 定义 ├── train.py # 训练入口，保存 best.pt ├── evaluate.py # 混淆矩阵、t-SNE、分类报告 ├── config.yaml # 超参集中管理 └── requirements.txt

config.yaml把样本长度、重叠率、学习率、epoch 都收进去，train.py里只读配置文件，这样跑实验时不用改代码。README 里写清楚三行复现命令：python preprocess.py、python train.py、python evaluate.py。大多数评审人和同学拿到源码包，能按这三步复现出论文里的准确率，这个项目就成功了一半。数据预处理脚本要保存切分时的groups信息，别只在内存里划分完就扔掉，隔两天再跑结果对不上会很痛苦。

6.2 从 CWRU 到真实车间：载荷波动、转速变化与传感器噪声的差距

CWRU 的数据是在实验室恒速、恒定负载环境下采集的，故障尺寸也是加工好的标准损伤，信号干净，类别边界清晰。真实车间的轴承诊断要复杂得多：转速不恒定、负载波动、传感器安装位置不同、环境噪声干扰，还有大量工况是“未知故障”而不是预设的几个类别。

所以我不建议把 CWRU 上的效果直接等同于工业可用性。更稳妥的路径是把 CWRU 作为算法验证基线，确认模型结构和训练流程没问题，然后去采集现场数据的少量样本做微调。转速变化大时，可以考虑引入转速归一化，或者把信号先做阶比跟踪再进模型，否则一维 CNN 学到的时间尺度会随转速漂移。这不是一个毕业设计必须做完整的事，但把它想清楚，面试或答辩时会更有底气。

我现在接到这类项目，第一件事不是打开train.py读网络结构，而是先写一个数据统计脚本，看每个类别的样本量、每个.mat文件长度、有没有 NaN、重叠后相邻窗口的相似度是多大。数据没体检完之前，模型再先进也不值得信。希望这份从数据到模型、从评估到交付的落地过程，能帮你省掉几个晚上的调试时间。希望帮到你。

本文还有配套的精品资源，点击获取