Pytorch实战：基于鲸鱼WOA优化1DCNN的轴承故障诊断
目录
0.引言
1.关键点
2.WOA优化1DCNN超参数实战
2.1 数据准备
2.2 1DCNN故障诊断建模
2.3 采用WOA优化1DCNN超参数
0.引言
采用1DCNN进行轴承故障诊断建模，并基于鲸鱼优化算法WOA对1DCNN的超参数进行优化，以实现更高的精度。建立一个两层的1DCNN，优化的参数包括学习率、训练次数、batchsize，卷积层1的核数量、核大小，池化层1的核大小，卷积层2的核数量、核大小，池化层2的核大小，全连接层1、全连接层2的节点数，总共11个超参数。
1.关键点
在Pytorch中，卷积层与池化层由于无法像tensorflow中一样，将padding设置成“same”模式，因此每一层的输出要手动计算，并且与全连接层的输入节点参数也要精确计算出来，否则节点数不匹配，容易报错。而我们采用优化算法来进行优化的，每一层的参数不是固定的，所以第一步是实现像tensorflow中一样，将卷积层与池化层设计成padding具备“same”模式的结构，代码如下：
class Conv1d(torch.nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, bias=True, padding_layer=nn.ReflectionPad1d):
super().__init__()
ka = kernel_size // 2
kb = ka - 1 if kernel_size % 2 == 0 else ka
self.net = torch.nn.Sequential(
padding_layer((ka,kb)),
nn.Conv1d(in_channels, out_channels, kernel_size, bias=bias)
)
def forward(self, x):
return self.net(x)
class MaxPool1d(torch.nn.Module):
def __init__(self, kernel_size):
super().__init__()
self.net=torch.nn.MaxPool1d(kernel_size=kernel_size)
def forward(self, x):
x1=self.net(x)
padsize=x.size(2)-x1.size(2)
ka = padsize // 2
kb = ka if padsize % 2 == 0 else ka+1
return F.pad(x1,(ka,kb))
net1=Conv1d(1,3,10)#输入通道、输出通道数、卷积核大小
net2=MaxPool1d(3)#池化核大小
dummy=torch.rand(16,1,101)
print(net1(dummy).size())
print(net1(dummy).size())
# torch.Size([16, 3, 101])
# torch.Size([16, 3, 101])可以看出，无论怎么设置输入的长度，与卷积、池化参数，他的输出长度都是与输入的长度都是一样的。
采用上述代码设计一个两层的1DCNN，代码如下
class ConvNet(torch.nn.Module):
def __init__(self,num_input,nk1,k1,pk1,nk2,k2,pk2,fc1,fc2, num_classes):
super(ConvNet, self).__init__()
# 1D-CNN 输入1*1024振动信号
self.net = nn.Sequential(
Conv1d(1,nk1 , kernel_size=k1),
MaxPool1d(kernel_size=pk1),
nn.ReLU(),
nn.BatchNorm1d(nk1),
Conv1d(nk1, nk2, kernel_size=k2),
MaxPool1d(kernel_size=pk2),
nn.ReLU(),
nn.BatchNorm1d(nk2)
)
self.feature_extractor = nn.Sequential(
nn.Linear(num_input*nk2, fc1),
nn.ReLU(),
# nn.Dropout(0.5),
nn.Linear(fc1, fc2))
self.classifier=nn.Sequential(
nn.ReLU(),
nn.Linear(fc2, num_classes),
)
def forward(self,x):
x= self.net(x)#进行卷积+池化操作提取振动信号特征
x=x.view(-1, x.size(1)*x.size(2))
feature = self.feature_extractor(x)#将上述特征拉伸为向量输入进全连接层实现分类
logits = self.classifier(feature)#将上述特征拉伸为向量输入进全连接层实现分类
probas = F.softmax(logits, dim=1)# softmax分类器
return logits,probas
net=ConvNet(101,8,3,3,16,3,4,128,128,10)
dummy=torch.rand(16,1,101)
print(net(dummy)[0].size())
# torch.Size([16, 10])
net=ConvNet(111,8,7,3,16,7,4,256,128,10)
dummy=torch.rand(16,1,111)
print(net(dummy)[0].size())
# torch.Size([16, 10])
可以看出，无论怎么设置输入的长度，与卷积、池化参数，他的输出都是16x10（16是batchsize，10是类别数）
2.WOA优化1DCNN超参数实战
2.1 数据准备
数据依旧采用48k的驱动端轴承故障诊断数据，每种故障样本数为200，每个样本的长度为1024，按照7：2：1的比例划分训练集、验证集、测试集
#coding:utf-8
from scipy.io import loadmat
from scipy.io import savemat
import numpy as np
import os
from sklearn import preprocessing # 0-1编码
from sklearn.model_selection import StratifiedShuffleSplit # 随机划分，保证每一类比例相同
def prepro(d_path, length=864, number=1000, normal=True, rate=[0.7, 0.2, 0.1], enc=True, enc_step=28):
"""对数据进行预处理,返回train_X, train_Y, valid_X, valid_Y, test_X, test_Y样本.
:param d_path: 源数据地址
:param length: 信号长度，默认2个信号周期，864
:param number: 每种信号个数,总共10类,默认每个类别1000个数据
:param normal: 是否标准化.True,Fales.默认True
:param rate: 训练集/验证集/测试集比例.默认[0.5,0.25,0.25],相加要等于1
:param enc: 训练集、验证集是否采用数据增强.Bool,默认True
:param enc_step: 增强数据集采样顺延间隔
:return: Train_X, Train_Y, Valid_X, Valid_Y, Test_X, Test_Y
```
import preprocess.preprocess_nonoise as pre
train_X, train_Y, valid_X, valid_Y, test_X, test_Y = pre.prepro(d_path=path,
length=864,
number=1000,
normal=False,
rate=[0.5, 0.25, 0.25],
enc=True,
enc_step=28)
```
"""
# 获得该文件夹下所有.mat文件名
filenames = os.listdir(d_path)
def capture(original_path):
"""读取mat文件，返回字典
:param original_path: 读取路径
:return: 数据字典
"""
files = {}
for i in filenames:
# 文件路径
file_path = os.path.join(d_path, i)
file = loadmat(file_path)
file_keys = file.keys()
for key in file_keys:
if 'DE' in key:
files[i] = file[key].ravel()
return files
def slice_enc(data, slice_rate=rate[1] + rate[2]):
"""将数据切分为前面多少比例，后面多少比例.
:param data: 单挑数据
:param slice_rate: 验证集以及测试集所占的比例
:return: 切分好的数据
"""
keys = data.keys()
Train_Samples = {}
Test_Samples = {}
for i in keys:
slice_data = data[i]
all_lenght = len(slice_data)
end_index = int(all_lenght * (1 - slice_rate))
samp_train = int(number * (1 - slice_rate)) # 700
Train_sample = []
Test_Sample = []
if enc:
enc_time = length // enc_step
samp_step = 0 # 用来计数Train采样次数
for j in range(samp_train):
random_start = np.random.randint(low=0, high=(end_index - 2 * length))
label = 0
for h in range(enc_time):
samp_step += 1
random_start += enc_step
sample = slice_data[random_start: random_start + length]
Train_sample.append(sample)
if samp_step == samp_train:
label = 1
break
if label:
break
else:
for j in range(samp_train):
random_start = np.random.randint(low=0, high=(end_index - length))
sample = slice_data[random_start:random_start + length]
Train_sample.append(sample)
# 抓取测试数据
for h in range(number - samp_train):
random_start = np.random.randint(low=end_index, high=(all_lenght - length))
sample = slice_data[random_start:random_start + length]
Test_Sample.append(sample)
Train_Samples[i] = Train_sample
Test_Samples[i] = Test_Sample
return Train_Samples, Test_Samples
# 仅抽样完成，打标签
def add_labels(train_test):
X = []
Y = []
label = 0
for i in filenames:
x = train_test[i]
X += x
lenx = len(x)
Y += [label] * lenx
label += 1
return X, Y
# one-hot编码
def one_hot(Train_Y, Test_Y):
Train_Y = np.array(Train_Y).reshape([-1, 1])
Test_Y = np.array(Test_Y).reshape([-1, 1])
Encoder = preprocessing.OneHotEncoder()
Encoder.fit(Train_Y)
Train_Y = Encoder.transform(Train_Y).toarray()
Test_Y = Encoder.transform(Test_Y).toarray()
Train_Y = np.asarray(Train_Y, dtype=np.int32)
Test_Y = np.asarray(Test_Y, dtype=np.int32)
return Train_Y, Test_Y
def scalar_stand(Train_X, Test_X):
# 用训练集标准差标准化训练集以及测试集
scalar = preprocessing.StandardScaler().fit(Train_X)
Train_X = scalar.transform(Train_X)
Test_X = scalar.transform(Test_X)
return Train_X, Test_X
def valid_test_slice(Test_X, Test_Y):
test_size = rate[2] / (rate[1] + rate[2])
ss = StratifiedShuffleSplit(n_splits=1, test_size=test_size)
for train_index, test_index in ss.split(Test_X, Test_Y):
X_valid, X_test = Test_X[train_index], Test_X[test_index]
Y_valid, Y_test = Test_Y[train_index], Test_Y[test_index]
return X_valid, Y_valid, X_test, Y_test
# 从所有.mat文件中读取出数据的字典
data = capture(original_path=d_path)
# 将数据切分为训练集、测试集
train, test = slice_enc(data)
# 为训练集制作标签，返回X，Y
Train_X, Train_Y = add_labels(train)
# 为测试集制作标签，返回X，Y
Test_X, Test_Y = add_labels(test)
# 为训练集Y/测试集One-hot标签
Train_Y, Test_Y = one_hot(Train_Y, Test_Y)
# 训练数据/测试数据 是否标准化.
if normal:
Train_X, Test_X = scalar_stand(Train_X, Test_X)
else:
# 需要做一个数据转换，转换成np格式.
Train_X = np.asarray(Train_X)
Test_X = np.asarray(Test_X)
# 将测试集切分为验证集合和测试集.
Valid_X, Valid_Y, Test_X, Test_Y = valid_test_slice(Test_X, Test_Y)
return Train_X, Train_Y, Valid_X, Valid_Y, Test_X, Test_Y
if __name__ == "__main__":
path = '0HP/'
train_X, train_Y, valid_X, valid_Y, test_X, test_Y = prepro(d_path=path,
length=1024,
number=200,
normal=True,
rate=[0.7, 0.2, 0.1],
enc=False,
enc_step=28)
savemat("data_process.mat", {'train_X': train_X,'train_Y': train_Y,
'valid_X': valid_X,'valid_Y': valid_Y,
'test_X': test_X,'test_Y': test_Y}) 2.2 1DCNN故障诊断建模
基于1中的1DCNN进行故障诊断建模，参数我们随意设置，测试集精度为80.5%（可以手动调参，提高精度，不过我比较懒，而且要对比出优化的重要性）
# coding: utf-8
# In[1]: 导入必要的库函数
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from sklearn.preprocessing import MinMaxScaler,StandardScaler
from model import ConvNet,Model_fit
import matplotlib.pyplot as plt
if torch.cuda.is_available():
torch.backends.cudnn.deterministic = True
from scipy.io import loadmat
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# In[2] 加载数据
num_classes=10
# 振动信号----1D-CNN输入
data=loadmat('data_process.mat')
x_train1=data['train_X']
x_valid1=data['valid_X']
y_train=data['train_Y'].argmax(axis=1)
y_valid=data['valid_Y'].argmax(axis=1)
ss1=StandardScaler().fit(x_train1) #MinMaxScaler StandardScaler
x_train1=ss1.transform(x_train1)
x_valid1=ss1.transform(x_valid1)
x_train1=x_train1.reshape(-1,1,1024)
x_valid1=x_valid1.reshape(-1,1,1024)
# 转换为torch的输入格式
train_features1 = torch.tensor(x_train1).type(torch.FloatTensor)
valid_features1 = torch.tensor(x_valid1).type(torch.FloatTensor)
train_labels = torch.tensor(y_train).type(torch.LongTensor)
valid_labels = torch.tensor(y_valid).type(torch.LongTensor)
print(train_features1.shape)
print(train_labels.shape)
N=train_features1.size(0)
# In[3]: 参数设置
learning_rate = 0.005#学习率
num_epochs = 10#迭代次数
batch_size = 64 #batchsize
# In[4]: 模型设置
torch.manual_seed(0)
torch.cuda.manual_seed(0)
model=ConvNet(train_features1.size(-1),8,3,3,16,3,4,128,128,10)
train_again=True # True就重新训练
if train_again:
# In[5]:
Model=Model_fit(model,batch_size,learning_rate,num_epochs,device,verbose=True)
Model.train(train_features1,train_labels,valid_features1,valid_labels)
model= Model.model
train_loss=Model.train_loss
valid_loss=Model.valid_loss
valid_acc=Model.valid_acc
train_acc=Model.train_acc
torch.save(model,'model/W_CNN1.pkl')#保存整个网络参数
# In[]
#loss曲线
plt.figure()
plt.plot(np.array(train_loss),label='train')
plt.plot(np.array(valid_loss),label='valid')
plt.title('loss curve')
plt.legend()
plt.savefig('图片保存/loss')
# accuracy 曲线
plt.figure()
plt.plot(np.array(train_acc),label='train')
plt.plot(np.array(valid_acc),label='valid')
plt.title('accuracy curve')
plt.legend()
plt.savefig('图片保存/accuracy')
plt.show()
else:
model=torch.load('model/W_CNN1.pkl',map_location=torch.device('cpu'))#加载模型
Model=Model_fit(model,batch_size,learning_rate,num_epochs,device,verbose=True)
# In[6]: 利用训练好的模型 对测试集进行分类
#提取测试集
x_test1=data['test_X']
y_test=data['test_Y'].argmax(axis=1)
x_test1=ss1.transform(x_test1)
x_test1=x_test1.reshape(-1,1,1024)
test_features1 = torch.tensor(x_test1).type(torch.FloatTensor)
test_labels = torch.tensor(y_test).type(torch.LongTensor)
_,teac=Model.compute_accuracy(test_features1,test_labels)
print('CNN直接分类的测试集正确率为：',teac*100,'%')
2.3 采用WOA优化1DCNN超参数
以最小化验证集分类错误率为适应度函数进行网络优化，目的是找到一组最优超参数，使得训练好的网络的验证集分类错误率最低。
# coding: utf-8
# In[1]: 导入必要的库函数
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from sklearn.preprocessing import MinMaxScaler,StandardScaler
from model import ConvNet,Model_fit
from optim import WOA,HUATU
import matplotlib.pyplot as plt
if torch.cuda.is_available():
torch.backends.cudnn.deterministic = True
from scipy.io import loadmat
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
#torch.manual_seed(0)
# In[2] 加载数据
num_classes=10
# 振动信号----1D-CNN输入
data=loadmat('data_process.mat')
x_train1=data['train_X']
x_valid1=data['valid_X']
y_train=data['train_Y'].argmax(axis=1)
y_valid=data['valid_Y'].argmax(axis=1)
ss1=StandardScaler().fit(x_train1) #MinMaxScaler StandardScaler
x_train1=ss1.transform(x_train1)
x_valid1=ss1.transform(x_valid1)
x_train1=x_train1.reshape(-1,1,1024)
x_valid1=x_valid1.reshape(-1,1,1024)
# 转换为torch的输入格式
train_features1 = torch.tensor(x_train1).type(torch.FloatTensor)
valid_features1 = torch.tensor(x_valid1).type(torch.FloatTensor)
train_labels = torch.tensor(y_train).type(torch.LongTensor)
valid_labels = torch.tensor(y_valid).type(torch.LongTensor)
# In[] WOA优化CNN
optim_again = True # 为 False 的时候就直接加载之间优化好的超参建建
# 训练模型
if optim_again:
best,trace,process=WOA(train_features1,train_labels,valid_features1,valid_labels)
trace,process=np.array(trace),np.array(process)
np.savez('model/woa_result.npz',trace=trace,best=best,process=process)
else:
para=np.load('model/woa_result.npz')
trace=para['trace'].reshape(-1,)
process=para['process']
best=para['best'].reshape(-1,)
HUATU(trace)
# In[3]: 参数设置
pop=best
learning_rate = pop[0] # 学习率
num_epochs = int(pop[1]) # 迭代次数
batch_size = int(pop[2]) # batchsize
nk1 = int(pop[3]) # conv1核数量
k1 = int(pop[4]) # conv1核大小
pk1 = int(pop[5]) # pool1核大小
nk2 = int(pop[6]) # conv2核数量
k2 = int(pop[7]) # conv2核大小
pk2 = int(pop[8]) # pool2核大小
fc1 = int(pop[9]) #全连接层1节点数
fc2 = int(pop[10]) #全连接层2节点数
torch.manual_seed(0)
torch.cuda.manual_seed(0)
model=ConvNet(train_features1.size(-1),nk1,k1,pk1,nk2,k2,pk2,fc1,fc2,10)
train_again= True #True 就重新训练
# In[5]:
if train_again:
Model=Model_fit(model,batch_size,learning_rate,num_epochs,device,verbose=True)
Model.train(train_features1,train_labels,valid_features1,valid_labels)
model= Model.model
train_loss=Model.train_loss
valid_loss=Model.valid_loss
valid_acc=Model.valid_acc
train_acc=Model.train_acc
torch.save(model,'model/W_CNN2.pkl')#保存整个网络参数
#loss曲线
plt.figure()
plt.plot(np.array(train_loss),label='train')
plt.plot(np.array(valid_loss),label='valid')
plt.title('loss curve')
plt.legend()
plt.savefig('图片保存/loss')
# accuracy 曲线
plt.figure()
plt.plot(np.array(train_acc),label='train')
plt.plot(np.array(valid_acc),label='valid')
plt.title('accuracy curve')
plt.legend()
plt.savefig('图片保存/accuracy')
plt.show()
else:
model=torch.load('model/W_CNN2.pkl',map_location=torch.device('cpu'))#加载模型
Model=Model_fit(model,batch_size,learning_rate,num_epochs,device,verbose=True)
# In[6]: 利用训练好的模型 对测试集进行分类
#提取测试集
x_test1=data['test_X']
y_test=data['test_Y'].argmax(axis=1)
x_test1=ss1.transform(x_test1)
x_test1=x_test1.reshape(-1,1,1024)
test_features1 = torch.tensor(x_test1).type(torch.FloatTensor)
test_labels = torch.tensor(y_test).type(torch.LongTensor)
_,teac=Model.compute_accuracy(test_features1,test_labels)
print('WOA-CNN分类的测试集正确率为：',teac*100,'%')
由于是最小化 验证集分类错误率为适应度函数，所以适应度曲线是一条下降的曲线。
3.代码
代码链接见评论区我的评论