文章目录：
如何理解神经网络里面的反向传播算法
反向传播算法（BP算法）主要是用于最常见的一类神经网络，叫多层前向神经网络，本质可以看作是一个general nonlinear estimator，即输入x_1 ... x_n 输出y，视图找到一个关系 y=f(x_1 ... x_n) （在这里f的实现方式就是神经网络）来近似已知数据。为了得到f中的未知参数的最优估计值，一般会采用最小化误差的准则，而最通常的做法就是梯度下降，到此为止都没问题，把大家困住了很多年的就是多层神经网络无法得到显式表达的梯度下降算法！
BP算法实际上是一种近似的最优解决方案，背后的原理仍然是梯度下降，但为了解决上述困难，其方案是将多层转变为一层接一层的优化：只优化一层的参数是可以得到显式梯度下降表达式的；而顺序呢必须反过来才能保证可工作——由输出层开始优化前一层的参数，然后优化再前一层……跑一遍下来，那所有的参数都优化过一次了。但是为什么说是近似最优呢，因为数学上除了很特殊的结构，step-by-step的优化结果并不等于整体优化的结果！不过，好歹现在能工作了，不是吗？至于怎么再改进（已经很多改进成果了），或者采用其他算法（例如智能优化算法等所谓的全局优化算法，就算是没有BP这个近似梯度下降也只是局部最优的优化算法）那就是新的研究课题了。
求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];
//fastcopy(mem[memcnt], dvalue, sizeof(double));
fastcopy(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];
fastcopy(mem[memcnt], dvalue, sizeof(double));
// fastcopy(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++) {
//fastcopy((new1-input_weights[i][j]), mem[memcnt], sizeof(double));
fastcopy((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++) {
//fastcopy((new1-hidden_weights[i][j]), mem[memcnt], sizeof(double));
fastcopy((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);
}
反向传播算法的算法简介
反向传播算法（backpropagation）是目前用来训练人工神经网络（artificial
neural
network，ann）的最常用且最有效的算法。其主要思想是：
（1）将训练集数据输入到ann的输入层，经过隐藏层，最后达到输出层并输出结果，这是ann的前向传播过程；
（2）由于ann的输出结果与实际结果有误差，则计算估计值与实际值之间的误差，并将该误差从输出层向隐藏层反向传播，直至传播到输入层；
（3）在反向传播的过程中，根据误差调整各种参数的值；不断迭代上述过程，直至收敛。
反向传播算法的思想比较容易理解，但具体的公式则要一步步推导，因此本文着重介绍公式的推导过程。
1.
变量定义
上图是一个三层人工神经网络，layer1至layer3分别是输入层、隐藏层和输出层。如图，先定义一些变量：
表示第层的第个神经元连接到第层的第个神经元的权重；
表示第层的第个神经元的偏置；
表示第层的第个神经元的输入，即：
表示第层的第个神经元的输出，即：
其中表示激活函数。
2.
代价函数
代价函数被用来计算ann输出值与实际值之间的误差。常用的代价函数是二次代价函数（quadratic
cost
function）：
其中，表示输入的样本，表示实际的分类，表示预测的输出，表示神经网络的最大层数。
3.
公式及其推导
本节将介绍反向传播算法用到的4个公式，并进行推导。如果不想了解公式推导过程，请直接看第4节的算法步骤。
首先，将第层第个神经元中产生的错误（即实际值与预测值之间的误差）定义为：
本文将以一个输入样本为例进行说明，此时代价函数表示为：
公式1（计算最后一层神经网络产生的错误）：
其中，表示hadamard乘积，用于矩阵或向量之间点对点的乘法运算。公式1的推导过程如下：
公式2（由后往前，计算每一层神经网络产生的错误）：
推导过程：
公式3（计算权重的梯度）：
推导过程：
公式4（计算偏置的梯度）：
推导过程：
4.
反向传播算法伪代码
输入训练集
对于训练集中的每个样本x，设置输入层（input
layer）对应的激活值：
前向传播：
，
计算输出层产生的错误：
bp算法是什么？
误差反向传播算法：
BP算法的基本思想是，学习过程包括两个过程：信号前向传播和误差后向传播。
（1）前向传播:输入样本-输入层-各隐层(处理)-输出层。
（2）错误反向传播:输出错误(某种形式)-隐藏层(逐层)-输入层。
BP算法基本介绍：
多层隐含层前馈网络可以极大地提高神经网络的分类能力，但长期以来一直没有提出解决权值调整问题的博弈算法。
1986年，Rumelhart和McCelland领导的科学家团队出版了《并行分布式处理》一书，详细分析了具有非线性连续传递函数的多层前馈网络的误差反向比例（BP）算法，实现了Minsky关于多层网络的思想。由于误差的反向传播算法常用于多层前馈网络的训练，人们常直接称多层前馈网络为BP网络。
神经网络BP算法求代码
输入节点数为3x3x5=45，输出节点数为3x3+2=11，隐节点数通过试凑法得出。
BP神经网络的Matlab代码见附件，修改节点数、增加归一化和反归一化过程即可。
BP算法，误差反向传播（Error Back Propagation, BP）算法。BP算法的基本思想是，学习过程由信号的正向传播与误差的反向传播两个过程组成。由于多层前馈网络的训练经常采用误差反向传播算法，人们也常把将多层前馈网络直接称为BP网络。
1）正向传播：输入样本－输入层－各隐层（处理）－输出层
注1：若输出层实际输出与期望输出（教师信号）不符，则转入2）（误差反向传播过程）
2）误差反向传播：输出误差（某种形式）－隐层（逐层）－输入层
其主要目的是通过将输出误差反传，将误差分摊给各层所有单元，从而获得各层单元的误差信号，进而修正各单元的权值（其过程，是一个权值调整的过程）。
注2：权值调整的过程，也就是网络的学习训练过程（学习也就是这么的由来，权值调整）。
int n1, n2, i; n1 = net-input_n; n2 = net-hidden_n; free((char *) net-input_units); free((char *) net
的过程中，根据误差调整各种参数的值；不断迭代上述过程，直至收敛。反向传播算法的思想比较容易理解，但具体的公式则要一步步推导，因此本文着重介绍公式的推导过程。1.变量定义上图是一个三层人工神经网络，layer1至layer3分别是输入层、隐藏层和输出层。如图