Pytorch-CNN轴承故障一维信号分类(二)

往期精彩内容:

Python-凯斯西储大学(CWRU)轴承数据解读与分类处理

Pytorch-LSTM轴承故障一维信号分类(一)-CSDN博客

三十多个开源数据集 | 故障诊断再也不用担心数据集了!

Python轴承故障诊断 (一)短时傅里叶变换STFT-CSDN博客

Python轴承故障诊断 (二)连续小波变换CWT-CSDN博客

Python轴承故障诊断 (三)经验模态分解EMD-CSDN博客

Python轴承故障诊断 (四)基于EMD-CNN的故障分类-CSDN博客

Python轴承故障诊断 (五)基于EMD-LSTM的故障分类-CSDN博客

Python轴承故障诊断 (六)基于EMD-Transformer的故障分类-CSDN博客

前言

本文基于凯斯西储大学(CWRU)轴承数据,先经过数据预处理进行数据集的制作和加载,最后通过Pytorch实现CNN模型一维卷积和二维卷积对故障数据的分类,然后进行对比。凯斯西储大学轴承数据的详细介绍可以参考下文:

Python-凯斯西储大学(CWRU)轴承数据解读与分类处理_凯斯西储大学轴承数据集介绍-CSDN博客

1 数据集制作与加载

1.1 导入数据

参考之前的文章,进行故障10分类的预处理,凯斯西储大学轴承数据10分类数据集:

第一步,导入十分类数据

import numpy as np
import pandas as pd
from scipy.io import loadmat

file_names = ['0_0.mat','7_1.mat','7_2.mat','7_3.mat','14_1.mat','14_2.mat','14_3.mat','21_1.mat','21_2.mat','21_3.mat']

for file in file_names:
    # 读取MAT文件
    data = loadmat(f'matfiles\\{file}')
    print(list(data.keys()))

第二步,读取MAT文件驱动端数据


# 采用驱动端数据
data_columns = ['X097_DE_time', 'X105_DE_time', 'X118_DE_time', 'X130_DE_time', 'X169_DE_time',
                'X185_DE_time','X197_DE_time','X209_DE_time','X222_DE_time','X234_DE_time']
columns_name = ['de_normal','de_7_inner','de_7_ball','de_7_outer','de_14_inner','de_14_ball','de_14_outer','de_21_inner','de_21_ball','de_21_outer']
data_12k_10c = pd.DataFrame()
for index in range(10):
    # 读取MAT文件
    data = loadmat(f'matfiles\\{file_names[index]}')
    dataList = data[data_columns[index]].reshape(-1)
    data_12k_10c[columns_name[index]] = dataList[:119808]  # 121048  min: 121265
print(data_12k_10c.shape)
data_12k_10c

第三步,制作数据集

train_set、val_set、test_set 均为按照7:2:1划分训练集、验证集、测试集,最后保存数据

第四步,制作训练集和标签


# 制作数据集和标签
import torch

# 这些转换是为了将数据和标签从Pandas数据结构转换为PyTorch可以处理的张量,
# 以便在神经网络中进行训练和预测。

def make_data_labels(dataframe):
    '''
        参数 dataframe: 数据框
        返回 x_data: 数据集     torch.tensor
            y_label: 对应标签值  torch.tensor
    '''
    # 信号值
    x_data = dataframe.iloc[:,0:-1]
    # 标签值
    y_label = dataframe.iloc[:,-1]
    x_data = torch.tensor(x_data.values).float()
    y_label = torch.tensor(y_label.values.astype('int64')) # 指定了这些张量的数据类型为64位整数,通常用于分类任务的类别标签
    return x_data, y_label

# 加载数据
train_set = load('train_set')
val_set = load('val_set')
test_set = load('test_set')

# 制作标签
train_xdata, train_ylabel = make_data_labels(train_set)
val_xdata, val_ylabel = make_data_labels(val_set)
test_xdata, test_ylabel = make_data_labels(test_set)
# 保存数据
dump(train_xdata, 'trainX_1024_10c')
dump(val_xdata, 'valX_1024_10c')
dump(test_xdata, 'testX_1024_10c')
dump(train_ylabel, 'trainY_1024_10c')
dump(val_ylabel, 'valY_1024_10c')
dump(test_ylabel, 'testY_1024_10c')

1.2 数据加载,训练数据、测试数据分组,数据分batch

import torch
from joblib import dump, load
import torch.utils.data as Data
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
# 参数与配置
torch.manual_seed(100)  # 设置随机种子,以使实验结果具有可重复性
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 有GPU先用GPU训练

