bp神经网络java代码

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

import java.util.Random;
public class BpDeep{
public double[][] layer;//神经网络各层节点
public double[][] layerErr;//神经网络各节点误差
public double[][][] layer_weight;//各层节点权重
public double[][][] layer_weight_delta;//各层节点权重动量
public double mobp;//动量系数
public double rate;//学习系数

public BpDeep(int[] layernum, double rate, double mobp){
this.mobp = mobp;
this.rate = rate;
layer = new double[layernum.length][];
layerErr = new double[layernum.length][];
layer_weight = new double[layernum.length][][];
layer_weight_delta = new double[layernum.length][][];
Random random = new Random();
for(int l=0;l<layernum.length;l++){
layer[l]=new double[layernum[l]];
layerErr[l]=new double[layernum[l]];
if(l+1<layernum.length){
layer_weight[l]=new double[layernum[l]+1][layernum[l+1]];
layer_weight_delta[l]=new double[layernum[l]+1][layernum[l+1]];
for(int j=0;j<layernum[l]+1;j++)
for(int i=0;i<layernum[l+1];i++)
layer_weight[l][j][i]=random.nextDouble();//随机初始化权重
}
}
}
//逐层向前计算输出
public double[] computeOut(double[] in){
for(int l=1;l<layer.length;l++){
for(int j=0;j<layer[l].length;j++){
double z=layer_weight[l-1][layer[l-1].length][j];
for(int i=0;i<layer[l-1].length;i++){
layer[l-1][i]=l==1?in[i]:layer[l-1][i];
z+=layer_weight[l-1][i][j]*layer[l-1][i];
}
layer[l][j]=1/(1+Math.exp(-z));
}
}
return layer[layer.length-1];
}
//逐层反向计算误差并修改权重
public void updateWeight(double[] tar){
int l=layer.length-1;
for(int j=0;j<layerErr[l].length;j++)
layerErr[l][j]=layer[l][j]*(1-layer[l][j])*(tar[j]-layer[l][j]);

while(l-->0){
for(int j=0;j<layerErr[l].length;j++){
double z = 0.0;
for(int i=0;i<layerErr[l+1].length;i++){
z=z+l>0?layerErr[l+1][i]*layer_weight[l][j][i]:0;
layer_weight_delta[l][j][i]= mobp*layer_weight_delta[l][j][i]+rate*layerErr[l+1][i]*layer[l][j];//隐含层动量调整
layer_weight[l][j][i]+=layer_weight_delta[l][j][i];//隐含层权重调整
if(j==layerErr[l].length-1){
layer_weight_delta[l][j+1][i]= mobp*layer_weight_delta[l][j+1][i]+rate*layerErr[l+1][i];//截距动量调整
layer_weight[l][j+1][i]+=layer_weight_delta[l][j+1][i];//截距权重调整
}
}
layerErr[l][j]=z*layer[l][j]*(1-layer[l][j]);//记录误差
}
}
}

public void train(double[] in, double[] tar){
double[] out = computeOut(in);
updateWeight(tar);
}
}

参考资料
http://geek.csdn.net/news/detail/56086

❸ 如何利用java库学习神经网络

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

❹ bp神经网络训练样本增加很多，但是隐含层节点数还是不变会不会欠拟合，或者过拟合求大神告知！

学习神经网络这段时间，有一个疑问，BP神经网络中训练的次数指的网络的迭代次数，如果有a个样本,每个样本训练次数n，则网络一共迭代an次，在n>>a 情况下 ， 网络在不停的调整权值，减小误差，跟样本数似乎关系不大。而且，a大了的话训练时间必然会变长。 
换一种说法，将你的数据集看成一个固定值， 那么样本集与测试集 也可以按照某种规格确定下来如7：3 所以如何看待 样本集的多少与训练结果呢？ 或者说怎么使你的网络更加稳定，更加符合你的所需 。

我尝试从之前的一个例子中看下区别

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

作者其实是实现了一个BP神经网络 ，不多说，看最后的例子

一个运用神经网络的例子 
最后我们找个简单例子来看看神经网络神奇的效果。为了方便观察数据分布，我们选用一个二维坐标的数据，下面共有4个数据，方块代表数据的类型为1，三角代表数据的类型为0，可以看到属于方块类型的数据有（1，2）和（2，1），属于三角类型的数据有（1，1），（2，2），现在问题是需要在平面上将4个数据分成1和0两类，并以此来预测新的数据的类型。


图片描述

我们可以运用逻辑回归算法来解决上面的分类问题，但是逻辑回归得到一个线性的直线做为分界线，可以看到上面的红线无论怎么摆放，总是有一个样本被错误地划分到不同类型中，所以对于上面的数据，仅仅一条直线不能很正确地划分他们的分类，如果我们运用神经网络算法，可以得到下图的分类效果，相当于多条直线求并集来划分空间，这样准确性更高。 

