bp网络模型c程序

⑴ BP神经网络的预测（回归）过程C语言程序

神经网络本质也是一种数据回归模型。我们举个简单的例子
y=ax^2+bx+c，
有三个系数要回归，如果只给你1～2组数据，你觉得能回归好吗？
考虑到样本本身有误差，为了防止过拟合（或过学习），一般要求神经网络的训练样本数是连接权系数（包括阈值）的2～3倍。你用了太多的连接权系数（包括阈值），即使效果不错，风险仍然很高。

⑵ BP神经网络

神经网络能很好地解决不同的机器学习问题。神经网络模型是许多逻辑单元按照不同层级组织起来的网络，每一层的输出变量都是下一层的输入变量。

上图显示了人工神经网络是一个分层模型，逻辑上可以分为三层：

输入层 ：输入层接收特征向量 x

输出层 ：输出层产出最终的预测 h

隐含层 ：隐含层介于输入层与输出层之间，之所以称之为隐含层，是因为当中产生的值并不像输入层使用的样本矩阵 X或者输出层用到的标签矩阵 y 那样直接可见。

下面引入一些标记法来帮助描述模型：

!$ a^{(j)}_{i} $ 代表第j层的第i个激活单元。 !$ heta^{(j)} $ 代表从第 j 层映射到第 j+1 层时的权重的矩阵，例如 !$ heta^{(1)} $ 代表从第一层映射到第二层的权重的矩阵。其尺寸为：以第 j+1层的激活单元数量为行数，以第 j 层的激活单元数加一为列数的矩阵。例如：上图所示的神经网络中 !$ heta^{(1)} $ 的尺寸为 3*4。

对于上图所示的模型，激活单元和输出分别表达为：

!$ a^{(2)}_{1} = g( heta^{(1)}_{10}x_0 + heta^{(1)}_{11}x_1 + heta^{(1)}_{12}x_2 + heta^{(1)}_{13}x_3 ) $

!$a^{(2)}_{2} = g( heta^{(1)}_{20}x_0 + heta^{(1)}_{21}x_1 + heta^{(1)}_{22}x_2 + heta^{(1)}_{23}x_3 ) $

!$a^{(2)}_{3} = g( heta^{(1)}_{30}x_0 + heta^{(1)}_{31}x_1 + heta^{(1)}_{32}x_2 + heta^{(1)}_{33}x_3 ) $

!$h_{ heta}{(x)} = g( heta^{(2)}_{10}a^{2}_{0} + heta^{(2)}_{11}a^{2}_{1} + heta^{(2)}_{12}a^{2}_{2} + heta^{(2)}_{13}a^{2}_{3} ) $

下面用向量化的方法以上面的神经网络为例，试着计算第二层的值：

对于多类分类问题来说:

我们可将神经网络的分类定义为两种情况:二类分类和多类分类。

二类分类： !$ S_{L} = 0,y = 0,y = 1$

多类分类： !$ S_{L} = k, y_{i} = 1表示分到第i类；(k>2)$

在神经网络中，我们可以有很多输出变量，我们的 !$h_{ heta}{(x)} $ 是一个维度为K的向量，并且我们训练集中的因变量也是同样维度的一个向量，因此我们的代价函数会比逻辑回归更加复杂一些，为： !$ h_{ heta}{(x)} in R^{K}(h_{ heta}{(x)})_{i} = i^{th} output$

我们希望通过代价函数来观察算法预测的结果与真实情况的误差有多大，唯一不同的是，对于每一行特征，我们都会给出K个预测，基本上我们可以利用循环，对每一行特征都预测K个不同结果，然后在利用循环在K个预测中选择可能性最高的一个，将其与y中的实际数据进行比较。

正则化的那一项只是排除了每一层 !$ heta_0$ 后，每一层的 矩阵的和。最里层的循环j循环所有的行（由 +1 层的激活单元数决定），循环i则循环所有的列，由该层（ !$ s_l$ 层）的激活单元数所决定。即： !$h_{ heta}{(x)}$ 与真实值之间的距离为每个样本-每个类输出的加和，对参数进行 regularization 的 bias 项处理所有参数的平方和。

