神经网络算法代码java 神经网络算法代码怎么用

你好，想跟你要一下神经网络的代码，看到你之前解答过问题，谢谢了

// BP.cpp : Defines the entry point for the console application.

创新互联专注为客户提供全方位的互联网综合服务，包含不限于网站设计、成都做网站、元宝网络推广、成都小程序开发、元宝网络营销、元宝企业策划、元宝品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们最大的嘉奖；创新互联为所有大学生创业者提供元宝建站搭建服务，24小时服务热线：18980820575，官方网址：www.cdcxhl.com

//该程序实现神经网络的BP算法，输入节点数，输出节点数，隐层数，隐层节点数任意，由用户决定。

//其中隐层数指的是总共层数包含输出层，比如说异或算法为2层，第一层节点数为2，第二层也即输出层节点数为1，输入点数为2 。

//但是该程序对异或算法实现并不理想，对多层多节点的神经网络有较好的结果

#include "stdafx.h"

#include "iostream.h"

#include time.h

#include stdlib.h

#include fstream

#include math.h

#include "stdio.h "

#define MAXCOUNT 1e5 //迭代训练次数上限 1的10的正5次幂

//精度0.001的随机浮点数,范围在-0.5——0.5

//rand()取0到32767,最大为2147483647. %模运算表示余数为0到1000之间，所以乘上浮点数0。001f就是0-1之间的数，再减去0.5,就是-0.5到+0.5

float randf()

{

return (float)((rand() % 1001) * 0.001f-0.5);

}

//高斯随机数产生函数

//这样生成的高斯分布随机数序列的期望为0.0，方差为1.0。若指定期望为E，方差为V，则只需增加：X = X * V + E;

double gaussrand()

{

static double V1, V2, S;

static int phase = 0;

double X;

if(phase == 0) {

do {

double U1 = (double)rand() / RAND_MAX;

double U2 = (double)rand() / RAND_MAX;

V1 = 2 * U1 - 1;

V2 = 2 * U2 - 1;

S = V1 * V1 + V2 * V2;

} while(S = 1 || S == 0);

X = V1 * sqrt(-2 * log(S) / S);

} else

X = V2 * sqrt(-2 * log(S) / S );

phase = 1 - phase;

return X;

}

//定义一个多层前向BP网络

class BP

