人工神经网络之反向传播算法

phinecos

浏览: 343525 次
性别:
来自: 上海

最近访客更多访客>>

loveofyou

huangyunbin

zhouzhk

liangyaqian

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

都说《机器学习》是学计算机的人必须要看的一本书，确实不是浪得虚名。看了一章人工神经网络(ANN)中关于反向传播算法的内容，相比单个感知器而言，采用多层网络的反向传播算法能表示出更多种类的非线性曲面，下面总结下它基本的处理框架。

ANN核心数据结构:

typedefstruct
{
intinput_n;/*numberofinputunits*/
inthidden_n;/*numberofhiddenunits*/
intoutput_n;/*numberofoutputunits*/
double*input_units;/*theinputunits*/
double*hidden_units;/*thehiddenunits*/
double*output_units;/*theoutputunits*/
double*hidden_delta;/*storageforhiddenuniterror*/
double*output_delta;/*storageforoutputuniterror*/
double*target;/*storagefortargetvector*/
double**input_weights;/*weightsfrominputtohiddenlayer*/
double**hidden_weights;/*weightsfromhiddentooutputlayer*/
/***Thenexttwoareformomentum***/
double**input_prev_weights;/*previouschangeoninputtohiddenwgt*/
double**hidden_prev_weights;/*previouschangeonhiddentooutputwgt*/
}BPNN;
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"> <meta name="ProgId" content="Word.Document"> <meta name="Generator" content="Microsoft Word 11"> <meta name="Originator" content="Microsoft Word 11"> <style>  </style>

整个神经网络可以分成三层：输入层，隐藏层，输出层，通过加权线性变换，层与层之间的传递，最终得到输入层的实数值。