由于神经网络允许多个隐含层，即各层的神经元都会产出预测，因此，就不能直接利用传统回归问题的梯度下降法来最小化 !$J( heta)$ ，而需要逐层考虑预测误差，并且逐层优化。为此，在多层神经网络中，使用反向传播算法（Backpropagation Algorithm）来优化预测，首先定义各层的预测误差为向量 !$ δ^{(l)} $

训练过程：

当我们对一个较为复杂的模型（例如神经网络）使用梯度下降算法时，可能会存在一些不容易察觉的错误，意味着，虽然代价看上去在不断减小，但最终的结果可能并不是最优解。

为了避免这样的问题，我们采取一种叫做梯度的数值检验（ Numerical Gradient Checking ）方法。这种方法的思想是通过估计梯度值来检验我们计算的导数值是否真的是我们要求的。

对梯度的估计采用的方法是在代价函数上沿着切线的方向选择离两个非常近的点然后计算两个点的平均值用以估计梯度。即对于某个特定的 ，我们计算出在 !$ heta - epsilon$ 处和 !$ heta + epsilon$ 的代价值（是一个非常小的值，通常选取 0.001），然后求两个代价的平均，用以估计在 !$ heta$ 处的代价值。

当 !$ heta$ 是一个向量时，我们则需要对偏导数进行检验。因为代价函数的偏导数检验只针对一个参数的改变进行检验，下面是一个只针对 !$ heta_1$ 进行检验的示例：

如果上式成立，则证明网络中BP算法有效，此时关闭梯度校验算法（因为梯度的近似计算效率很慢），继续网络的训练过程。

⑶ 建立BP神经网络地面沉降预测模型

基坑降水引起地面沉降的BP神经网络预测模型建模过程如下：

（1）样本选择

因基坑降水引起的地面沉降量和距离基坑的距离关系密切，因此建模选用“基坑降水引起沉降工程数据（第二类）”（见表4.1）中的相关数据作为样本进行学习训练和检验。

（2）BP神经网络结构设计

对于BP网络，对于任何在闭区间内的一个连续函数都可以用单隐层的BP网络逼近，因而一个三层BP网络就可以完成任意的n维到m维的映射。根据网络结构简单化的原则，确定采用三层BP网络结构，即输入层为沉降点距基坑的距离L（m）、等效压缩模量E（MPa）、水位降深H（m）和支护刚度n四个参数，输出层为地面累积沉降量（mm），隐层层数为1层。隐层的神经元数目选择是一个十分复杂的问题，往往需要根据设计者的经验和多次实验来确定，因而不存在一个理想的解析式来表示。隐单元的数目与问题的要求，与输入、输出单元的数目有直接的关系。隐单元数目太多会导致学习时间过长，误差不一定最佳，也会导致容错性差、不能识别以前没有看到的样本，因此一定存在一个最佳的隐单元数。研究通过一次编程比较了隐层神经元个数分别为5、10、15、20、25、30、40时训练速度及检验精度。

图4.2 BP神经网络程序框图

（3）网络训练及检验

BP网络采用梯度下降法来降低网络的训练误差，考虑到基坑降水地面沉降范围内沉降量变化幅度较小的特点，训练时以训练目标取0.001为控制条件，考虑到网络的结构比较复杂，神经元个数比较多，需要适当增加训练次数和学习速率，因此初始训练次数设为10000次，学习速率取0.1，中间层的神经元传递函数采用S型正切函数tansig，传输函数采用logsig，训练函数采用trainlm，选用38组数据中的33组作为训练样本，5组作为检验样本。

（4）网络实现及检验效果

使用MATLAB6.0编程建立基于BP神经网络的基坑降水地面沉降预测模型（程序代码见附件1），其训练误差及检验效果如下：

图4.3 训练误差曲线

图4.4 预测误差曲线

由图4.3、图4.4可见：样本数据收敛，训练误差较小，中间层神经单元个数为10时预测精度较好，误差小于20%，误差满足工程需求。

⑷ BP神经网络方法

人工神经网络是近几年来发展起来的新兴学科，它是一种大规模并行分布处理的非线性系统，适用解决难以用数学模型描述的系统，逼近任何非线性的特性，具有很强的自适应、自学习、联想记忆、高度容错和并行处理能力，使得神经网络理论的应用已经渗透到了各个领域。近年来，人工神经网络在水质分析和评价中的应用越来越广泛，并取得良好效果。在这些应用中，纵观应用于模式识别的神经网络，BP网络是最有效、最活跃的方法之一。