# 加载数据集
def dataloader(batch_size, workers=2):
    # 训练集
    train_xdata = load('trainX_1024_10c')
    train_ylabel = load('trainY_1024_10c')
    # 验证集
    val_xdata = load('valX_1024_10c')
    val_ylabel = load('valY_1024_10c')
    # 测试集
    test_xdata = load('testX_1024_10c')
    test_ylabel = load('testY_1024_10c')

    # 加载数据
    train_loader = Data.DataLoader(dataset=Data.TensorDataset(train_xdata, train_ylabel),
                                   batch_size=batch_size, shuffle=True, num_workers=workers, drop_last=True)
    val_loader = Data.DataLoader(dataset=Data.TensorDataset(val_xdata, val_ylabel),
                                 batch_size=batch_size, shuffle=True, num_workers=workers, drop_last=True)
    test_loader = Data.DataLoader(dataset=Data.TensorDataset(test_xdata, test_ylabel),
                                  batch_size=batch_size, shuffle=True, num_workers=workers, drop_last=True)
    return train_loader, val_loader, test_loader

batch_size = 32
# 加载数据
train_loader, val_loader, test_loader = dataloader(batch_size)

2 CNN-2D分类模型和训练、评估

2.1 定义CNN-2d分类模型

注意:输入数据进行了堆叠 ,把一个1*1024 的序列 进行划分堆叠成形状为1 * 32 * 32, 就使输入序列的长度降下来了,(channels, seq_length, H_in)

2.2 定义模型参数


# 定义模型参数
batch_size = 32
# 先用浅层试一试
conv_arch = ((2, 32), (1, 64), (1, 128))  
input_channels = 1
num_classes = 10
model = CNN2DModel(conv_arch, num_classes, batch_size)  
# 定义损失函数和优化函数
model = model.to(device)
loss_function = nn.CrossEntropyLoss(reduction='sum')  # loss
learn_rate = 0.0003
optimizer = torch.optim.Adam(model.parameters(), learn_rate)  # 优化器

2.3 模型结构

2.4 模型训练

50个epoch,准确率将近97%,CNN-2D网络分类模型效果良好。

2.5 模型评估


# 模型 测试集 验证  
import torch.nn.functional as F
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 有GPU先用GPU训练

# 加载模型
model =torch.load('best_model_cnn2d.pt')
# model = torch.load('best_model_cnn2d.pt', map_location=torch.device('cpu'))

# 将模型设置为评估模式
model.eval()
# 使用测试集数据进行推断
with torch.no_grad():
    correct_test = 0
    test_loss = 0
    for test_data, test_label in test_loader:
        test_data, test_label = test_data.to(device), test_label.to(device)
        test_output = model(test_data)
        probabilities = F.softmax(test_output, dim=1)
        predicted_labels = torch.argmax(probabilities, dim=1)
        correct_test += (predicted_labels == test_label).sum().item()
        loss = loss_function(test_output, test_label)
        test_loss += loss.item()

test_accuracy = correct_test / len(test_loader.dataset)
test_loss = test_loss / len(test_loader.dataset)
print(f'Test Accuracy: {test_accuracy:4.4f}  Test Loss: {test_loss:10.8f}')

Test Accuracy: 0.9313  Test Loss: 0.04866932

3 CNN-1D分类模型和训练、评估

3.1 定义CNN-1d分类模型

注意:与2d模型的信号长度堆叠不同,CNN-1D模型直接在一维序列上进行卷积池化操作;形状为(batch,H_in, seq_length),利用平均池化 使CNN-1D和CNN-2D模型最后输出维度相同,保持着相近的参数量。

3.2 定义模型参数

# 定义模型参数
batch_size = 32
# 先用浅层试一试
conv_arch = ((2, 32), (1, 64), (1, 128))  
input_channels = 1
num_classes = 10
model = CNN1DModel(conv_arch, num_classes, batch_size)  
# 定义损失函数和优化函数
model = model.to(device)
loss_function = nn.CrossEntropyLoss(reduction='sum')  # loss
learn_rate = 0.0003
optimizer = torch.optim.Adam(model.parameters(), learn_rate)  # 优化器

3.3 模型结构

3.4 模型训练

50个epoch,准确率将近95%,CNN-1D网络分类模型效果良好。

3.5 模型评估

# 模型 测试集 验证  
import torch.nn.functional as F
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 有GPU先用GPU训练

# 加载模型
model =torch.load('best_model_cnn1d.pt')
# model = torch.load('best_model_cnn2d.pt', map_location=torch.device('cpu'))