BPNN*bpnn_internal_create(intn_in,intn_hidden,intn_out;)
{//创建人工网络，参数分别指定输入层，隐藏层和输出层大小
BPNN*newnet;
newnet=(BPNN*)malloc(sizeof(BPNN));
if(newnet==NULL)
{
printf("BPNN_CREATE:Couldn'tallocateneuralnetwork/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);
}

下面代码段是ANN运行的核心部分：

if(train_n>0)
{//提供了训练集
printf("Creatingnewnetwork'%s'/n",netname);
iimg=trainlist->list[0];//指向训练集第一张图片
imgsize=ROWS(iimg)*COLS(iimg);
/*bthom===========================
makeanetwith:
imgsizeinputs,4hidenunits,and1outputunit
*/
//输入层为图片大小，隐藏层为，输出层为
net=bpnn_create(imgsize,4,1);
}

//训练
/**************Trainit*****************************/
for(epoch=1;epoch<=epochs;epoch++)
{
printf("%d",epoch);fflush(stdout);
sumerr=0.0;
for(i=0;i<train_n;i++)
{
/**Setupinputunitsonnetwithimagei**/
//为图像i在网络上建立输入单元
load_input_with_image(trainlist->list[i],net);
/**Setuptargetvectorforimagei**/
//为图像i建立目标向量
load_target(trainlist->list[i],net);
/**Runbackprop,learningrate0.3,momentum0.3**/
//学习速率.3，冲量.3
bpnn_train(net,0.3,0.3,&out_err,&hid_err);
sumerr+=(out_err+hid_err);
}
进行性能评估：
for(i=0;i<n;i++)
{
/***Loadtheimageintotheinputlayer.**/
load_input_with_image(il->list[i],net);//加载图片到输入层中
/***Runthenetonthisinput.**/
bpnn_feedforward(net);//在当前输入上运行神经网络
/***Setupthetargetvectorforthisimage.**/
load_target(il->list[i],net);//为此图片建立目标向量
/***Seeifitgotitright.***/
if(evaluate_performance(net,&val,0))
{//判断是否正确识别,
correct++;
}
elseif(list_errors)
{
printf("%s-outputs",NAME(il->list[i]));
for(j=1;j<=net->output_n;j++)
{
printf("%.3f",net->output_units[j]);
}
putchar('/n');
}
err+=val;
}
err=err/(double)n;
if(!list_errors)
/*bthom==================================
thislineprintspartoftheouputline
discussedinsection3.1.2ofhomework
*/
printf("%g%g",((double)correct/(double)n)*100.0,err);

用到的性能评估函数：

evaluate_performance(BPNN *net, double *err)

{//性能评估

double delta;

delta = net->target[1] - net->output_units[1];

*err = (0.5 * delta * delta);

/*** If the target unit is on... ***/

if (net->target[1] > 0.5)

{

/*** If the output unit is on, then we correctly recognized me! ***/

if (net->output_units[1] > 0.5)

{

return (1);

}

else

{

return (0);

}

/*** Else, the target unit is off... ***/

}

else

{

/*** If the output unit is on, then we mistakenly thought it was me ***/

if (net->output_units[1] > 0.5)

{

return (0);

/*** else, we correctly realized that it wasn't me ***/

}

else

{

return (1);

}

辅助处理函数区：

load_input_with_image(IMAGE*img,BPNN*net)
{//输入图像
double*units;
intnr,nc,imgsize,i,j,k;

nr=ROWS(img);//行大小
nc=COLS(img);//列大小
imgsize=nr*nc;;
if(imgsize!=net->input_n)
{//确保输入单元数目设置为图片大小
printf("LOAD_INPUT_WITH_IMAGE:Thisimagehas%dpixels,/n",imgsize);
printf("butyournethas%dinputunits.Igiveup./n",net->input_n);
exit(-1);
}
//取图片的每个像素为输入单元
units=net->input_units;
k=1;
for(i=0;i<nr;i++)
{
for(j=0;j<nc;j++)
{
units[k]=((double)img_getpixel(img,i,j))/255.0;
k++;
}
}
}

load_target(IMAGE*img,BPNN*net)
{//加载目标值
intscale;
charuserid[40],head[40],expression[40],eyes[40],photo[40];
userid[0]=head[0]=expression[0]=eyes[0]=photo[0]='/0';
/***scanintheimagefeatures***/
sscanf(NAME(img),"%[^_]_%[^_]_%[^_]_%[^_]_%d.%[^_]",
userid,head,expression,eyes,&scale,photo);
if(!strcmp(userid,"glickman"))
{
net->target[1]=TARGET_HIGH;/*it'sme,settargettoHIGH*/
}
else
{
net->target[1]=TARGET_LOW;/*notme,setittoLOW*/
}
}

voidbpnn_train(BPNN*net,doubleeta,momentum*eo,momentum*eh)
{//人工神经网络训练
intin,hid,out;
doubleout_err,hid_err;
in=net->input_n;
hid=net->hidden_n;
out=net->output_n;
/***Feedforwardinputactivations.***/
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);
/***Computeerroronoutputandhiddenunits.***/
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;
/***Adjustinputandhiddenweights.***/
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);
}

voidbpnn_feedforward(BPNN*net)
{//前向反馈
intin,hid,out;
in=net->input_n;//输入层大小
hid=net->hidden_n;//隐藏层大小
out=net->output_n;//输出层大小
/***Feedforwardinputactivations.***/
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);
}

voidbpnn_adjust_weights(double*delta,double*ly,double**w,double**oldw,doubleeta,doublemomentum)
{//调整权值
doublenew_dw;
intk,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;
}
}
}
voidbpnn_layerforward(double*l1,double*l2,double**conn,intn1,intn2)
{//层次前向输入
doublesum;
intj,k;
/***Setupthresholdingunit***/
l1[0]=1.0;
//加权线性变换
/***Foreachunitinsecondlayer***/
for(j=1;j<=n2;j++)
{
/***Computeweightedsumofitsinputs***/
sum=0.0;
for(k=0;k<=n1;k++)
{
sum+=conn[k][j]*l1[k];
}
l2[j]=squash(sum);
}
}

分享到：