BP网络是多层前向网络的权值学习采用误差逆传播学习的一种算法（Error Back Propagation，简称BP）。在具体应用该网络时分为网络训练及网络工作两个阶段。在网络训练阶段，根据给定的训练模式，按照“模式的顺传播”→“误差逆传播”→“记忆训练”→“学习收敛”4个过程进行网络权值的训练。在网络的工作阶段，根据训练好的网络权值及给定的输入向量，按照“模式顺传播”方式求得与输入向量相对应的输出向量的解答（阎平凡，2000）。

BP算法是一种比较成熟的有指导的训练方法，是一个单向传播的多层前馈网络。它包含输入层、隐含层、输出层，如图4-4所示。

图4-4 地下水质量评价的BP神经网络模型

图4-4给出了4层地下水水质评价的BP神经网络模型。同层节点之间不连接。输入信号从输入层节点，依次传过各隐含层节点，然后传到输出层节点，如果在输出层得不到期望输出，则转入反向传播，将误差信号沿原来通路返回，通过学习来修改各层神经元的权值，使误差信号最小。每一层节点的输出只影响下一层节点的输入。每个节点都对应着一个作用函数（f）和阈值（a），BP网络的基本处理单元量为非线性输入-输出的关系，输入层节点阈值为0，且f（x）=x；而隐含层和输出层的作用函数为非线性的Sigmoid型（它是连续可微的）函数，其表达式为

f（x）=1/（1+e^-x） （4-55）

设有L个学习样本（X_k，O_k）（k=1，2，…，l），其中X_k为输入，O_k为期望输出，X_k经网络传播后得到的实际输出为Y_k，则Y_k与要求的期望输出O_k之间的均方误差为

区域地下水功能可持续性评价理论与方法研究

式中：M为输出层单元数；Y_k，p为第k样本对第p特性分量的实际输出；O_k，p为第k样本对第p特性分量的期望输出。

样本的总误差为

区域地下水功能可持续性评价理论与方法研究

由梯度下降法修改网络的权值，使得E取得最小值，学习样本对W_ij的修正为

区域地下水功能可持续性评价理论与方法研究

式中：η为学习速率，可取0到1间的数值。

所有学习样本对权值W_ij的修正为

区域地下水功能可持续性评价理论与方法研究

通常为增加学习过程的稳定性，用下式对W_ij再进行修正：

区域地下水功能可持续性评价理论与方法研究

式中：β为充量常量；W_ij（t）为BP网络第t次迭代循环训练后的连接权值；W_ij（t-1）为BP网络第t-1次迭代循环训练后的连接权值。

在BP网络学习的过程中，先调整输出层与隐含层之间的连接权值，然后调整中间隐含层间的连接权值，最后调整隐含层与输入层之间的连接权值。实现BP网络训练学习程序流程，如图4-5所示（倪深海等，2000）。

图4-5 BP神经网络模型程序框图

若将水质评价中的评价标准作为样本输入，评价级别作为网络输出，BP网络通过不断学习，归纳出评价标准与评价级别间复杂的内在对应关系，即可进行水质综合评价。

BP网络对地下水质量综合评价，其评价方法不需要过多的数理统计知识，也不需要对水质量监测数据进行复杂的预处理，操作简便易行，评价结果切合实际。由于人工神经网络方法具有高度民主的非线性函数映射功能，使得地下水水质评价结果较准确（袁曾任，1999）。

BP网络可以任意逼近任何连续函数，但是它主要存在如下缺点：①从数学上看，它可归结为一非线性的梯度优化问题，因此不可避免地存在局部极小问题；②学习算法的收敛速度慢，通常需要上千次或更多。

神经网络具有学习、联想和容错功能，是地下水水质评价工作方法的改进，如何在现行的神经网络中进一步吸取模糊和灰色理论的某些优点，建立更适合水质评价的神经网络模型，使该模型既具有方法的先进性又具有现实的可行性，将是我们今后研究和探讨的问题。

⑸ c语言实现*/遗传算法改进BP神经网络原理和算法实现怎么弄