图片描述

简单粗暴，用作者的代码运行后 训练5000次 。根据训练结果来预测一条新数据的分类（3,1）



预测值 （3,1）的结果跟（1,2）（2,1）属于一类 属于正方形

这时如果我们去掉 2个样本，则样本输入变成如下

//设置样本数据，对应上面的4个二维坐标数据 double[][] data = new double[][]{{1,2},{2,2}}; //设置目标数据，对应4个坐标数据的分类 double[][] target = new double[][]{{1,0},{0,1}};

1

2

3

❺ java编写bp神经网络函数

我用.NET做过一个，不过准确率没这么高，75%到80%，可能是输入点少的缘故（4个），总体样本一万多条，我随机抽取100条样本训练神经网络
qq 1320379472

❻ 如何理解CNN神经网络里的反向传播backpropagation，bp算法

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

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

能传一下表格么，谢谢啦

❽ BP神经网络预测代码

你这是在做时间序列呢。

你可以去《神经网络之家》nnetinfo----》学习教程二--->神经网络在时间序列上的应用
上面有讲解。我把代码摘抄给你

% time series:神经网络在时间序列上的应用

% 本代码出自《神经网络之家》

timeList = 0 :0.01 : 2*pi; %生成时间点

X = sin(timeList); %生成时间序列信号

%利用x(t-5),x(t-4),x(t-3),x(t-2),x(t-1)作为输入预测x(t)，将x(t)作为输出数据

inputData = [X(1:end-5);X(2:end-4);X(3:end-3);X(4:end-2);X(5:end-1)];

outputData = X(6:end);

%使用用输入输出数据（inputData、outputData）建立网络，

%隐节点个数设为3.其中隐层、输出层的传递函数分别为tansig和purelin，使用trainlm方法训练。

net = newff(inputData,outputData,3,{'tansig','purelin'},'trainlm');

%设置一些常用参数

net.trainparam.goal = 0.0001; %训练目标：均方误差低于0.0001

net.trainparam.show = 400; %每训练400次展示一次结果

net.trainparam.epochs = 1500; %最大训练次数：15000.

[net,tr] = train(net,inputData,outputData);%调用matlab神经网络工具箱自带的train函数训练网络

simout = sim(net,inputData); %调用matlab神经网络工具箱自带的sim函数得到网络的预测值

figure; %新建画图窗口窗口

t=1:length(simout);

plot(t,outputData,t,simout,'r')%画图，对比原来的输出和网络预测的输出

%------------------附加:抽取数学表达式----------------------------top

%希望脱离matlab的sim函数来使用训练好网络的话，可以抽取出数学的表达式，|

%这样在任何软件中，只需要按表达式计算即可。 |

%============抽取数学表达式==================

%抽取出网络的权值和阈值

w12 = net.iw{1,1}; %第1层（输入层）到第2层（隐层）的权值

b2 = net.b{1}; %第2层（隐层）的阈值

w23 = net.lw{2,1}; %第2层（隐层）到第3层（输出层）的权值

b3 = net.b{2}; %第3层（输出层）的阈值

%由于有归一化，必须先将归一化信息抓取出来

iMax = max(inputData,[],2);

iMin = min(inputData,[],2);

oMax = max(outputData,[],2);

oMin = min(outputData,[],2);

%方法1：归一化--->计算输出--->反归一化

normInputData=2*(inputData -repmat(iMin,1,size(inputData,2)))./repmat(iMax-iMin,1,size(inputData,2)) -1;

tmp = w23*tansig( w12 *normInputData + repmat(b2,1,size(normInputData,2))) + repmat(b3,1,size(normInputData,2));

myY = (tmp+1).*repmat(oMax-oMin,1,size(outputData,2))./2 + repmat(oMin,1,size(outputData,2));

%方法2：用真正的权值和阈值进行计算

%公式请参考《提取对应原始数据的权重和阈值》

W12 = w12 * 2 ./repmat(iMax' -iMin',size(w12,1),1);

B2 = -w12* (2*iMin ./(iMax - iMin) + 1) + b2;

W23 = w23 .*repmat((oMax -oMin),1,size(w23,2))/2;

B3 = (oMax -oMin) .*b3 /2 + (oMax -oMin)/2 + oMin;

%最终的数学表达式：

myY2 = W23 *tansig( W12 *inputData + repmat(B2,1,size(inputData,2))) + repmat(B3,1,size(inputData,2));

❾ 谁有最简单的BP神经网络的可以的代码啊

#include <cmath>
#include <cstdlib>
#include <cstdio>
#include <ctime>
//Rumelhart,1985,only one hidden layer
const double lr = 0.1;
const double goal = 1e-1;
const size_t SampleNum = 4;
const size_t HidNeuron = 10;
const size_t Input = 2;
const size_t Output = 1;

