【算法基础】基于pytorch的BP神经网络算法代码+数据集_bp神经网络pytorch代码

实现功能：

1、数据回归：基于多输入单输出数据集
2、代码最后使用matplotlib绘制了 [训练次数-loss值] 折线图进行训练结果展示

注：

1、代码亲测可成功运行；
2、以下代码通过cuda调用GPU训练，如果cuda报错则需检查GPU训练环境配置，例如pytorch是否为GPU版本、cuda版本是否适配当前显卡驱动版本等。
3、数据集：
链接：https://pan.baidu.com/s/1VC83_A0V0-N4kZhiAXEs6w?pwd=0000
提取码：0000
本文重点在于介绍算法，该数据集质量不算优质。
算法拟合能力没有问题，但基于此数据集可能存在非凸优化问题，结果有概率呈现局部最优状态，导致收敛效果差，所以读者下一阶段可以尝试学习一些能有效规避局部最优问题的算法。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import torch
from sklearn import preprocessing


features = pd.read_excel('number_list.xlsx')  # 设置文件夹地址
labels_train = np.array(features['输出'])  # 制作标签，用于比对训练结果
fea_train = features.drop(columns=['输出'])  # 在特征数据集中去掉label
# df.drop(label, axis=0)
# label：要删除的列或者行，如果要删除多个，传入列表
# axis:轴的方向，0为行，1为列，默认为0
fea_train = np.array(fea_train)  # 转换为ndarray格式

# 数据标准化操作：(x-均值μ) / 标准差σ ，使数据关于原点对称，提升训练效率
input_features = preprocessing.StandardScaler().fit_transform(fea_train)  # fit：求出均值和标准差 transform：求解

# 设定神经网络的输入参数、隐藏层神经元、输出参数的个数
input_size = input_features.shape[1]  # 设定输入特征个数为7
# np.shape[1]
# 0为行，1为列，默认为0
# 在此表格中因为每行为各样本的值，每列为不同的特征分类，所以此处0表示样本数，1表示特征数
hidden_size = 64  # 设定隐藏层包含64个神经元
output_size = 1  # 设定输出特征个数为1
batch_size = 2  # 每一批迭代的特征数量

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")  # 选择使用GPU训练

my_nn = torch.nn.Sequential(
    torch.nn.Linear(input_size, hidden_size).to(device),  # 输入层 → 第一层
    torch.nn.Sigmoid().to(device),
    torch.nn.Linear(hidden_size, hidden_size).to(device),  # 第一层 → 第二层
    torch.nn.Sigmoid().to(device),
    torch.nn.Linear(hidden_size, hidden_size).to(device),  # 第二层 → 第三层
    torch.nn.Sigmoid().to(device),
    torch.nn.Linear(hidden_size, hidden_size).to(device),  # 第三层 → 第四层
    torch.nn.Sigmoid().to(device),
    torch.nn.Linear(hidden_size, output_size).to(device)  # 第四层 → 输出层
).to(device)
cost = torch.nn.MSELoss(reduction='mean').to(device)
optimizer = torch.optim.Adam(my_nn.parameters(), lr=0.01)

# 训练网络
losses = []
for i in range(300):
    batch_loss = []
    # 采用MINI-Batch的方法进行训练
    for start in range(0, len(input_features), batch_size):
        end = start + batch_size if start + batch_size < len(input_features) else len(input_features)
        x = torch.tensor(input_features[start:end], dtype=torch.float, requires_grad=True).to(device)
        y = torch.tensor(labels_train[start:end], dtype=torch.float, requires_grad=True).to(device)
        prediction = my_nn(x).to(device)
        loss = cost(prediction, y).to(device)
        optimizer.zero_grad()
        loss.backward(retain_graph=True)
        optimizer.step()
        batch_loss.append(loss.data.cpu().numpy())

    if i % 10 == 0:
        losses.append(np.mean(batch_loss))
        print(losses)
        print(i, np.mean(batch_loss))

# 保存模型
torch.save(my_nn, 'BP.pt')

# 绘制图像
dev_x = [i * 10 for i in range(20)]
plt.xlabel('step count')
plt.ylabel('loss')
plt.xlim((0, 200))
plt.ylim((0, 1000))
plt.plot(dev_x, losses)
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

调用训练好的模型：
因为之前模型使用GPU训练，所以调用时也要使用GPU，即：需要配置device

import torch

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
new = torch.load('BP.pt', map_location=lambda storage, loc: storage.cuda(0))

inp1 = [273, 82, 114, 210, 9, 904, 680]
input1 = torch.tensor(inp1, dtype=torch.float).to(device)
out1 = new(input1)
print(out1)

1
2
3
4
5
6
7
8
9
10