遗传算法有相当大的引用。遗传算法在游戏中应用的现状在遗传编码时, 一般将瓦片的坐标作为基因进行实数编码, 染色体的第一个基因为起点坐标, 最后一个基因为终点坐标, 中间的基因为路径经过的每一个瓦片的坐标。在生成染色体时, 由起点出发, 随机选择当前结点的邻居节点中的可通过节点, 将其坐标加入染色体, 依此循环, 直到找到目标点为止, 生成了一条染色体。重复上述操作, 直到达到指定的种群规模。遗传算法的优点：1、遗传算法是以决策变量的编码作为运算对象，可以直接对集合、序列、矩阵、树、图等结构对象进行操作。这样的方式一方面有助于模拟生物的基因、染色体和遗传进化的过程，方便遗传操作算子的运用。另一方面也使得遗传算法具有广泛的应用领域，如函数优化、生产调度、自动控制、图像处理、机器学习、数据挖掘等领域。2、遗传算法直接以目标函数值作为搜索信息。它仅仅使用适应度函数值来度量个体的优良程度，不涉及目标函数值求导求微分的过程。因为在现实中很多目标函数是很难求导的，甚至是不存在导数的，所以这一点也使得遗传算法显示出高度的优越性。3、遗传算法具有群体搜索的特性。它的搜索过程是从一个具有多个个体的初始群体P(0)开始的，一方面可以有效地避免搜索一些不必搜索的点。另一方面由于传统的单点搜索方法在对多峰分布的搜索空间进行搜索时很容易陷入局部某个单峰的极值点，而遗传算法的群体搜索特性却可以避免这样的问题，因而可以体现出遗传算法的并行化和较好的全局搜索性。4、遗传算法基于概率规则，而不是确定性规则。这使得搜索更为灵活，参数对其搜索效果的影响也尽可能的小。5、遗传算法具有可扩展性，易于与其他技术混合使用。以上几点便是遗传算法作为优化算法所具备的优点。遗传算法的缺点：遗传算法在进行编码时容易出现不规范不准确的问题。

⑹ 求BP神经网络算法的C++源代码

// AnnBP.cpp: implementation of the CAnnBP class.
//
//////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "AnnBP.h"
#include "math.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CAnnBP::CAnnBP()
{
eta1=0.3;
momentum1=0.3;

}

CAnnBP::~CAnnBP()
{

}

double CAnnBP::drnd()
{
return ((double) rand() / (double) BIGRND);
}

/*** 返回-1.0到1.0之间的双精度随机数 ***/
double CAnnBP::dpn1()
{
return (double) (rand())/(32767/2)-1;
}

/*** 作用函数，目前是S型函数 ***/
double CAnnBP::squash(double x)
{
return (1.0 / (1.0 + exp(-x)));
}

/*** 申请1维双精度实数数组 ***/
double* CAnnBP::alloc_1d_dbl(int n)
{
double *new1;

new1 = (double *) malloc ((unsigned) (n * sizeof (double)));
if (new1 == NULL) {
AfxMessageBox("ALLOC_1D_DBL: Couldn't allocate array of doubles\n");
return (NULL);
}
return (new1);
}

/*** 申请2维双精度实数数组 ***/
double** CAnnBP::alloc_2d_dbl(int m, int n)
{
int i;
double **new1;

new1 = (double **) malloc ((unsigned) (m * sizeof (double *)));
if (new1 == NULL) {
AfxMessageBox("ALLOC_2D_DBL: Couldn't allocate array of dbl ptrs\n");
return (NULL);
}

for (i = 0; i < m; i++) {
new1[i] = alloc_1d_dbl(n);
}

return (new1);
}

/*** 随机初始化权值 ***/
void CAnnBP::bpnn_randomize_weights(double **w, int m, int n)
{
int i, j;
for (i = 0; i <= m; i++) {
for (j = 0; j <= n; j++) {
w[i][j] = dpn1();
}
}

}

/*** 0初始化权值 ***/
void CAnnBP::bpnn_zero_weights(double **w, int m, int n)
{
int i, j;

for (i = 0; i <= m; i++) {
for (j = 0; j <= n; j++) {
w[i][j] = 0.0;
}
}

}

/*** 设置随机数种子 ***/
void CAnnBP::bpnn_initialize(int seed)
{
CString msg,s;
msg="Random number generator seed:";
s.Format("%d",seed);
AfxMessageBox(msg+s);
srand(seed);
}