double Weight1[Input][HidNeuron] = {0};
double Bias1[HidNeuron] = {0};
double Weight2[HidNeuron][Output] = {0};
double Bias2[Output] = {0};

double InputValue[SampleNum][Input] ={0};
double OutputValue[SampleNum][Output] ={0};
double Error[SampleNum][Output] = {0};
double MSE = 1;

void InitWeight()
{
size_t i,j;
for( i=0; i<Input; i++)
{
for(j=0; j<HidNeuron; j++)
{
Weight1[i][j] = (rand()/(double)RAND_MAX)*2 - 1;
}
}
for( i=0; i<HidNeuron; i++)
Bias1[i] = (rand()/(double)RAND_MAX)*2 - 1;
for( i=0; i<HidNeuron; i++)
{
for(j=0; j<Output; j++)
{
Weight2[i][j] = (rand()/(double)RAND_MAX)*2 - 1;
}
}
for( i=0; i<Output; i++)
Bias2[i] = (rand()/(double)RAND_MAX)*2 - 1;
}

double LogSigmoid(double x)
{
return 1/(1+exp(-x));
}

double DetLogSigmoid(double x)
{
return LogSigmoid(x) - pow(LogSigmoid(x),2.0);
}

void Computing()
{
size_t i,j,k;
double sum=0;
double hidOutput[SampleNum][HidNeuron] = {0};
double finOutput[SampleNum][Output] = {0};

double detOutput[Output] = {0};
double detHid[HidNeuron] = {0};
double simHidError[HidNeuron] ={0};
for(i=0; i<SampleNum; i++)
{
//ForwardComputing
for(j=0; j<HidNeuron; j++)
{
sum =0;
for(k=0; k<Input+1; k++)
{
if(k == Input)
sum += (-1)*Bias1[j];
else
sum += InputValue[i][k]*Weight1[k][j];
}
hidOutput[i][j] = LogSigmoid(sum);
}
for(j=0; j<Output; j++)
{
sum =0;
for(k=0; k<HidNeuron+1; k++)
{
if(k == HidNeuron)
sum += (-1)*Bias2[j];
else
sum += hidOutput[i][k]*Weight2[k][j];
}
finOutput[i][j] = LogSigmoid(sum);
Error[i][j] = OutputValue[i][j] - finOutput[i][j];
}
//BackwardComputing
for(j=0; j<Output; j++)
{
detOutput[j] = finOutput[i][j]*(1-finOutput[i][j])*Error[i][j];
for(k=0; k<HidNeuron; k++)
{
Weight2[k][j] += (lr*detOutput[j]*hidOutput[i][k]);
}
Bias2[j] += (lr*detOutput[j]*(-1));
}

for(j=0; j<HidNeuron; j++)
{
simHidError[j] = 0;
for(k=0; k<Output; k++)
{
simHidError[j] += detOutput[k]*Weight2[j][k];
}
}

for(j=0; j<HidNeuron; j++)
{
detHid[j] = hidOutput[i][j]*(1-hidOutput[i][j])*simHidError[j];
for(k=0; k<Input; k++)
{
Weight1[k][j] += (lr*detHid[j]*InputValue[i][k]);
}
Bias1[j] += (lr*detHid[j]*(-1));
}
}
MSE=0;
for(i =0; i<Output; i++)
{
for(j=0; j<SampleNum; j++)
{
MSE += (Error[j][i]*Error[j][i]);
}
}
MSE = sqrt(MSE/SampleNum);
}

int main()
{
srand(unsigned(time(NULL)));
static clock_t BeforeRunTime = clock();
InitWeight();
InputValue[0][0] = 0;
InputValue[0][1] = 0;
OutputValue[0][0] = 0;

InputValue[1][0] = 1;
InputValue[1][1] = 1;
OutputValue[1][0] = 0;

InputValue[2][0] = 0;
InputValue[2][1] = 1;
OutputValue[2][0] = 1;

InputValue[3][0] = 1;
InputValue[3][1] = 0;
OutputValue[3][0] = 1;

size_t cEpoch = 0;
while(MSE>goal)
{
cEpoch++;
Computing();
printf("MSE: %.6f\n",MSE);
}
printf("Epochs %d\n",cEpoch);

clock_t UsedTime = clock()-BeforeRunTime;
printf("UsedTime %dms\n",UsedTime);

getchar();
return 0;
}

❿ 求神经网络算法的一个代码示例（C、C++或java一类的）

在matlab里建立一个.m的M文件，把代码输进去，保存，运行就可以了。 演示程序是在command 里打demo就可以了找到了 . 你邮箱多少，我只有简单的BP神经网络程序。