{

public:

double ***p;//记录所有的权值

double ***ddp;//记录所有的权值增量

int *pnode;//记录每一层的节点数

double **pnodey;//记录每组每一层的节点的输出值

double **ddlj;//记录每组每一层的节点的ddlj

double **pX; //记录输入样本

double **pY; //记录输入理想输出值

int Sidenum; //隐层数目

int Inputnodenum;

int outputnodenum;

int yangbenzushu;

BP()

{

Sidenum=0;

Inputnodenum=0;

outputnodenum=0;

yangbenzushu=0;

}

~BP()

{

for(int m=0;mSidenum;m++)

{

for(int n=0;npnode[m+1];n++)

{

delete[] p[m][n];

delete[] ddp[m][n];

}

delete[] p[m];

delete[] ddp[m];

}

delete[] p;

delete[] ddp;

p=NULL;

ddp=NULL;

if(p==NULL)

delete [] pnode;

for(int M=0;MSidenum;M++)

{

delete[] pnodey[M];

delete[] ddlj[M];

}

delete[] pnodey;

delete[] ddlj;

pnodey=NULL;

ddlj=NULL;

}

//完成所有权值的初始化

void getW(int sidenum,int inputnodenum,int outputnodenum1,int yangbenzu)

{

Sidenum=sidenum;

yangbenzushu= yangbenzu;//样本组数目

Inputnodenum=inputnodenum;

outputnodenum=outputnodenum1;

p=new double **[sidenum];//记录所有权值

ddp=new double **[sidenum];//权值增量

pnode=new int [sidenum+1];//包含输入层，输出层每一层的节点数.

for(int i=0;isidenum+1;i++)

{

int data=0;

cout"请输入第"i"层节点数"endl;

cindata;

pnode[i]=data;

}

for (int j=0;jsidenum;j++) // 初始化权值, 不包含输入层,但是包含输出层.第0层表示第一个隐层

{

p[j]=new double* [pnode[j+1]]; //首先P[j]层有多少个节点,就有多少个指针,每个指针指向一个权值数组.因为p[j]是二级指针,存放的是某指针的地址,某指针可以指向一维数组.

ddp[j]=new double*[pnode[j+1]];//同上

for (int k=0;kpnode[j+1];k++)

{

ddp[j][k]=new double[pnode[j]+1];//表示第j层的第k个节点指向的是一个数组,这个数组里存的是这个节点的权值.

p[j][k]=new double[pnode[j]+1];

for (int t=0;tpnode[j]+1;t++) //pnode[j]+1 表示第j层的输入点个数.

{

ddp[j][k][t]=0;//每一层的权值初始化为0 表示的是第j层的第k个节点,第t个输入的输入权值.

if(t==0)p[j][k][t]=-fabs(randf());//每一层的阀值初始化 第0个元素.

else p[j][k][t]=randf();//每一层的权值初始化

}

}

}

//为记录每一层的节点的输出值和ddlj的指针开辟内存

pnodey=new double *[Sidenum]; //一共有Sidenum层.

ddlj=new double *[Sidenum];

for(int p=0;pSidenum;p++)

{

pnodey[p] = new double [pnode[p+1]+1];//每层一共有节点数+1个输出

ddlj[p]=new double [pnode[p+1]];// 这个是做什么的？？

pnodey[p][0]=1;//每组每层的首值为1,这个值是为了与阈值相乘,这也是为什么会有上面+1个输出

}

}

/**********************/

//每个节点输出函数

double fas(double s)

{

double t;

t=1.0/(exp(-s)+1);

return t;

}

/************************************************/

//该函数用来记录样本值和理想输出值

void INPUT(int yangbenzushu1 )

{

pY=new double*[yangbenzushu1];//yangbenzushu1数量个理想输出

pX=new double*[yangbenzushu1];//yangbenzushu1数量个样本

for(int yu=0;yuyangbenzushu1;yu++)

{

pX[yu]=new double[Inputnodenum+1];//每个样本的维数是输入点个数+1

pY[yu]=new double[outputnodenum+1];//输出的维数也是输出点个数+1

}

//每组样本的首值赋为1， 这样就可以使下标对应的比较好

for(int yu1=0;yu1yangbenzushu1;yu1++)

{

pX[yu1][0]=1;

pY[yu1][0]=1;

}

cout"请输入样本输入值"endl;

for(int yuy=0;yuyyangbenzushu1;yuy++)

for(int yy=1;yy=Inputnodenum;yy++)

{

if(yy==Inputnodenum) coutendl;

cout"X["yuy"]""["yy"]="' ';

cinpX[yuy][yy];

}

cout"请输入样本理想输出值"endl;

for(int yuy1=0;yuy1yangbenzushu1;yuy1++)

for(int yy1=1;yy1=outputnodenum;yy1++)

{ //if(yy==Inputnodenum) coutendl;

cout"Y["yuy1"]""["yy1"]="' ';

cinpY[yuy1][yy1];

}

}

/****************************************************************************/

//计算每个节点的输出值

double computeYl(int KK)//KK代表第几组组号

{

double sum1=0;

//把所有的层的每一个节点的输出值算出来并记录在pnodey里,不包含输入点值

for(int y=0;ySidenum;y++)//层数

{

for(int r=1;rpnode[y+1]+1;r++)//本节点数，加1是为了下标好看

{

double sum=0;

for(int z=0;zpnode[y]+1;z++)//前一层的节点数

{

if(y==0)sum+= pX[KK][z]*p[y][r-1][z];

else

sum+=pnodey[y-1][z]*p[y][r-1][z];

}

pnodey[y][r]=fas(sum);

}

}

for(int j=1;j=outputnodenum;j++)

sum1+=pow(pY[KK][j]-pnodey[Sidenum-1][j],2);

return sum1;

}

/**********************************************************/

//Compute Back-Propagation-Errors

void ComputeBackPropagationErrors(int gf)//gf代表组号

{//计算所有的ddlj[][]

//for(int gf=0;gfyangbenzushu;gf++)//组数

for(int q=Sidenum-1;q=0;q--)//从最后一层开始

{

if(q==Sidenum-1)//如果是最外一层的话

{

for(int rt=0;rtpnode[q+1];rt++)//每层的节点数

ddlj[q][rt]=pnodey[q][rt+1]*(1-pnodey[q][rt+1])*(pY[gf][rt+1]-pnodey[q][rt+1]) ;

}

else

{

for(int ry=0;rypnode[q+1];ry++)

{

double sumtemp=0;

for(int fg=0;fgpnode[q+2];fg++)

sumtemp+=ddlj[q+1][fg]*p[q+1][fg][ry+1];

ddlj[q][ry] = pnodey[q][ry+1]*(1-pnodey[q][ry+1])* sumtemp;

}

}

}

//计算所有的ddp[][]

//for(int gf1=0;gf1yangbenzushu;gf1++)//组数

for(int l=0;lSidenum;l++)//层数

for(int JJ=0;JJpnode[l+1];JJ++)//每一层的节点数

for(int i=0;ipnode[l]+1;i++)//前一层的节点数

{

if(l==0)//如果是第一层的话，y值为输入的X值

ddp[l][JJ][i]=ddlj[l][JJ]*pX[gf][i];

else

ddp[l][JJ][i]=ddlj[l][JJ]*pnodey[l-1][i];

}

}

/*************************************************************************/

void UpdatetheWeightsusingBPAlgorithm()

{

for(int cent=0;centSidenum;cent++)//层数

for(int J=0;Jpnode[cent+1];J++)//每一层的节点数

for(int i=0;ipnode[cent]+1;i++)//前一层的节点数

p[cent][J][i]+=0.2*ddp[cent][J][i];

}

/***************************************************************************/

double xunlianErrors()//定义训练误差函数

{

double error=0;

double sum=0;

double temp=0;

double temp1=0;

for(int gf1=0;gf1yangbenzushu;gf1++)//组数

{

temp= computeYl(gf1);

//temp1=zhengquelv(gf1);

//sum+=temp1;

for(int jj=1;jj=outputnodenum;jj++)

coutpnodey[Sidenum-1][jj];

error+=temp;

}

// sum=sum/yangbenzushu;

cout"用训练集所得到的正确率："sumendl;

return error/yangbenzushu;

}

/****************************************************************************/

double jiaoyanErrors(int yangbenzushu1 )//定义校验误差函数

{

double error=0;

double sum=0;

double temp=0;

double temp1=0;

for(int gf1=0;gf1yangbenzushu1;gf1++)//组数

{

temp= computeYl(gf1);

for(int jj=1;jj=outputnodenum;jj++)

coutpnodey[Sidenum-1][jj];

//temp1=zhengquelv(gf1);

//sum+=temp1;

error+=temp;

}

//sum=sum/yangbenzushu1;

//cout"用校验集所得到的正确率："sumendl;

return error/yangbenzushu1;

}

/********************************************************************/

double zhengquelv(int KK)

{

int count=0;

double av=0;

//for(int gf1=0;gf1yangbenzushu;gf1++)//组数

for(int jj=1;jj=outputnodenum;jj++)

{

if (pnodey[Sidenum-1][jj]0) pnodey[Sidenum-1][jj]=1;

else pnodey[Sidenum-1][jj]=0;

if(pY[KK][jj]==pnodey[Sidenum-1][jj])count++;

}

av=(double)count/outputnodenum;

return av;

}

/***********************************************************************/

void freeINput()

{

if(pX!=NULL)

{

for(int u=0;uyangbenzushu;u++)

delete []pX[u];

delete []pX;

pX=NULL;

}

if(pY!=NULL)

{

for(int u1=0;u1yangbenzushu;u1++)

delete []pY[u1];

delete []pY;

pY=NULL;

}

}

/***************************************************************/

//输出所有的权值

void wputout()

{

for (int j=0;jSidenum;j++)

{

cout"第["j+1"]层权值为："endl;

for (int k=0;kpnode[j+1];k++)

{

//if(k==pnode[j+1]-1) coutendl;

for (int t=0;tpnode[j]+1;t++)

{

coutp[j][k][t]' ';

if(t==pnode[j]) coutendl;

}

}

}

}

/**********************************************************/

};