/*** 创建BP网络 ***/
BPNN* CAnnBP::bpnn_internal_create(int n_in, int n_hidden, int n_out)
{
BPNN *newnet;

newnet = (BPNN *) malloc (sizeof (BPNN));
if (newnet == NULL) {
printf("BPNN_CREATE: Couldn't allocate neural network\n");
return (NULL);
}

newnet->input_n = n_in;
newnet->hidden_n = n_hidden;
newnet->output_n = n_out;
newnet->input_units = alloc_1d_dbl(n_in + 1);
newnet->hidden_units = alloc_1d_dbl(n_hidden + 1);
newnet->output_units = alloc_1d_dbl(n_out + 1);

newnet->hidden_delta = alloc_1d_dbl(n_hidden + 1);
newnet->output_delta = alloc_1d_dbl(n_out + 1);
newnet->target = alloc_1d_dbl(n_out + 1);

newnet->input_weights = alloc_2d_dbl(n_in + 1, n_hidden + 1);
newnet->hidden_weights = alloc_2d_dbl(n_hidden + 1, n_out + 1);

newnet->input_prev_weights = alloc_2d_dbl(n_in + 1, n_hidden + 1);
newnet->hidden_prev_weights = alloc_2d_dbl(n_hidden + 1, n_out + 1);

return (newnet);

}

/* 释放BP网络所占地内存空间 */
void CAnnBP::bpnn_free(BPNN *net)
{
int n1, n2, i;

n1 = net->input_n;
n2 = net->hidden_n;

free((char *) net->input_units);
free((char *) net->hidden_units);
free((char *) net->output_units);

free((char *) net->hidden_delta);
free((char *) net->output_delta);
free((char *) net->target);

for (i = 0; i <= n1; i++) {
free((char *) net->input_weights[i]);
free((char *) net->input_prev_weights[i]);
}
free((char *) net->input_weights);
free((char *) net->input_prev_weights);

for (i = 0; i <= n2; i++) {
free((char *) net->hidden_weights[i]);
free((char *) net->hidden_prev_weights[i]);
}
free((char *) net->hidden_weights);
free((char *) net->hidden_prev_weights);

free((char *) net);
}

/*** 创建一个BP网络，并初始化权值***/
BPNN* CAnnBP::bpnn_create(int n_in, int n_hidden, int n_out)
{
BPNN *newnet;

newnet = bpnn_internal_create(n_in, n_hidden, n_out);

#ifdef INITZERO
bpnn_zero_weights(newnet->input_weights, n_in, n_hidden);
#else
bpnn_randomize_weights(newnet->input_weights, n_in, n_hidden);
#endif
bpnn_randomize_weights(newnet->hidden_weights, n_hidden, n_out);
bpnn_zero_weights(newnet->input_prev_weights, n_in, n_hidden);
bpnn_zero_weights(newnet->hidden_prev_weights, n_hidden, n_out);

return (newnet);

}

void CAnnBP::bpnn_layerforward(double *l1, double *l2, double **conn, int n1, int n2)
{
double sum;
int j, k;

/*** 设置阈值 ***/
l1[0] = 1.0;

/*** 对于第二层的每个神经元 ***/
for (j = 1; j <= n2; j++) {

/*** 计算输入的加权总和 ***/
sum = 0.0;
for (k = 0; k <= n1; k++) {
sum += conn[k][j] * l1[k];
}
l2[j] = squash(sum);
}
}

/* 输出误差 */
void CAnnBP::bpnn_output_error(double *delta, double *target, double *output, int nj, double *err)
{
int j;
double o, t, errsum;

errsum = 0.0;
for (j = 1; j <= nj; j++) {
o = output[j];
t = target[j];
delta[j] = o * (1.0 - o) * (t - o);
errsum += ABS(delta[j]);
}
*err = errsum;

}

/* 隐含层误差 */
void CAnnBP::bpnn_hidden_error(double *delta_h, int nh, double *delta_o, int no, double **who, double *hidden, double *err)
{
int j, k;
double h, sum, errsum;

errsum = 0.0;
for (j = 1; j <= nh; j++) {
h = hidden[j];
sum = 0.0;
for (k = 1; k <= no; k++) {
sum += delta_o[k] * who[j][k];
}
delta_h[j] = h * (1.0 - h) * sum;
errsum += ABS(delta_h[j]);
}
*err = errsum;
}

