Pytorch学习笔记（二）——使用pytorch实现BP神经网络拟合函数（附python和C++实现)

使用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)

pytorch

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()))

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()

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;
	
	
}