# 将模型设置为评估模式
model.eval()
# 使用测试集数据进行推断
with torch.no_grad():
    correct_test = 0
    test_loss = 0
    for test_data, test_label in test_loader:
        test_data, test_label = test_data.to(device), test_label.to(device)
        test_output = model(test_data)
        probabilities = F.softmax(test_output, dim=1)
        predicted_labels = torch.argmax(probabilities, dim=1)
        correct_test += (predicted_labels == test_label).sum().item()
        loss = loss_function(test_output, test_label)
        test_loss += loss.item()

test_accuracy = correct_test / len(test_loader.dataset)
test_loss = test_loss / len(test_loader.dataset)
print(f'Test Accuracy: {test_accuracy:4.4f}  Test Loss: {test_loss:10.8f}')

Test Accuracy: 0.9185  Test Loss: 0.14493044

4 模型对比

对比CNN-2D模型 和CNN-1D模型:

模型

参数量

训练集准确率

验证集准确率

测试集准确率

CNN1D

615654

96.56

94.64

91.85

CNN2D

683430

98.38

96.88

93.13

由于CNN-2D模型参数量稍微多一点,所以模型表现得也略好一点,适当调整参数,两者模型准确率相近。但是CNN-2D推理速度要快于CNN-1D,在轴承故障数据集上,应该更考虑CNN-2D模型在堆叠后的一维信号上进行卷积池化。

注意调整参数:

  • 可以适当增加 CNN层数 和每层神经元个数,微调学习率;

  • 增加更多的 epoch (注意防止过拟合)

  • 可以改变一维信号堆叠的形状(设置合适的长度和维度)

代码、数据整理如下:

图片

对于一维CNN轴承故障诊断,可以使用PyTorch来实现。以下是一个示例代码,可以用于训练和测试一个基本的一维CNN模型来诊断轴承故障。 ```python import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader, Dataset # 定义一维CNN模型 class CNNModel(nn.Module): def __init__(self): super(CNNModel, self).__init__() self.conv1 = nn.Conv1d(in_channels=1, out_channels=16, kernel_size=3) self.relu = nn.ReLU() self.pool = nn.MaxPool1d(kernel_size=2) self.fc = nn.Linear(16, 2) def forward(self, x): x = self.conv1(x) x = self.relu(x) x = self.pool(x) x = torch.flatten(x, 1) x = self.fc(x) return x # 定义训练集和测试集的数据加载器 class BearingDataset(Dataset): def __init__(self, data, labels): self.data = data self.labels = labels def __getitem__(self, index): return self.data[index], self.labels[index] def __len__(self): return len(self.data) # 定义训练函数 def train(model, train_loader, criterion, optimizer, device): model.train() running_loss = 0.0 for inputs, labels in train_loader: inputs = inputs.to(device) labels = labels.to(device) optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() * inputs.size(0) epoch_loss = running_loss / len(train_loader.dataset) return epoch_loss # 定义测试函数 def test(model, test_loader, criterion, device): model.eval() running_loss = 0.0 correct = 0 total = 0 with torch.no_grad(): for inputs, labels in test_loader: inputs = inputs.to(device) labels = labels.to(device) outputs = model(inputs) loss = criterion(outputs, labels) running_loss += loss.item() * inputs.size(0) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() epoch_loss = running_loss / len(test_loader.dataset) accuracy = correct / total return epoch_loss, accuracy # 加载数据并进行预处理 train_data = torch.Tensor(...) # 训练集数据,维度为 [样本数, 特征数, 信号长度] train_labels = torch.LongTensor(...) # 训练集标签,维度为 [样本数] test_data = torch.Tensor(...) # 测试集数据,维度为 [样本数, 特征数, 信号长度] test_labels = torch.LongTensor(...) # 测试集标签,维度为 [样本数] train_dataset = BearingDataset(train_data, train_labels) test_dataset = BearingDataset(test_data, test_labels) train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False) # 定义设备 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 创建模型实例 model = CNNModel() model.to(device) # 定义损失函数和优化器 criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) # 训练和测试模型 num_epochs = 10 for epoch in range(num_epochs): train_loss = train(model, train_loader, criterion, optimizer, device) test_loss, test_accuracy = test(model, test_loader, criterion, device) print(f"Epoch {epoch+1}/{num_epochs} - Train Loss: {train_loss:.4f} - Test Loss: {test_loss:.4f} - Test Accuracy: {test_accuracy:.4f}") ``` 请注意,上述代码只是一个简单的示例,你需要根据你的数据和问题适当进行修改和调整。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值