/* 调整权值 */
void CAnnBP::bpnn_adjust_weights(double *delta, int ndelta, double *ly, int nly, double **w, double **oldw, double eta, double momentum)
{
double new_dw;
int k, j;

ly[0] = 1.0;
for (j = 1; j <= ndelta; j++) {
for (k = 0; k <= nly; k++) {
new_dw = ((eta * delta[j] * ly[k]) + (momentum * oldw[k][j]));
w[k][j] += new_dw;
oldw[k][j] = new_dw;
}
}

}

/* 进行前向运算 */
void CAnnBP::bpnn_feedforward(BPNN *net)
{
int in, hid, out;

in = net->input_n;
hid = net->hidden_n;
out = net->output_n;

/*** Feed forward input activations. ***/
bpnn_layerforward(net->input_units, net->hidden_units,
net->input_weights, in, hid);
bpnn_layerforward(net->hidden_units, net->output_units,
net->hidden_weights, hid, out);

}

/* 训练BP网络 */
void CAnnBP::bpnn_train(BPNN *net, double eta, double momentum, double *eo, double *eh)
{
int in, hid, out;
double out_err, hid_err;

in = net->input_n;
hid = net->hidden_n;
out = net->output_n;

/*** 前向输入激活 ***/
bpnn_layerforward(net->input_units, net->hidden_units,
net->input_weights, in, hid);
bpnn_layerforward(net->hidden_units, net->output_units,
net->hidden_weights, hid, out);

/*** 计算隐含层和输出层误差 ***/
bpnn_output_error(net->output_delta, net->target, net->output_units,
out, &out_err);
bpnn_hidden_error(net->hidden_delta, hid, net->output_delta, out,
net->hidden_weights, net->hidden_units, &hid_err);
*eo = out_err;
*eh = hid_err;

/*** 调整输入层和隐含层权值 ***/
bpnn_adjust_weights(net->output_delta, out, net->hidden_units, hid,
net->hidden_weights, net->hidden_prev_weights, eta, momentum);
bpnn_adjust_weights(net->hidden_delta, hid, net->input_units, in,
net->input_weights, net->input_prev_weights, eta, momentum);
}

/* 保存BP网络 */
void CAnnBP::bpnn_save(BPNN *net, char *filename)
{
CFile file;
char *mem;
int n1, n2, n3, i, j, memcnt;
double dvalue, **w;
n1 = net->input_n; n2 = net->hidden_n; n3 = net->output_n;
printf("Saving %dx%dx%d network to '%s'\n", n1, n2, n3, filename);
try
{
file.Open(filename,CFile::modeWrite|CFile::modeCreate|CFile::modeNoTruncate);
}
catch(CFileException* e)
{
e->ReportError();
e->Delete();
}

file.Write(&n1,sizeof(int));
file.Write(&n2,sizeof(int));
file.Write(&n3,sizeof(int));

memcnt = 0;
w = net->input_weights;
mem = (char *) malloc ((unsigned) ((n1+1) * (n2+1) * sizeof(double)));
// mem = (char *) malloc (((n1+1) * (n2+1) * sizeof(double)));
for (i = 0; i <= n1; i++) {
for (j = 0; j <= n2; j++) {
dvalue = w[i][j];
//fast(&mem[memcnt], &dvalue, sizeof(double));
fast(&mem[memcnt], &dvalue, sizeof(double));
memcnt += sizeof(double);

}
}

file.Write(mem,sizeof(double)*(n1+1)*(n2+1));
free(mem);

memcnt = 0;
w = net->hidden_weights;
mem = (char *) malloc ((unsigned) ((n2+1) * (n3+1) * sizeof(double)));
// mem = (char *) malloc (((n2+1) * (n3+1) * sizeof(double)));
for (i = 0; i <= n2; i++) {
for (j = 0; j <= n3; j++) {
dvalue = w[i][j];
fast(&mem[memcnt], &dvalue, sizeof(double));
// fast(&mem[memcnt], &dvalue, sizeof(double));
memcnt += sizeof(double);
}
}

file.Write(mem, (n2+1) * (n3+1) * sizeof(double));
// free(mem);

file.Close();
return;
}

