• 神经网络分析中医药数据Excel数据||神经网络pytorch实现||五折交叉验证||pytorch神经网络框架||神经网络模型参数保存

    注意参数位已用中文描述代替。

    如果你想训练自己的数据集，大多情况修改他们就可以了。

    如果数据格式不大相同 或者 你想要修改网络结构（本文是三层全连接BP神经网络）。

    那么你可以试着修改其中的一些函数，试着符合你的要求。

     五折交叉、模型保存等均在代码中解释，自行选择

    如果你没有安装pytorch，你可以尝试安装这个包的cpu版

    Start Locally | PyTorch

    如果不想安装，可以去去郭大侠的github，哪里不需要pytorch

    数据格式

    664条样本   每条103个属性，最后一列为标签

    结果

     不使用五折交叉验证

     使用五折交叉验证

    代码

    不使用五折交叉验证

    1. """
    2. BP神经网络二分类任务 瘀血阻络证 103特征
    3. """
    4. import pandas as pd
    5. import matplotlib.pyplot as plt
    6. import numpy as np
    7. import random
    8. import torch
    9. import torch.nn as nn
    10. from torch.utils.data import DataLoader, TensorDataset
    11. from sklearn.model_selection import train_test_split
    12. from sklearn.metrics import classification_report, roc_curve, auc
    13.  
    14.  
    15. def open_excel(file_url):
    16.     """
    17.     打开数据集，进行数据处理
    18.     :param file_url:文件路径
    19.     :return:特征集数据、标签集数据
    20.     """
    21.     readbook = pd.read_excel(f'{file_url}', engine='openpyxl')
    22.     nplist = readbook.T.to_numpy()
    23.     data = nplist[0:-1].T
    24.     data = np.float64(data)
    25.     target = nplist[-1]
    26.     return data, target
    27.  
    28.  
    29. def open_csv(file_url):
    30.     """
    31.     打开数据集，进行数据处理
    32.     :param file_url:文件名
    33.     :return:特征集数据、标签集数据
    34.     """
    35.     readbook = pd.read_csv(f'{file_url}.csv')
    36.     nplist = readbook.T.to_numpy()
    37.     data = nplist[0:-1].T
    38.     data = np.float64(data)
    39.     target = nplist[-1]
    40.     return data, target
    41.  
    42.  
    43. def random_number(data_size, key):
    44.     """
    45.    使用shuffle()打乱
    46.     """
    47.     number_set = []
    48.     for i in range(data_size):
    49.         number_set.append(i)
    50.  
    51.     if key == 1:
    52.         random.shuffle(number_set)
    53.  
    54.     return number_set
    55.  
    56.  
    57. def inputtotensor(inputtensor, labeltensor):
    58.     """
    59.     将数据集的输入和标签转为tensor格式
    60.     :param inputtensor: 数据集输入
    61.     :param labeltensor: 数据集标签
    62.     :return: 输入tensor，标签tensor
    63.     """
    64.     inputtensor = np.array(inputtensor)
    65.     inputtensor = torch.FloatTensor(inputtensor)
    66.  
    67.     labeltensor = np.array(labeltensor)
    68.     labeltensor = labeltensor.astype(float)
    69.     labeltensor = torch.LongTensor(labeltensor)
    70.  
    71.     return inputtensor, labeltensor
    72.  
    73.  
    74. # 定义BP神经网络
    75. class NeuralNetwork(nn.Module):
    76.     def __init__(self):
    77.         super(NeuralNetwork, self).__init__()
    78.         self.fc1 = nn.Linear(input_size, hidden_size)  # 输入层->隐藏层1
    79.         self.relu = nn.ReLU()
    80.         self.fc2 = nn.Linear(hidden_size, hidden_size)  # 隐藏层1->隐藏层2
    81.         self.fc3 = nn.Linear(hidden_size, num_classes)  # 隐藏层2->输出层
    82.         self.dropout_i = nn.Dropout(p=0.2)  # dropout训练
    83.         self.dropout_h = nn.Dropout(p=0.5)  # 隐藏层的dropout训练
    84.  
    85.     def forward(self, x):
    86.         out = self.fc1(x)
    87.         out = self.dropout_i(out)
    88.         out = self.relu(out)
    89.         out = self.fc2(out)
    90.         out = self.dropout_h(out)
    91.         out = self.relu(out)
    92.         out = self.fc3(out)
    93.         return out
    94.  
    95.  
    96. def addbatch(data_train, data_test, batchsize):
    97.     """
    98.     设置batch
    99.     :param data_train: 输入
    100.     :param data_test: 标签
    101.     :param batchsize: 一个batch大小
    102.     :return: 设置好batch的数据集
    103.     """
    104.     data = TensorDataset(data_train, data_test)
    105.     data_loader = DataLoader(data, batch_size=batchsize, shuffle=True)
    106.  
    107.     return data_loader
    108.  
    109.  
    110. def train_test(traininput, trainlabel, Epochs, batchsize):  # ,testinput, testlabel
    111.     """
    112.     函数输入为：训练输入，训练标签，测试输入，测试标签，一个batch大小
    113.     进行BP的训练，每训练一次就算一次准确率，同时记录loss
    114.     :return:训练次数list，训练loss，测试loss，准确率
    115.     """
    116.  
    117.     # 设置batch
    118.     traindata = addbatch(traininput, trainlabel, batchsize)  # shuffle打乱数据集
    119.     total_step = len(traindata)
    120.     for epoch in range(Epochs):
    121.         for step, data in enumerate(traindata):
    122.             net.train()
    123.             inputs, labels = data
    124.             # 前向传播
    125.             out = net(inputs)
    126.             # 计算损失函数
    127.             loss = loss_func(out, labels)
    128.             # 清空上一轮的梯度
    129.             optimizer.zero_grad()
    130.             # 反向传播
    131.             loss.backward()
    132.             # 参数更新
    133.             optimizer.step()
    134.             # 输出loss
    135.             if (epoch + 1) % 100 == 0:
    136.                 print('Epoch [{}/{}], Step [{}/{}], Loss: {:.8f}'
    137.                       .format(epoch + 1, Epochs, step + 1, total_step, loss.item()))
    138.  
    139.  
    140. '''        # 测试准确率
    141.         net.eval()
    142.         testout = net(testinput)
    143.         testloss = loss_func(testout, testlabel)
    144.         prediction = torch.max(testout, 1)[1]  # torch.max
    145.         pred_y = prediction.numpy()  # 事先放在了GPU，所以必须得从GPU取到CPU中！！！！！！
    146.         target_y = testlabel.data.numpy()
    147.         j = 0
    148.         for i in range(pred_y.size):
    149.             if pred_y[i] == target_y[i]:
    150.                 j += 1
    151.         acc = j / pred_y.size
    153.         if epoch % 10 == 0:
    154.             print("训练次数为", epoch, "的准确率为:", acc)'''
    155.  
    156.  
    157. # 根据标签和预测概率结果画出ROC图，并计算AUC值
    158. def acu_curve(y, prob):
    159.     fpr, tpr, threshold = roc_curve(y, prob)  ###计算真正率和假正率
    160.     roc_auc = auc(fpr, tpr)  ###计算auc的值
    161.     print("AUC:", roc_auc)
    162.     plt.figure()
    163.     lw = 2
    164.     plt.figure(figsize=(6, 6))
    165.     plt.plot(fpr, tpr, color='darkorange',
    166.              lw=lw, label='ROC curve (area = %0.3f)' % roc_auc)  ###假正率为横坐标，真正率为纵坐标做曲线
    167.     plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
    168.     plt.xlim([0.0, 1.0])
    169.     plt.ylim([0.0, 1.05])
    170.     plt.xlabel('False Positive Rate')
    171.     plt.ylabel('True Positive Rate')
    172.     plt.title('Receiver operating characteristic')
    173.     plt.legend(loc="lower right")
    174.     plt.show()
    175.     return roc_auc
    176.  
    177.  
    178. if __name__ == "__main__":
    179.     # 利用open_excel读取数据
    180.     feature, label = open_excel('症状_瘀血阻络证_data.xlsx')
    181.     # 数据划分为训练集和测试集
    182.     x_train, x_test, y_train, y_test = train_test_split(feature, label, test_size=你的比例, random_state=你的随机数)
    183.     # 将数据转为tensor格式
    184.     traininput, trainlabel = inputtotensor(x_train, y_train)
    185.     testinput, testlabel = inputtotensor(x_test, y_test)
    186.     # 归一化处理
    187.     traininput = nn.functional.normalize(traininput)
    188.     testinput = nn.functional.normalize(testinput)
    189.     # 设置超参数
    190.     Epochs = 你的迭代次数
    191.     input_size = 103
    192.     hidden_size = 你的隐层神经元个数
    193.     num_classes = 2
    194.     LR = 你的学习率
    195.     batchsize = 
    196.     # 定义网络
    197.     net = NeuralNetwork()
    198.     # 优化器
    199.     optimizer = torch.optim.Adam(net.parameters(), LR)
    200.     # 设定损失函数
    201.     loss_func = torch.nn.CrossEntropyLoss()
    202.     # 训练并且记录每次loss     函数输入为：训练输入，训练标签，测试输入，测试标签，一个batch大小
    203.     print(traininput)
    204.     print(trainlabel)
    205.     train_test(traininput, trainlabel, Epochs, batchsize)
    206.     print('----------------------------------不使用五折交叉验证----------------------------------')
    207.     # 不使用五折交叉验证的测试结果
    208.     net.eval()
    209.     test_predict1 = net(testinput).cpu().detach().numpy()  # 将tensor转为概率数组
    210.     test_predict2 = np.argmax(test_predict1, axis=1)  # 将概率数组转为label
    211.     # print(test_predict1)
    212.     # print(test_predict2)
    213.     print(classification_report(testlabel, test_predict2))
    214.     auc = acu_curve(testlabel, test_predict1[:, 1:])
    215.  
    216.     #######是否保存模型参数#######
    217.     save = True 或者 False
    218.     if save:
    219.         device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    220.         model = NeuralNetwork().to(device)
    221.         str = 'hidden_size'+str(hidden_size)+'-batchsize'+str(batchsize)+'-Epochs'+str(Epochs)+'-auc'+str(auc)
    222.         url = './'+ str + '.pth'
    223.         torch.save(model.state_dict(), url)
    224.         print('模型参数已保存到'+url)
    225.     '''# 读取教师模型参数  并预测
    226.     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    227.     open_model = NeuralNetwork()
    228.     open_model.load_state_dict(torch.load('./名字.pth'))
    229.     open_model.to(device)
    230.     test_predict1 = open_model(testinput.to(device)).cpu().detach().numpy()
    231.     test_predict2 = np.argmax(test_predict1, axis=1)  # 将概率数组转为label
    232.     print(classification_report(testlabel, test_predict2))
    233.     acu_curve(testlabel, test_predict1[:, 1:])
    234.     '''

    使用五折交叉验证（修改之处）

    前155行与上述相同（多了几个import）

    1. import pandas as pd
    2. import matplotlib.pyplot as plt
    3. import numpy as np
    4. import random
    5. import torch
    6. import torch.nn as nn
    7. from torch.utils.data import DataLoader, TensorDataset
    8. from sklearn.model_selection import KFold
    9. from sklearn.metrics import roc_curve, precision_score, recall_score, f1_score, \
    10.     roc_auc_score, accuracy_score, auc
    11. from itertools import chain
    1.  
    2. def statistics(testlabel, test_predict1, test_predict2):
    3.     """
    4.     :testlabel 测试集label:
    5.     :test_predict1 预测概率数组:
    6.     :test_predict2 预测label:
    7.     :return:
    8.     """
    9.     # 准确率
    10.     print(f"Accuracy:", accuracy_score(testlabel, test_predict2))
    11.     # 精确率
    12.     print("Precision:", precision_score(testlabel, test_predict2, average='macro'))
    13.     # 召回率
    14.     print("Recall:", recall_score(testlabel, test_predict2, average='macro'))
    15.     # F1值
    16.     print("F1-Score:", f1_score(testlabel, test_predict2, average='macro'))
    17.     # 画ROC曲线
    18.     fpr, tpr, thresholds = roc_curve(testlabel, test_predict1[:, 1], pos_label=1)  # pos_label=1表示正样本的标签为1
    19.     roc_auc = auc(fpr, tpr)  ###计算auc的值
    20.     print("AUC:", roc_auc)
    21.     plt.plot(fpr, tpr, linewidth=2, label="ROC(AUC=%0.3f)" % roc_auc_score(testlabel, test_predict1[:, 1]), color='darkorange')
    22.     plt.xlabel('False Positive Rate')
    23.     plt.ylabel('True Positive Rate')
    24.     plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
    25.     plt.ylim(0, 1.05)
    26.     plt.xlim(0, 1.05)
    27.     plt.legend(loc=4)
    28.     plt.show()
    29.     return roc_auc
    30.  
    31.  
    32. if __name__ == "__main__":
    33.     # 加载数据
    34.     df = pd.read_excel(r"症状_瘀血阻络证_data.xlsx")
    35.     data = df.iloc[:, :-1]
    36.     data['target'] = df.iloc[:, -1]  # 添加标签
    37.     data = data.to_numpy()
    38.     # 5-fold cross-validation
    39.     kf = KFold(n_splits=5, shuffle=True)
    40.     for train_index, test_index in kf.split(data):
    41.         x_train, x_test = data[train_index, :data.shape[1] - 1], data[test_index, :data.shape[1] - 1]
    42.         y_train, y_test = data[train_index, data.shape[1] - 1:data.shape[1]], data[test_index,data.shape[1] - 1:data.shape[1]]
    43.     '''这里把y_train、y_test降维  否则见221行 ps：目前是200行'''
    44.     y_train = list(chain.from_iterable(y_train))
    45.     y_test = list(chain.from_iterable(y_test))
    46.     # 将数据转为tensor格式
    47.     traininput, trainlabel = inputtotensor(x_train, y_train)
    48.     testinput, testlabel = inputtotensor(x_test, y_test)
    49.     # 归一化处理
    50.     traininput = nn.functional.normalize(traininput)
    51.     testinput = nn.functional.normalize(testinput)
    52.     # 设置超参数
    53.     Epochs = 你的迭代次数
    54.     input_size = 103
    55.     hidden_size = 你的隐层神经元个数
    56.     num_classes = 2
    57.     LR = 你的学习率
    58.     batchsize = 你的batchsize
    59.     # 定义网络
    60.     net = NeuralNetwork()
    61.     # 优化器
    62.     optimizer = torch.optim.Adam(net.parameters(), LR)
    63.     '''设定损失函数  KFold使trainlabel升维  需要更改为多标签损失函数MultiLabelSoftMarginLoss  当然我没这么做  我在200行把y_train、y_test降维了'''
    64.     #loss_func = torch.nn.MultiLabelSoftMarginLoss()
    65.     loss_func = torch.nn.CrossEntropyLoss()
    66.     # 训练并且记录每次loss     函数输入为：训练输入，训练标签，测试输入，测试标签，一个batch大小
    67.     train_test(traininput, trainlabel, Epochs, batchsize)
    68.     print('----------------------------------使用五折交叉验证----------------------------------')
    69.     # 使用五折交叉验证的测试结果
    70.     net.eval()
    71.     test_predict1 = net(testinput).cpu().detach().numpy()  # 将tensor转为概率数组
    72.     test_predict2 = np.argmax(test_predict1, axis=1)  # 将概率数组转为label
    73.     auc = statistics(testlabel, test_predict1, test_predict2)
    74.     #######是否保存模型参数#######
    75.     save = True 或者 False
    76.     if save:
    77.         device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    78.         model = NeuralNetwork().to(device)
    79.         str = 'hidden_size'+str(hidden_size)+'-batchsize'+str(batchsize)+'-Epochs'+str(Epochs)+'-auc'+str(auc)
    80.         url = './'+ str + '.pth'
    81.         torch.save(model.state_dict(), url)
    82.         print('模型参数已保存到'+url)
    83.     '''# 读取教师模型参数  并预测
    84.     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    85.     open_model = NeuralNetwork()
    86.     open_model.load_state_dict(torch.load('./名字.pth'))
    87.     open_model.to(device)
    88.     test_predict1 = open_model(testinput.to(device)).cpu().detach().numpy()
    89.     test_predict2 = np.argmax(test_predict1, axis=1)  # 将概率数组转为label
    90.     statistics(testlabel, test_predict1, test_predict2)
    91.     '''

     注意点（参考）

    1、主要参考pytorch神经网络对Excel数据集进行处理（读取，转为tensor格式，归一化），并且以鸢尾花（iris）数据集为例，实现BP神经网络_<编程路上>的博客-CSDN博客https://blog.csdn.net/weixin_43788986/article/details/125880602

    2 、pytorch：批量数据分割（batch）_XYKenny的博客-CSDN博客https://blog.csdn.net/XYKenny/article/details/105935836

    3、Pytorch学习笔记(5)——交叉熵报错RuntimeError: 1D target tensor expected, multi-target not supported_野指针小李的博客-CSDN博客https://blog.csdn.net/qq_35357274/article/details/121002342

    4、评估深度学习模型-在keras中使用scikit-learn-基于keras的python学习笔记（三）_人工智障之深度瞎学的博客-CSDN博客https://blog.csdn.net/weixin_44474718/article/details/86249827

    5、python将二维数组变成一维数组（np.array类型）_靳航ppp的博客-CSDN博客_python二维数组转化为一维数组https://blog.csdn.net/haha456487/article/details/106316116

  • 相关阅读:
    财务对账-财务收发存-业务收发存
    Rust使用Iterator优化grep
    概率论与数理统计学习：随机事件（一）——知识总结与C语言实现案例
    Linux 目录管理
    IgH Master环境搭建
    非零基础自学Java (老师：韩顺平) 第15章 泛型 15.3 泛型介绍 && 15.4 泛型的语法
    leetcode刷题（124）——64. 最小路径和
    【算法刷题】—7.13哈希表的应用
    数据统计与可视化复习总结（二）：非参数检验、生存分析
    A8. 无人机编队飞行定位分析与讨论-大结局
  • 原文地址：https://blog.csdn.net/qq_54499870/article/details/127974826