• 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”模式的结构，代码如下：

    1. class Conv1d(torch.nn.Module):
    2.     def __init__(self, in_channels, out_channels, kernel_size, bias=True, padding_layer=nn.ReflectionPad1d):
    3.         super().__init__()
    4.         ka = kernel_size // 2
    5.         kb = ka - 1 if kernel_size % 2 == 0 else ka
    6.         self.net = torch.nn.Sequential(
    7.             padding_layer((ka,kb)),
    8.             nn.Conv1d(in_channels, out_channels, kernel_size, bias=bias)
    9.         )
    10.     def forward(self, x):
    11.         return self.net(x)
    12.  
    13. class MaxPool1d(torch.nn.Module):
    14.     def __init__(self, kernel_size):
    15.         super().__init__()
    16.         self.net=torch.nn.MaxPool1d(kernel_size=kernel_size)
    17.     def forward(self, x):
    18.         x1=self.net(x)
    19.         padsize=x.size(2)-x1.size(2)
    20.         ka = padsize // 2
    21.         kb = ka if padsize % 2 == 0 else ka+1
    22.         return F.pad(x1,(ka,kb))
    23.  
    24. net1=Conv1d(1,3,10)#输入通道、输出通道数、卷积核大小
    25. net2=MaxPool1d(3)#池化核大小
    26. dummy=torch.rand(16,1,101)
    27. print(net1(dummy).size())
    28. print(net1(dummy).size())
    29. # torch.Size([16, 3, 101])
    30. # torch.Size([16, 3, 101])

    可以看出，无论怎么设置输入的长度，与卷积、池化参数，他的输出长度都是与输入的长度都是一样的。

    采用上述代码设计一个两层的1DCNN，代码如下 

    1. class ConvNet(torch.nn.Module):
    2.  
    3.     def __init__(self,num_input,nk1,k1,pk1,nk2,k2,pk2,fc1,fc2, num_classes):
    4.         super(ConvNet, self).__init__()
    5.         
    6.  
    7.         # 1D-CNN 输入1*1024振动信号
    8.         self.net = nn.Sequential(
    9.             Conv1d(1,nk1 , kernel_size=k1), 
    10.             MaxPool1d(kernel_size=pk1),      
    11.             nn.ReLU(),                        
    12.             nn.BatchNorm1d(nk1),
    13.             Conv1d(nk1, nk2, kernel_size=k2),  
    14.             MaxPool1d(kernel_size=pk2),      
    15.             nn.ReLU(),                          
    16.             nn.BatchNorm1d(nk2)
    17.         )
    18.         
    19.  
    20.         self.feature_extractor = nn.Sequential(
    21.             nn.Linear(num_input*nk2, fc1),
    22.             nn.ReLU(),                         
    23. #            nn.Dropout(0.5),
    24.             nn.Linear(fc1, fc2))               
    25.         self.classifier=nn.Sequential(
    26.             nn.ReLU(),
    27.             nn.Linear(fc2, num_classes),
    28.         )
    29.  
    30.  
    31.     def forward(self,x):
    32.         x= self.net(x)#进行卷积+池化操作提取振动信号特征
    33.         x=x.view(-1, x.size(1)*x.size(2))
    34.         feature = self.feature_extractor(x)#将上述特征拉伸为向量输入进全连接层实现分类
    35.         logits = self.classifier(feature)#将上述特征拉伸为向量输入进全连接层实现分类
    36.         probas = F.softmax(logits, dim=1)# softmax分类器
    37.         return logits,probas
    38.  
    39. net=ConvNet(101,8,3,3,16,3,4,128,128,10)
    40. dummy=torch.rand(16,1,101)
    41. print(net(dummy)[0].size())
    42. # torch.Size([16, 10])
    43. net=ConvNet(111,8,7,3,16,7,4,256,128,10)
    44. dummy=torch.rand(16,1,111)
    45. print(net(dummy)[0].size())
    46. # torch.Size([16, 10])

    可以看出，无论怎么设置输入的长度，与卷积、池化参数，他的输出都是16x10（16是batchsize，10是类别数）

    2.WOA优化1DCNN超参数实战

    2.1 数据准备

            数据依旧采用48k的驱动端轴承故障诊断数据，每种故障样本数为200，每个样本的长度为1024，按照7：2：1的比例划分训练集、验证集、测试集

    1. #coding:utf-8
    2.  
    3.  
    4. from scipy.io import loadmat
    5. from scipy.io import savemat
    6.  
    7. import numpy as np
    8. import os
    9. from sklearn import preprocessing  # 0-1编码
    10. from sklearn.model_selection import StratifiedShuffleSplit  # 随机划分，保证每一类比例相同
    11.  
    12. def prepro(d_path, length=864, number=1000, normal=True, rate=[0.7, 0.2, 0.1], enc=True, enc_step=28):
    13.     """对数据进行预处理,返回train_X, train_Y, valid_X, valid_Y, test_X, test_Y样本.
    15.     :param d_path: 源数据地址
    16.     :param length: 信号长度，默认2个信号周期，864
    17.     :param number: 每种信号个数,总共10类,默认每个类别1000个数据
    18.     :param normal: 是否标准化.True,Fales.默认True
    19.     :param rate: 训练集/验证集/测试集比例.默认[0.5,0.25,0.25],相加要等于1
    20.     :param enc: 训练集、验证集是否采用数据增强.Bool,默认True
    21.     :param enc_step: 增强数据集采样顺延间隔
    22.     :return: Train_X, Train_Y, Valid_X, Valid_Y, Test_X, Test_Y
    24.     ```
    25.     import preprocess.preprocess_nonoise as pre
    27.     train_X, train_Y, valid_X, valid_Y, test_X, test_Y = pre.prepro(d_path=path,
    28.                                                                     length=864,
    29.                                                                     number=1000,
    30.                                                                     normal=False,
    31.                                                                     rate=[0.5, 0.25, 0.25],
    32.                                                                     enc=True,
    33.                                                                     enc_step=28)
    34.     ```
    35.     """
    36.     # 获得该文件夹下所有.mat文件名
    37.     filenames = os.listdir(d_path)
    38.  
    39.     def capture(original_path):
    40.         """读取mat文件，返回字典
    42.         :param original_path: 读取路径
    43.         :return: 数据字典
    44.         """
    45.         files = {}
    46.         for i in filenames:
    47.             # 文件路径
    48.             file_path = os.path.join(d_path, i)
    49.             file = loadmat(file_path)
    50.             file_keys = file.keys()
    51.             for key in file_keys:
    52.                 if 'DE' in key:
    53.                     files[i] = file[key].ravel()
    54.         return files
    55.  
    56.     def slice_enc(data, slice_rate=rate[1] + rate[2]):
    57.         """将数据切分为前面多少比例，后面多少比例.
    59.         :param data: 单挑数据
    60.         :param slice_rate: 验证集以及测试集所占的比例
    61.         :return: 切分好的数据
    62.         """
    63.         keys = data.keys()
    64.         Train_Samples = {}
    65.         Test_Samples = {}
    66.         for i in keys:
    67.             slice_data = data[i]
    68.             all_lenght = len(slice_data)
    69.             end_index = int(all_lenght * (1 - slice_rate))
    70.             samp_train = int(number * (1 - slice_rate))  # 700
    71.             Train_sample = []
    72.             Test_Sample = []
    73.             if enc:
    74.                 enc_time = length // enc_step
    75.                 samp_step = 0  # 用来计数Train采样次数
    76.                 for j in range(samp_train):
    77.                     random_start = np.random.randint(low=0, high=(end_index - 2 * length))
    78.                     label = 0
    79.                     for h in range(enc_time):
    80.                         samp_step += 1
    81.                         random_start += enc_step
    82.                         sample = slice_data[random_start: random_start + length]
    83.                         Train_sample.append(sample)
    84.                         if samp_step == samp_train:
    85.                             label = 1
    86.                             break
    87.                     if label:
    88.                         break
    89.             else:
    90.                 for j in range(samp_train):
    91.                     random_start = np.random.randint(low=0, high=(end_index - length))
    92.                     sample = slice_data[random_start:random_start + length]
    93.                     Train_sample.append(sample)
    94.  
    95.             # 抓取测试数据
    96.             for h in range(number - samp_train):
    97.                 random_start = np.random.randint(low=end_index, high=(all_lenght - length))
    98.                 sample = slice_data[random_start:random_start + length]
    99.                 Test_Sample.append(sample)
    100.             Train_Samples[i] = Train_sample
    101.             Test_Samples[i] = Test_Sample
    102.         return Train_Samples, Test_Samples
    103.  
    104.     # 仅抽样完成，打标签
    105.     def add_labels(train_test):
    106.         X = []
    107.         Y = []
    108.         label = 0
    109.         for i in filenames:
    110.             x = train_test[i]
    111.             X += x
    112.             lenx = len(x)
    113.             Y += [label] * lenx
    114.             label += 1
    115.         return X, Y
    116.  
    117.     # one-hot编码
    118.     def one_hot(Train_Y, Test_Y):
    119.         Train_Y = np.array(Train_Y).reshape([-1, 1])
    120.         Test_Y = np.array(Test_Y).reshape([-1, 1])
    121.         Encoder = preprocessing.OneHotEncoder()
    122.         Encoder.fit(Train_Y)
    123.         Train_Y = Encoder.transform(Train_Y).toarray()
    124.         Test_Y = Encoder.transform(Test_Y).toarray()
    125.         Train_Y = np.asarray(Train_Y, dtype=np.int32)
    126.         Test_Y = np.asarray(Test_Y, dtype=np.int32)
    127.         return Train_Y, Test_Y
    128.  
    129.     def scalar_stand(Train_X, Test_X):
    130.         # 用训练集标准差标准化训练集以及测试集
    131.         scalar = preprocessing.StandardScaler().fit(Train_X)
    132.         Train_X = scalar.transform(Train_X)
    133.         Test_X = scalar.transform(Test_X)
    134.         return Train_X, Test_X
    135.  
    136.     def valid_test_slice(Test_X, Test_Y):
    137.         test_size = rate[2] / (rate[1] + rate[2])
    138.         ss = StratifiedShuffleSplit(n_splits=1, test_size=test_size)
    139.         for train_index, test_index in ss.split(Test_X, Test_Y):
    140.             X_valid, X_test = Test_X[train_index], Test_X[test_index]
    141.             Y_valid, Y_test = Test_Y[train_index], Test_Y[test_index]
    142.             return X_valid, Y_valid, X_test, Y_test
    143.  
    144.     # 从所有.mat文件中读取出数据的字典
    145.     data = capture(original_path=d_path)
    146.     # 将数据切分为训练集、测试集
    147.     train, test = slice_enc(data)
    148.     # 为训练集制作标签，返回X，Y
    149.     Train_X, Train_Y = add_labels(train)
    150.     # 为测试集制作标签，返回X，Y
    151.     Test_X, Test_Y = add_labels(test)
    152.     # 为训练集Y/测试集One-hot标签
    153.     Train_Y, Test_Y = one_hot(Train_Y, Test_Y)
    154.     # 训练数据/测试数据 是否标准化.
    155.     if normal:
    156.         Train_X, Test_X = scalar_stand(Train_X, Test_X)
    157.     else:
    158.         # 需要做一个数据转换，转换成np格式.
    159.         Train_X = np.asarray(Train_X)
    160.         Test_X = np.asarray(Test_X)
    161.     # 将测试集切分为验证集合和测试集.
    162.     Valid_X, Valid_Y, Test_X, Test_Y = valid_test_slice(Test_X, Test_Y)
    163.     return Train_X, Train_Y, Valid_X, Valid_Y, Test_X, Test_Y
    164.  
    165.  
    166. if __name__ == "__main__":
    167.     path = '0HP/'
    168.     train_X, train_Y, valid_X, valid_Y, test_X, test_Y = prepro(d_path=path,
    169.                                                                 length=1024,
    170.                                                                 number=200,
    171.                                                                 normal=True,
    172.                                                                 rate=[0.7, 0.2, 0.1],
    173.                                                                 enc=False,
    174.                                                                 enc_step=28)
    175.  
    176.     savemat("data_process.mat", {'train_X': train_X,'train_Y': train_Y,
    177.                                    'valid_X': valid_X,'valid_Y': valid_Y,
    178.                                    'test_X': test_X,'test_Y': test_Y})

    2.2 1DCNN故障诊断建模

            基于1中的1DCNN进行故障诊断建模，参数我们随意设置，测试集精度为80.5%（可以手动调参，提高精度，不过我比较懒，而且要对比出优化的重要性）

    1. # coding: utf-8
    2. # In[1]: 导入必要的库函数
    3.  
    4.  
    5. import numpy as np
    6. import torch
    7. import torch.nn as nn
    8. import torch.nn.functional as F
    9. from sklearn.preprocessing import MinMaxScaler,StandardScaler
    10. from model import ConvNet,Model_fit
    11. import matplotlib.pyplot as plt
    12. if torch.cuda.is_available():
    13.     torch.backends.cudnn.deterministic = True
    14. from scipy.io import loadmat
    15. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    16.  
    17.  
    18. # In[2] 加载数据
    19. num_classes=10
    20.  
    21. # 振动信号----1D-CNN输入
    22. data=loadmat('data_process.mat')
    23. x_train1=data['train_X']
    24. x_valid1=data['valid_X']
    25. y_train=data['train_Y'].argmax(axis=1)
    26. y_valid=data['valid_Y'].argmax(axis=1)
    27. ss1=StandardScaler().fit(x_train1) #MinMaxScaler StandardScaler
    28. x_train1=ss1.transform(x_train1)
    29. x_valid1=ss1.transform(x_valid1)
    30.  
    31. x_train1=x_train1.reshape(-1,1,1024)
    32. x_valid1=x_valid1.reshape(-1,1,1024)
    33.  
    34.  
    35. # 转换为torch的输入格式
    36. train_features1 = torch.tensor(x_train1).type(torch.FloatTensor)
    37. valid_features1 = torch.tensor(x_valid1).type(torch.FloatTensor)
    38.  
    39. train_labels = torch.tensor(y_train).type(torch.LongTensor)
    40. valid_labels = torch.tensor(y_valid).type(torch.LongTensor)
    41.         
    42. print(train_features1.shape)
    43. print(train_labels.shape)
    44.  
    45. N=train_features1.size(0)
    46.  
    47. # In[3]: 参数设置
    48. learning_rate = 0.005#学习率
    49. num_epochs = 10#迭代次数
    50. batch_size = 64 #batchsize
    51. # In[4]: 模型设置
    52. torch.manual_seed(0)
    53. torch.cuda.manual_seed(0)
    54. model=ConvNet(train_features1.size(-1),8,3,3,16,3,4,128,128,10)
    55. train_again=True # True就重新训练
    56. if train_again:    
    57.     # In[5]:
    58.     Model=Model_fit(model,batch_size,learning_rate,num_epochs,device,verbose=True)
    59.     Model.train(train_features1,train_labels,valid_features1,valid_labels)
    60.     model=  Model.model
    61.     train_loss=Model.train_loss
    62.     valid_loss=Model.valid_loss
    63.     valid_acc=Model.valid_acc
    64.     train_acc=Model.train_acc
    65.     
    66.     torch.save(model,'model/W_CNN1.pkl')#保存整个网络参数
    67.     # In[] 
    68.     #loss曲线
    69.     plt.figure()
    70.     plt.plot(np.array(train_loss),label='train')
    71.     plt.plot(np.array(valid_loss),label='valid')
    72.     plt.title('loss curve')
    73.     plt.legend()
    74.     plt.savefig('图片保存/loss')
    75.     # accuracy 曲线
    76.     plt.figure()
    77.     plt.plot(np.array(train_acc),label='train')
    78.     plt.plot(np.array(valid_acc),label='valid')
    79.     plt.title('accuracy curve')
    80.     plt.legend()
    81.     plt.savefig('图片保存/accuracy')
    82.     plt.show()
    83. else:
    84.     model=torch.load('model/W_CNN1.pkl',map_location=torch.device('cpu'))#加载模型
    85.     Model=Model_fit(model,batch_size,learning_rate,num_epochs,device,verbose=True)
    86.  
    87. # In[6]: 利用训练好的模型 对测试集进行分类
    88.  
    89. #提取测试集
    90. x_test1=data['test_X']
    91. y_test=data['test_Y'].argmax(axis=1)
    92.  
    93. x_test1=ss1.transform(x_test1)
    94. x_test1=x_test1.reshape(-1,1,1024)
    95.  
    96. test_features1 = torch.tensor(x_test1).type(torch.FloatTensor)
    97.  
    98. test_labels = torch.tensor(y_test).type(torch.LongTensor)
    99.  
    100. _,teac=Model.compute_accuracy(test_features1,test_labels)
    101. print('CNN直接分类的测试集正确率为：',teac*100,'%')

    2.3 采用WOA优化1DCNN超参数

            以最小化验证集分类错误率为适应度函数进行网络优化，目的是找到一组最优超参数，使得训练好的网络的验证集分类错误率最低。

    1. # coding: utf-8
    2. # In[1]: 导入必要的库函数
    3.  
    4.  
    5. import numpy as np
    6. import torch
    7. import torch.nn as nn
    8. import torch.nn.functional as F
    9. from sklearn.preprocessing import MinMaxScaler,StandardScaler
    10. from model import ConvNet,Model_fit
    11. from optim import WOA,HUATU
    12. import matplotlib.pyplot as plt
    13. if torch.cuda.is_available():
    14.     torch.backends.cudnn.deterministic = True
    15. from scipy.io import loadmat
    16. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    17. #torch.manual_seed(0)
    18.  
    19. # In[2] 加载数据
    20. num_classes=10
    21.  
    22. # 振动信号----1D-CNN输入
    23. data=loadmat('data_process.mat')
    24. x_train1=data['train_X']
    25. x_valid1=data['valid_X']
    26. y_train=data['train_Y'].argmax(axis=1)
    27. y_valid=data['valid_Y'].argmax(axis=1)
    28. ss1=StandardScaler().fit(x_train1) #MinMaxScaler StandardScaler
    29. x_train1=ss1.transform(x_train1)
    30. x_valid1=ss1.transform(x_valid1)
    31.  
    32. x_train1=x_train1.reshape(-1,1,1024)
    33. x_valid1=x_valid1.reshape(-1,1,1024)
    34.  
    35.  
    36. # 转换为torch的输入格式
    37. train_features1 = torch.tensor(x_train1).type(torch.FloatTensor)
    38. valid_features1 = torch.tensor(x_valid1).type(torch.FloatTensor)
    39.  
    40. train_labels = torch.tensor(y_train).type(torch.LongTensor)
    41. valid_labels = torch.tensor(y_valid).type(torch.LongTensor)
    42.  
    43. # In[] WOA优化CNN
    44. optim_again = True # 为 False 的时候就直接加载之间优化好的超参建建
    45. # 训练模型
    46. if optim_again:
    47.     best,trace,process=WOA(train_features1,train_labels,valid_features1,valid_labels)
    48.     trace,process=np.array(trace),np.array(process)
    49.     np.savez('model/woa_result.npz',trace=trace,best=best,process=process)
    50. else:
    51.     para=np.load('model/woa_result.npz')
    52.     trace=para['trace'].reshape(-1,)
    53.     process=para['process']
    54.     best=para['best'].reshape(-1,)
    55. HUATU(trace)
    56. # In[3]: 参数设置
    57. pop=best
    58. learning_rate = pop[0]  # 学习率
    59. num_epochs = int(pop[1])  # 迭代次数
    60. batch_size = int(pop[2])  # batchsize
    61.  
    62. nk1 = int(pop[3])  # conv1核数量
    63. k1 = int(pop[4])  # conv1核大小
    64. pk1 = int(pop[5]) # pool1核大小
    65.  
    66. nk2 = int(pop[6])  # conv2核数量
    67. k2 = int(pop[7])  # conv2核大小
    68. pk2 = int(pop[8]) # pool2核大小
    69.     
    70. fc1 = int(pop[9]) #全连接层1节点数
    71. fc2 = int(pop[10]) #全连接层2节点数
    72. torch.manual_seed(0)
    73. torch.cuda.manual_seed(0)
    74. model=ConvNet(train_features1.size(-1),nk1,k1,pk1,nk2,k2,pk2,fc1,fc2,10)
    75. train_again= True #True 就重新训练
    76. # In[5]:
    77. if train_again:    
    78.     
    79.     Model=Model_fit(model,batch_size,learning_rate,num_epochs,device,verbose=True)
    80.     Model.train(train_features1,train_labels,valid_features1,valid_labels)
    81.     model=  Model.model
    82.     train_loss=Model.train_loss
    83.     valid_loss=Model.valid_loss
    84.     valid_acc=Model.valid_acc
    85.     train_acc=Model.train_acc
    86.     
    87.     torch.save(model,'model/W_CNN2.pkl')#保存整个网络参数
    88.     
    89.     #loss曲线
    90.     plt.figure()
    91.     plt.plot(np.array(train_loss),label='train')
    92.     plt.plot(np.array(valid_loss),label='valid')
    93.     plt.title('loss curve')
    94.     plt.legend()
    95.     plt.savefig('图片保存/loss')
    96.     # accuracy 曲线
    97.     plt.figure()
    98.     plt.plot(np.array(train_acc),label='train')
    99.     plt.plot(np.array(valid_acc),label='valid')
    100.     plt.title('accuracy curve')
    101.     plt.legend()
    102.     plt.savefig('图片保存/accuracy')
    103.     plt.show()
    104. else:
    105.     model=torch.load('model/W_CNN2.pkl',map_location=torch.device('cpu'))#加载模型
    106.     Model=Model_fit(model,batch_size,learning_rate,num_epochs,device,verbose=True)
    107.  
    108. # In[6]: 利用训练好的模型 对测试集进行分类
    109.  
    110. #提取测试集
    111. x_test1=data['test_X']
    112. y_test=data['test_Y'].argmax(axis=1)
    113.  
    114. x_test1=ss1.transform(x_test1)
    115. x_test1=x_test1.reshape(-1,1,1024)
    116.  
    117. test_features1 = torch.tensor(x_test1).type(torch.FloatTensor)
    118.  
    119. test_labels = torch.tensor(y_test).type(torch.LongTensor)
    120.  
    121. _,teac=Model.compute_accuracy(test_features1,test_labels)
    122. print('WOA-CNN分类的测试集正确率为：',teac*100,'%')

    由于是最小化 验证集分类错误率为适应度函数，所以适应度曲线是一条下降的曲线。

    3.代码

    代码链接见评论区我的评论

  • 相关阅读:
    dp记录。
    R-FCN: Object Detection via Region-based Fully Convolutional Networks
    Web3 新手攻略：9 个不可或缺的 APP 助力你踏入加密领域
    【Java】Java中对List进行排序
    excel文件双击 该文件没有与之关联的应用来执行操作
    微软校园大使喊你来秋招啦！
    流程图渲染方式：Canvas vs SVG
    相机平行状态下模型无法初始化到桌面
    华为机试 - 水仙花数 Ⅰ
    C++初阶--内存管理
  • 原文地址：https://blog.csdn.net/qq_41043389/article/details/127799188