/* 从文件中读取BP网络 */
BPNN* CAnnBP::bpnn_read(char *filename)
{
char *mem;
BPNN *new1;
int n1, n2, n3, i, j, memcnt;
CFile file;

try
{
file.Open(filename,CFile::modeRead|CFile::modeCreate|CFile::modeNoTruncate);
}
catch(CFileException* e)
{
e->ReportError();
e->Delete();
}

// printf("Reading '%s'\n", filename);// fflush(stdout);

file.Read(&n1, sizeof(int));
file.Read(&n2, sizeof(int));
file.Read(&n3, sizeof(int));

new1 = bpnn_internal_create(n1, n2, n3);

// printf("'%s' contains a %dx%dx%d network\n", filename, n1, n2, n3);
// printf("Reading input weights..."); // fflush(stdout);

memcnt = 0;
mem = (char *) malloc (((n1+1) * (n2+1) * sizeof(double)));

file.Read(mem, ((n1+1)*(n2+1))*sizeof(double));
for (i = 0; i <= n1; i++) {
for (j = 0; j <= n2; j++) {
//fast(&(new1->input_weights[i][j]), &mem[memcnt], sizeof(double));
fast(&(new1->input_weights[i][j]), &mem[memcnt], sizeof(double));
memcnt += sizeof(double);
}
}
free(mem);

// printf("Done\nReading hidden weights..."); //fflush(stdout);

memcnt = 0;
mem = (char *) malloc (((n2+1) * (n3+1) * sizeof(double)));

file.Read(mem, (n2+1) * (n3+1) * sizeof(double));
for (i = 0; i <= n2; i++) {

for (j = 0; j <= n3; j++) {
//fast(&(new1->hidden_weights[i][j]), &mem[memcnt], sizeof(double));
fast(&(new1->hidden_weights[i][j]), &mem[memcnt], sizeof(double));
memcnt += sizeof(double);

}
}
free(mem);
file.Close();

printf("Done\n"); //fflush(stdout);

bpnn_zero_weights(new1->input_prev_weights, n1, n2);
bpnn_zero_weights(new1->hidden_prev_weights, n2, n3);

return (new1);
}

void CAnnBP::CreateBP(int n_in, int n_hidden, int n_out)
{
net=bpnn_create(n_in,n_hidden,n_out);
}

void CAnnBP::FreeBP()
{
bpnn_free(net);

}

void CAnnBP::Train(double *input_unit,int input_num, double *target,int target_num, double *eo, double *eh)
{
for(int i=1;i<=input_num;i++)
{
net->input_units[i]=input_unit[i-1];
}

for(int j=1;j<=target_num;j++)
{
net->target[j]=target[j-1];
}
bpnn_train(net,eta1,momentum1,eo,eh);

}

void CAnnBP::Identify(double *input_unit,int input_num,double *target,int target_num)
{
for(int i=1;i<=input_num;i++)
{
net->input_units[i]=input_unit[i-1];
}
bpnn_feedforward(net);
for(int j=1;j<=target_num;j++)
{
target[j-1]=net->output_units[j];
}
}

void CAnnBP::Save(char *filename)
{
bpnn_save(net,filename);

}

void CAnnBP::Read(char *filename)
{
net=bpnn_read(filename);
}

void CAnnBP::SetBParm(double eta, double momentum)
{
eta1=eta;
momentum1=momentum;

}

void CAnnBP::Initialize(int seed)
{
bpnn_initialize(seed);

}

⑺ 数学建模题 葡萄酒的评价 用bp神经网络解，求怎样用C或C++或Java代码解

能传一下表格么，谢谢啦

⑻ 如何建立bp神经网络预测 模型

建立BP神经网络预测 模型，可按下列步骤进行：

1、提供原始数据

2、训练数内据预测数据提取及归一化

3、BP网络容训练

4、BP网络预测

5、结果分析

现用一个实际的例子，来预测2015年和2016年某地区的人口数。

已知2009年——2014年某地区人口数分别为3583、4150、5062、4628、5270、5340万人

执行BP_main程序，得到

[ 2015, 5128.631704710423946380615234375]

[ 2016, 5100.5797325642779469490051269531]

代码及图形如下。