热门标签
热门文章
- 1【Linux更新驱动、cuda和cuda toolkit】_linux系统如何更新主机的cuda版本
- 2新能源汽车2022智能化，感知方案的终极答案是？
- 3使用rust学习基本算法（四）
- 4C# Stopwatch计时器 记录方法执行时间_stopwatch stopwatch = new stopwatch();
- 5blinker小白入门学习_esp32_#include
- 6每个私域运营者都必须掌握的 5 大关键流量运营核心打法！
- 7精准测试：代码覆盖率与测试覆盖率
- 8像素与分辨率_像素与分辨率对照表
- 9「iOS」怎么修改去掉Navigation Bar上的返回按钮文本颜色,箭头颜色以及导航栏按钮的颜色_消除颜色type_navigation_bar
- 10如何快速开发一个自己的微信小程序_小程序怎么开发
当前位置: article > 正文
Pytorch学习笔记（二）——使用pytorch实现BP神经网络拟合函数（附python和C++实现)_bp神经网络pytorch
作者：凡人多烦事01 | 2024-05-02 08:56:25
赞
踩
bp神经网络pytorch
使用BP神经网络拟合函数
最近学习bp神经网络，但是网上的代码很多都是做分类决策，我们要拟合函数需要对代码进行修改，进行回归预测，修改思路就是将输出层的激活函数改为f(x)=x,并且对反向传播过程中更改隐藏层到输出层的权重公式进行修改。
生成测试数据程序。
贴几个参考的博文：
神经网络实现连续型变量的回归预测（python)
BP神经网络与Python实现
C++实现的BP神经网络（代码与详解）
# 生成测试数据
import numpy as np
import pandas as pd
import math
if __name__ == "__main__":
# 训练集和验证集样本总个数
sample = 100
path='C:/Users/Desktop/data/'
train_data_path = path+'train.csv'
test_data_path = path+'test.csv'
# 构造生成数据的模型,全部置0，获取空列表
X1 = np.zeros((sample, 1))
X2 = np.zeros((sample, 1))
X3 = np.zeros((sample, 1))
#生成随机的sigama1 sigama2 sigama3 全部置0，获取空列表
Z1=np.zeros((sample, 1))
Z2=np.zeros((sample, 1))
Z3=np.zeros((sample, 1))
#生成随机数
Z1[:, 0] = np.random.normal(-4,2, sample) #正态分布随机数
Z2[:, 0] = np.random.normal(-2,0, sample) #正态分布随机数
Z3[:, 0] = np.random.uniform(0,2,sample) #均匀分布随机数
#生成固定的随机数，测试固定sigama值与随机的区别
c1=np.random.normal(-4,2)
c2=np.random.normal(-2,0)
c3=np.random.uniform(0,2)
i=0
#生成符合x1^2+x2^2+x3^2<=10的数据
while(i<sample):
x1=np.random.normal(1, 1)
x2=np.random.normal(2, 1)
x3=np.random.normal(3, 1)
if((x1+x2+x3)<=10):
X1[i]=x1
X2[i]=x2
X3[i]=x3
i=i+1
#生成空Y值列表
Y = np.zeros((sample, 1))
#循环求Y值
for i in range(sample):
Y[i] = （abs(X1[i] - c1) + abs(X2[i] - c2) + abs(X3[i] +c3))）**2 #生成固定参数Y值
# 将所有生成的数据放到data里面
data = np.zeros((sample, 4))
data[:, 0] = X1[:, 0]
data[:, 1] = X2[:, 0]
data[:, 2] = X3[:, 0]
data[:, 3] = Y[:, 0]
# 将data分成测试集和训练集 80%的训练集 20%测试集
num_traindata = int(0.8*sample)
# 将训练数据保存
traindata = pd.DataFrame(data[0:num_traindata, :], columns=['x1', 'x2', 'x3', 'y'])
traindata.to_csv(train_data_path, index=False)
print('训练数据保存在: ', train_data_path)
# 将验证数据保存
test_data = pd.DataFrame(data[num_traindata:, :], columns=['x1', 'x2', 'x3', 'y'])
test_data.to_csv(test_data_path, index=False)
print('验证数据保存在: ', test_data_path)
- 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
import torch
import torch.nn as nn
import pandas as pd
class Net(nn.Module):
def __init__(self,n_input,n_hidden,n_output):
super(Net,self).__init__()
self.hidden1 = nn.Linear(n_input,n_hidden) #此为输入层到隐藏层 输入为3 输出为6
self.predict = nn.Linear(n_hidden,n_output) #此为隐藏层到输出层 输入为6 输出为1
def forward(self,input):
out = self.hidden1(input) #隐藏层加权
out = torch.sigmoid(out)
#relu(out) #激活函数对加权后的数据进行操作
out =self.predict(out) #输出结果
return out
if __name__ == "__main__":
#读取数据
path = 'C:/Users/Desktop/data/'
train_data_path = path + 'train.csv'
validate_data_path = path + 'test.csv'
dt=pd.read_csv(train_data_path)
dt.head()
dataset=dt.values
X=dataset[:,:3].astype(float)
Y=dataset[:, -1].astype(float)
#将数据转换为tensor
x, y = (torch.tensor(X), torch.tensor(Y))
x = x.to(torch.float32)
y=y.to(torch.float32)
#定义一个输入神经元为3 隐藏层神经元为6 输出神经元为1的bp神经网络
net = Net(3, 10, 1)
print(net)
optimizer = torch.optim.SGD(net.parameters(), lr=0.1)
#定义损失函数 MSELoss的函数为均方误差函数 (1/n)*(y1-y2)^2
loss_func = torch.nn.MSELoss()
for t in range(500):
prediction = net(x)
print(prediction[0])
loss = loss_func(prediction, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('Train Epoch:{}\tLoss:{:.6f}'.format(t+1,loss.item()))
- 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
python代码
from __future__ import division
import math
import random
import pandas as pd
import numpy as np
random.seed(0)
# 生成区间[a, b)内的随机数
def rand(a, b):
return (b - a) * random.random() + a
# 生成大小 I*J 的矩阵，默认零矩阵
def makeMatrix(I, J, fill=0.0):
m = []
for i in range(I):
m.append([fill] * J)
return m
# 函数 sigmoid
def sigmoid(x):
return 1.0 / (1.0 + math.exp(-x))
# 函数 sigmoid 的导数
def dsigmoid(x):
return x * (1 - x)
class NN:
""" BP神经网络 """
def __init__(self, ni, nh, no):
# 输入层、隐藏层、输出层的节点（数）
self.ni = ni + 1 # 增加一个偏差节点
self.nh = nh + 1
self.no = no
# 激活神经网络的所有节点（向量）
self.ai = [1.0] * self.ni
self.ah = [1.0] * self.nh
self.ao = [1.0] * self.no
# 建立权重（矩阵）
self.wi = makeMatrix(self.ni, self.nh)
self.wo = makeMatrix(self.nh, self.no)
# 设为随机值
for i in range(self.ni):
for j in range(self.nh):
self.wi[i][j] = rand(-0.2, 0.2)
for j in range(self.nh):
for k in range(self.no):
self.wo[j][k] = rand(-2, 2)
'''前向传播'''
def update(self, inputs):
if len(inputs) != self.ni - 1:
raise ValueError('与输入层节点数不符！')
# 激活输入层
for i in range(self.ni - 1):
self.ai[i] = inputs[i]
# 激活隐藏层
for j in range(self.nh - 1):
sum = 0.0
for i in range(self.ni):
sum = sum + self.ai[i] * self.wi[i][j]
self.ah[j] = sigmoid(sum)
# 激活输出层
for k in range(self.no):
sum = 0.0
for j in range(self.nh):
sum = sum + self.ah[j] * self.wo[j][k]
self.ao[k] = sigmoid(sum)
return self.ao
""" 反向传播 """
def backPropagate(self, targets, lr):
# 计算输出层的误差
output_deltas = [0.0] * self.no
for k in range(self.no):
error = targets[k] - self.ao[k]
output_deltas[k] = dsigmoid(self.ao[k]) * error
# 计算隐藏层的误差
hidden_deltas = [0.0] * self.nh
for j in range(self.nh):
error = 0.0
for k in range(self.no):
error = error + output_deltas[k] * self.wo[j][k]
hidden_deltas[j] = dsigmoid(self.ah[j]) * error
# 更新输出层权重
for j in range(self.nh):
for k in range(self.no):
change = output_deltas[k] * self.ah[j]
self.wo[j][k] = self.wo[j][k] + lr * change
# 更新输入层权重
for i in range(self.ni):
for j in range(self.nh):
change = hidden_deltas[j] * self.ai[i]
self.wi[i][j] = self.wi[i][j] + lr * change
# 计算误差
error = 0.0
for k in range(self.no):
error += 0.5 * (targets[k] - self.ao[k]) ** 2
return error
def test(self, patterns):
count = 0
x = patterns[:,0:3]
y = patterns[:,3:4]
for p in range(len(patterns)):
targets = y[p]
result = self.update(x[p])
print(x[p], ':', targets, '->', result)
count += (targets == result)
accuracy = float(count / len(patterns))
print('accuracy: %-.9f' % accuracy)
def weights(self):
print('输入层权重:')
for i in range(self.ni):
print(self.wi[i])
print()
print('输出层权重:')
for j in range(self.nh):
print(self.wo[j])
def train(self, patterns, iterations=1000, lr=0.1):
# lr: 学习速率(learning rate)
count = 0
x = patterns[:,0:3]
y = patterns[:,3:4]
for i in range(iterations):
error = 0.0
for p in range(len(patterns)):
inputs = x[p]
targets = y[p]
self.update(inputs)
error = error + self.backPropagate(targets, lr)
if i % 100 == 0:
print('error: %-.9f' % error)
def iris():
df = pd.read_csv('train.csv', encoding='utf-8')
'''
# 读取数据
raw = pd.read_csv('train.csv')
raw_data = raw.values
raw_feature = raw_data[0:, 0:3]
for i in range(len(raw_feature)):
ele = []
ele.append(list(raw_feature[i]))
if raw_data[i][3] == 'Iris-setosa':
ele.append([1, 0, 0])
elif raw_data[i][4] == 'Iris-versicolor':
ele.append([0, 1, 0])
else:
ele.append([0, 0, 1])
data.append(ele)
'''
# 读取数据
raw = df[['x1', 'x2', 'x3','y']]
data = np.array(raw)
# 随机排列数据
# random.shuffle(data)
training = data[0:100]
test = data[101:150]
nn = NN(3, 5, 1)
nn.train(training, iterations=10000)
nn.weights()
nn.test(test)
if __name__ == '__main__':
iris()
- 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
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
C++代码
#include <iostream>
#include <cmath>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <string>
#include <cstring>
#include <fstream>
#include <iomanip>//设置精度
#include <random>
using namespace std;
#define INNODE 3 // 输入结点数
#define HIDENODE 6 // 隐含结点数
#define OUTNODE 1 // 输出结点数
#define LEARNINGRATE 0.9// 学习速率（注意：越高虽然越快 也容易误差较大）
#define SAMPLE 100
/**
* 输入层节点
*/
typedef struct inputNode {
double value; // 输入值
std::vector<double> weight // 输入层单个节点对下一层每个节点的权值
, wDeltaSum; // 单个加权的不同样本和
}InputNode;
/**
* 输出层节点
*/
typedef struct outputNode {
double o_value // 节点最终值 经过偏移与激活函数后的值
, rightout // 正确输出值
, bias // 偏移量 每个节点只有一个
, bDeltaSum; // 反向传播时 经过计算后的偏移量需要改变的值 因为有多个样本所以是sum
}OutputNode;
/**
* 隐含层节点
*/
typedef struct hiddenNode {
double o_value // 节点最终值 经过偏移与激活函数后的值
, bias // 偏移量 每个节点只有一个
, bDeltaSum; // 反向传播时 经过计算后的偏移量需要改变的值 因为有多个样本所以是sum
std::vector<double> weight // 隐藏层单个节点对下一层每个节点的加权值
, wDeltaSum; // 单个加权的不同样本和
}HiddenNode;
/**
* 单个样本
*/
typedef struct sample {
std::vector<double> in // 输入层value的迭代器 里面的数据有输入层节点数个（输入层每个节点的value值 代表一份样本数据中 一个输入属性的值）
, out; // 输出层rightout的迭代器 里面的数据也有输出层层节点数个（输出层每个节点的rightout值 代表一份样本数据 应该输出属性的正确值）
}Sample;
/**
* BP神经网络
*/
/**
* 工具类
*/
class Util
{
public:
// 获得txt文件中准备的数据
std::vector<double> getFileData(char* fileName);
};
vector<double> Util::getFileData(char* fileName) {
vector<double> res;
ifstream input(fileName);
if (!input) {
return res;
}
string buff;
while (getline(input, buff)) {
char* datas = (char*)buff.c_str();
const char* spilt = " ";
// strtok字符串拆分函数
char* data = strtok(datas, spilt);
while (data != NULL) {
// atof是stdlib头文件下转化字符串为数字的函数
res.push_back(atof(data));
// NULL代表从上次没拆分完地方继续拆
data = strtok(NULL, spilt);
}
}
input.close();
return res;
}
class BpNet {
public:
BpNet(); // 构造函数 用来初始化加权和偏移
void fp(); // 单个样本前向传播
void bp(); // 单个样本后向传播
void doTraining(std::vector<Sample> sampleGroup, double threshold, int mostTimes); // 训练（更新 weight, bias）
void afterTrainTest(std::vector<Sample>& testGroup); // 神经网络学习后进行预测
void setInValue(std::vector<double> inValue); // 设置学习样本输入
void setOutRightValue(std::vector<double> outRightValue); // 设置学习样本输出
public://设置成public就不用get、set麻烦
double error; //误差率
InputNode* inputLayer[INNODE]; // 输入层（任何模型都只有一层）
OutputNode* outputLayer[OUTNODE]; // 输出层（任何模型都只有一层）
HiddenNode* hiddenLayer[HIDENODE]; // 隐含层（我们这个只有一个隐藏层所以一维数组 但如果有多层是二维数组）
};
inline double getRandom() {
return ((2.0*(double)rand() / RAND_MAX) - 1);
}
/**
* sigmoid 函数（激活函数 要保证单调 且只有一个变量）
*/
inline double sigmoid(double x) {
// 一般bp用作分类的话都用该函数
double ans = 1.0 / (1.0 + exp(-x));
return ans;
}
/**
* 初始化（给加权或者偏移赋初值）
*/
BpNet::BpNet() {
srand((unsigned)time(NULL));
// error初始值，只要能保证大于阀值进入训练就可以
error = 100.f;
/*
* 初始化输入层每个节点对下一层每个节点的加权
*/
for (int i = 0; i < INNODE; i++) {
inputLayer[i] = new InputNode();
for (int j = 0; j < HIDENODE; j++) {
inputLayer[i]->weight.push_back(getRandom());
inputLayer[i]->wDeltaSum.push_back(0.f);
}
}
/*
* 初始化隐藏层每个节点对下一层每个节点的加权
* 初始化隐藏层每个节点的偏移
*/
for (int i = 0; i < HIDENODE; i++) {
hiddenLayer[i] = new HiddenNode();
hiddenLayer[i]->bias = getRandom();
// 初始化加权
for (int j = 0; j < OUTNODE; j++) {
hiddenLayer[i]->weight.push_back(getRandom());
hiddenLayer[i]->wDeltaSum.push_back(0.f);
}
}
/*
* 初始化输出层每个节点的偏移
*/
for (int i = 0; i < OUTNODE; i++) {
outputLayer[i] = new OutputNode();
outputLayer[i]->bias = getRandom();
}
}
/**
* 正向传播 获取一个样本从输入到输出的结果
*/
void BpNet::fp() {
/*
* 隐藏层向输入层获取数据
*/
// 遍历隐藏层节点
for (int i = 0; i < HIDENODE; i++) {
double sum = 0.f;
// 遍历输入层每个节点
for (int j = 0; j < INNODE; j++) {
sum += inputLayer[j]->value * inputLayer[j]->weight[i];
}
// 增加偏移
sum += hiddenLayer[i]->bias;
// 调用激活函数 设置o_value
hiddenLayer[i]->o_value = sigmoid(sum);
}
/*
* 输出层向隐藏层获取数据
*/
// 遍历输出层节点
for (int i = 0; i < OUTNODE; i++) {
double sum = 0.f;
// 遍历隐藏层节点
for (int j = 0; j < HIDENODE; j++) {
sum += hiddenLayer[j]->o_value * hiddenLayer[j]->weight[i];
}
sum += outputLayer[i]->bias;
outputLayer[i]->o_value = sum; //第一个修改点
}
}
/**
* 反向传播 从输出层再反向
*
* 该方法目的是返回：多个样本加权应该变化值的和【wDeltaSum】、多个样本偏移应该变化值的和【bDeltaSum】
* 在训练时根据样本数变化值的求平均值 用该平均值修改加权、偏移
*
*/
void BpNet::bp() {
/*
* 求误差值error
*/
for (int i = 0; i < OUTNODE; i++) {
double tmpe = fabs(outputLayer[i]->o_value - outputLayer[i]->rightout);
// 计算误差 参照上面第一个公式
error += tmpe * tmpe / 2;
}
/*
* 求输出层偏移的变化值
*/
int i = 0;
for (i = 0; i < OUTNODE; i++) {
// 偏移应该变化的值 参照b2公式
double bDelta = (-1) * (outputLayer[i]->rightout - outputLayer[i]->o_value) ;
outputLayer[i]->bDeltaSum += bDelta;
//cout << "正确值：" << outputLayer[i]->rightout << "预测值：" << outputLayer[i]->o_value<<endl;
}
/*
* 求对输出层加权的变化值
*/
for (int i = 0; i < HIDENODE; i++) {
for (int j = 0; j < OUTNODE; j++) {
// 加权应该变化的值 参照w9公式
double wDelta = (-1) * (outputLayer[j]->rightout - outputLayer[j]->o_value) * hiddenLayer[i]->o_value;
hiddenLayer[i]->wDeltaSum[j] += wDelta;
}
}
/*
* 求隐藏层偏移
*/
for (int i = 0; i < HIDENODE; i++) {
double sum = 0; // 因为是遍历输出层节点 不可以确定有多少个输出节点 参照b1公式的第一个公因式
for (int j = 0; j < OUTNODE; j++) {
sum += (-1) * (outputLayer[j]->rightout - outputLayer[j]->o_value) * hiddenLayer[i]->weight[j];
}
// 参照公式b1
hiddenLayer[i]->bDeltaSum += (sum * hiddenLayer[i]->o_value * (1 - hiddenLayer[i]->o_value));
}
/*
* 求输入层对隐藏层的加权变化
*/
for (int i = 0; i < INNODE; i++) {
// 从公式b1和w1可以看出 两个公式是有公因式 所以这部分代码相同
double sum = 0;
for (int j = 0; j < HIDENODE; j++) {
for (int k = 0; k < OUTNODE; k++) {
sum += (-1) * (outputLayer[k]->rightout - outputLayer[k]->o_value) * hiddenLayer[j]->weight[k];
}
// 参照公式w1
inputLayer[i]->wDeltaSum[j] += (sum * hiddenLayer[j]->o_value * (1 - hiddenLayer[j]->o_value) * inputLayer[i]->value);
}
}
}
/**
* 进行训练 参照上面最后修改的公式
*/
void BpNet::doTraining(vector<Sample> sampleGroup, double threshold, int mostTimes) {
int sampleNum = sampleGroup.size();
int trainTimes = 0;
bool isSuccess = true;
while (error >= threshold) {
// 判断是否超过最大训练次数
if (trainTimes > mostTimes) {
isSuccess = false;
break;
}
cout << "训练次数:" << trainTimes++ << "\t\t" << "当前误差: " << error << endl;
error = 0.f;
// 初始化输入层加权的delta和
for (int i = 0; i < INNODE; i++) {
inputLayer[i]->wDeltaSum.assign(inputLayer[i]->wDeltaSum.size(), 0.f);
}
// 初始化隐藏层加权和偏移的delta和
for (int i = 0; i < HIDENODE; i++) {
hiddenLayer[i]->wDeltaSum.assign(hiddenLayer[i]->wDeltaSum.size(), 0.f);
hiddenLayer[i]->bDeltaSum = 0.f;
}
// 初始化输出层的偏移和
for (int i = 0; i < OUTNODE; i++) {
outputLayer[i]->bDeltaSum = 0.f;
}
// 完成所有样本的调用与反馈
for (int iter = 0; iter < sampleNum; iter++) {
setInValue(sampleGroup[iter].in);
setOutRightValue(sampleGroup[iter].out);
fp();
bp();
}
cout << "正确值：" << outputLayer[0]->rightout << "预测值：" << outputLayer[0]->o_value << endl;
// 修改输入层的加权
for (int i = 0; i < INNODE; i++) {
for (int j = 0; j < HIDENODE; j++) {
//每一个加权的和都是所有样本累积的 所以要除以样本数
inputLayer[i]->weight[j] -= LEARNINGRATE * inputLayer[i]->wDeltaSum[j] / sampleNum;
}
}
// 修改隐藏层的加权和偏移
for (int i = 0; i < HIDENODE; i++) {
// 修改每个节点的偏移 因为一个节点就一个偏移 所以不用在节点里再遍历
hiddenLayer[i]->bias -= LEARNINGRATE * hiddenLayer[i]->bDeltaSum / sampleNum;
// 修改每个节点的各个加权的值
for (int j = 0; j < OUTNODE; j++) {
hiddenLayer[i]->weight[j] -= LEARNINGRATE * hiddenLayer[i]->wDeltaSum[j] / sampleNum;
}
}
//修改输出层的偏移
for (int i = 0; i < OUTNODE; i++) {
outputLayer[i]->bias -= LEARNINGRATE * outputLayer[i]->bDeltaSum / sampleNum;
}
}
if (isSuccess) {
cout << endl << "训练成功!!!" << "\t\t" << "最终误差: " << error << endl << endl;
}
else {
cout << endl << "训练失败! 超过最大次数!" << "\t\t" << "最终误差: " << error << endl << endl;
}
}
/**
* 训练后进行测试使用
*/
void BpNet::afterTrainTest(vector<Sample>& testGroup) {
int testNum = testGroup.size();
for (int iter = 0; iter < testNum; iter++) {
// 把样本输出清空
testGroup[iter].out.clear();
setInValue(testGroup[iter].in);
// 从隐藏层从输入层获取数据
for (int i = 0; i < HIDENODE; i++) {
double sum = 0.f;
for (int j = 0; j < INNODE; j++) {
sum += inputLayer[j]->value * inputLayer[j]->weight[i];
}
sum += hiddenLayer[i]->bias;
hiddenLayer[i]->o_value = sigmoid(sum);
}
// 输出层从隐藏层获取数据
for (int i = 0; i < OUTNODE; i++) {
double sum = 0.f;
for (int j = 0; j < HIDENODE; j++) {
sum += hiddenLayer[j]->o_value * hiddenLayer[j]->weight[i];
}
sum += outputLayer[i]->bias;
outputLayer[i]->o_value = sigmoid(sum);
// 设置输出的值
testGroup[iter].out.push_back(outputLayer[i]->o_value);
}
}
}
/**
* 给输入层每个节点设置输入值 每个样本进行训练时都要调用
*/
void BpNet::setInValue(vector<double> sampleIn) {
// 对应一次样本 输入层每个节点的输入值
for (int i = 0; i < INNODE; i++) {
inputLayer[i]->value = sampleIn[i];
}
}
/**
* 给输出层每个节点设置正确值 每个样本进行训练时都要调用
*/
void BpNet::setOutRightValue(vector<double> sampleOut) {
// 对应一次样本 输出层层每个节点的正确值
for (int i = 0; i < OUTNODE; i++) {
outputLayer[i]->rightout = sampleOut[i];
}
}
void getInput(double& threshold, int& mostTimes); // 获得输入的阀值和误差大小
vector<Sample> getTrianData(); // 从文件获取训练数据 没获取到直接退出
vector<Sample> getTestData(); // 从文件获取测试数据 没获取到直接退出
void showTest(vector<Sample>testGroup); // 输出测试数据的结果
void getInput(double& threshold, int& mostTimes) {
cout << "训练及测试数据已从文件读入" << endl << endl;
cout << "请输入XOR训练最大误差："; //0.0001最好
cin >> threshold;
cout << "请输入XOR训练最大次数：";
cin >> mostTimes;
}
void showTest(vector<Sample> testGroup) {
// 输出测试结果
cout << "系统测试数据:" << endl;
for (int i = 0; i < testGroup.size(); i++) {
for (int j = 0; j < testGroup[i].in.size(); j++) {
cout << testGroup[i].in[j] << "\t";
}
cout << "-- XOR训练结果 :";
for (int j = 0; j < testGroup[i].out.size(); j++) {
cout << testGroup[i].out[j] << "\t";
}
cout << endl;
}
cout << endl << endl;
system("pause");
}
vector<Sample> getTestData() {
Util util;
vector<double> testData = util.getFileData("test.txt");
if (testData.size() == 0) {
cout << "载入测试数据失败！" << endl;
exit(0);
}
const int groups = testData.size() / 2;
// 创建测试数据
Sample testInOut[101];
for (int i = 0, index = 0; i < groups; i++) {
for (int j = 0; j < 2; j++) {
testInOut[i].in.push_back(testData[index++]);
}
}
// 初始化数据
return vector<Sample>(testInOut, testInOut + groups);
}
vector<Sample> getTrianData() {
Util util;
vector<double> trainData = util.getFileData("data.txt");
if (trainData.size() == 0) {
cout << "载入训练数据失败！" << endl;
exit(0);
}
const int groups = SAMPLE;
cout << groups<<endl;
// 创建样本数据
Sample trainInOut[SAMPLE];
// 把vector设置给样本Sample
for (int i = 0, index = 0; i < groups; i++) {
for (int j = 0; j < 4; j++) {
if (j % 4 != 3) {
trainInOut[i].in.push_back(trainData[index++]);
}
else {
trainInOut[i].out.push_back(trainData[index++]);
}
}
}
// 初始化录入的个数据
return vector<Sample>(trainInOut, trainInOut + groups);
}
int main() {
// 准备所有数据
BpNet bpNet;
vector<Sample> sampleGroup = getTrianData();
//vector<Sample> testGroup = getTestData();
double threshold; // 设定的阀值 即为设定的误差
int mostTimes; // 最大训练次数
// 获取输入 并提示数据已经录入
//getInput(threshold, mostTimes);
threshold = 0.05;
mostTimes = 100;
// 进行训练
bpNet.doTraining(sampleGroup, threshold, mostTimes);
// 训练后测试录入的数据 这里的参数是引用
//bpNet.afterTrainTest(testGroup);
// 打印提前录入数据的测试结果
//showTest(testGroup);
cout << "程序结束" << endl;
return 0;
}
- 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
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
- 218
- 219
- 220
- 221
- 222
- 223
- 224
- 225
- 226
- 227
- 228
- 229
- 230
- 231
- 232
- 233
- 234
- 235
- 236
- 237
- 238
- 239
- 240
- 241
- 242
- 243
- 244
- 245
- 246
- 247
- 248
- 249
- 250
- 251
- 252
- 253
- 254
- 255
- 256
- 257
- 258
- 259
- 260
- 261
- 262
- 263
- 264
- 265
- 266
- 267
- 268
- 269
- 270
- 271
- 272
- 273
- 274
- 275
- 276
- 277
- 278
- 279
- 280
- 281
- 282
- 283
- 284
- 285
- 286
- 287
- 288
- 289
- 290
- 291
- 292
- 293
- 294
- 295
- 296
- 297
- 298
- 299
- 300
- 301
- 302
- 303
- 304
- 305
- 306
- 307
- 308
- 309
- 310
- 311
- 312
- 313
- 314
- 315
- 316
- 317
- 318
- 319
- 320
- 321
- 322
- 323
- 324
- 325
- 326
- 327
- 328
- 329
- 330
- 331
- 332
- 333
- 334
- 335
- 336
- 337
- 338
- 339
- 340
- 341
- 342
- 343
- 344
- 345
- 346
- 347
- 348
- 349
- 350
- 351
- 352
- 353
- 354
- 355
- 356
- 357
- 358
- 359
- 360
- 361
- 362
- 363
- 364
- 365
- 366
- 367
- 368
- 369
- 370
- 371
- 372
- 373
- 374
- 375
- 376
- 377
- 378
- 379
- 380
- 381
- 382
- 383
- 384
- 385
- 386
- 387
- 388
- 389
- 390
- 391
- 392
- 393
- 394
- 395
- 396
- 397
- 398
- 399
- 400
- 401
- 402
- 403
- 404
- 405
- 406
- 407
- 408
- 409
- 410
- 411
- 412
- 413
- 414
- 415
- 416
- 417
- 418
- 419
- 420
- 421
- 422
- 423
- 424
- 425
- 426
- 427
- 428
- 429
- 430
- 431
- 432
- 433
- 434
- 435
- 436
- 437
- 438
- 439
- 440
- 441
- 442
- 443
- 444
- 445
- 446
- 447
- 448
- 449
- 450
- 451
- 452
- 453
- 454
- 455
- 456
- 457
- 458
- 459
- 460
- 461
- 462
- 463
- 464
- 465
- 466
- 467
- 468
- 469
- 470
- 471
- 472
- 473
- 474
- 475
- 476
- 477
- 478
- 479
- 480
- 481
- 482
- 483
- 484
- 485
- 486
- 487
- 488
- 489
- 490
- 491
- 492
- 493
- 494
- 495
- 496
- 497
- 498
- 499
- 500
- 501
- 502
- 503
- 504
- 505
- 506
- 507
- 508
- 509
- 510
- 511
- 512
- 513
- 514
- 515
- 516
- 517
- 518
- 519
- 520
- 521
- 522
- 523
- 524
- 525
- 526
- 527
- 528
- 529
- 530
- 531
- 532
- 533
- 534
- 535
- 536
- 537
- 538
- 539
- 540
- 541
- 542
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/523213
推荐阅读
相关标签