void main()

{

BP bp;

int count=0;//用来统计所用的迭代次数

//FILE *fp;

int inputnodenum,outnodenum,sidenum,yangbenzunum;

double error;

cout"请输入：输入点数，输出点数，隐层数"endl;

cininputnodenumoutnodenumsidenum;

cout"请输入样本组数"endl;

cinyangbenzunum;

//第一步初始化所有的权值

bp.getW(sidenum,inputnodenum,outnodenum,yangbenzunum);

//第二步输入样本组

bp.INPUT(yangbenzunum);

for(count++)

{

double sum=0;

double temp=0;

for(int fuzu=0;fuzuyangbenzunum;fuzu++)

{

//第三步计算所有y值

temp=bp点抗 puteYl(fuzu);

//第四步Compute Back-Propagation-Errors

bp.ComputeBackPropagationErrors(fuzu);

//第五步Update the Weights using BP Algorithm

bp.UpdatetheWeightsusingBPAlgorithm();

sum+=temp;

}

//第六步判断是否收敛

error=sum/2*yangbenzunum;

//freopen("debug\\out.txt","w",stdout);

//fp=freopen( "out.txt", "w", stdout) ;

// coutcount' 'errorendl;

// fclose(stdout);//关闭文件

/*if(count==1000)couterrorendl;

if(count==1500)couterrorendl;

if(count==1600)couterrorendl;*/

//if(count==10000)couterrorendl;

if(error1.02)

{

cout"循环收敛""迭代次数为："countendl;

//bp.freeINput();//释放X Y空间

break;

}

}

cout"权值为："endl;

bp.wputout();

double XUNLIANER=bp.xunlianErrors();

//cout"训练误差为："XUNLIANERendl;

bp.freeINput();//释放X Y空间

/*

cout"请输入校验样本: "endl;

int jiaoyannum=0;

cinjiaoyannum;

bp.INPUT(jiaoyannum);

double jiaoyanER=bp.jiaoyanErrors(jiaoyannum);

cout"校验误差为:"jiaoyanERendl;

//fclose( stdout ) ;*/

}

急求BP神经网络算法，用java实现！！！

见附件，一个基本的用java编写的BP网络代码。

BP（Back Propagation）神经网络是86年由Rumelhart和McCelland为首的科学家小组提出，是一种按误差逆传播算法训练的多层前馈网络，是目前应用最广泛的神经网络模型之一。BP网络能学习和存贮大量的输入-输出模式映射关系，而无需事前揭示描述这种映射关系的数学方程。它的学习规则是使用最速下降法，通过反向传播来不断调整网络的权值和阈值，使网络的误差平方和最小。BP神经网络模型拓扑结构包括输入层（input）、隐层(hidden layer)和输出层(output layer)。

如何用70行Java代码实现深度神经网络算法

你“行”的概念是什么？ 用C++之后在matlab中编译成mex后，使用的时候一行代码就可以了。

同理，实现算法本身中基本的运算过程是不是展开，用什么、语言？

再者，什么类型的网络？ 普通的全连接？ 局部连接的卷积神经网络？ Deep Residual Network? 不同类型的网络结构上会不一样。