BP神经网络 java代码实现

最新推荐文章于 2023-08-25 22:41:59 发布
最新推荐文章于 2023-08-25 22:41:59 发布
阅读量2.3k 收藏
点赞数
文章标签： 网络 java import string exception class

package backp;

import java.*;

import java.awt.*;

import java.io.*;

import java.util.Scanner;

 

//by realmagician

 

import org.omg.CORBA.portable.InputStream;

public class backpro {

         public static void main(String args[])

         {

                   String filename=new String("delta.in");

                   try {                   

                            FileInputStream fileInputStream=new FileInputStream(filename);

                            Scanner sinScanner=new Scanner(fileInputStream);

                            int attN,hidN,outN,samN;

                            attN=sinScanner.nextInt();

                            outN=sinScanner.nextInt();

                            hidN=sinScanner.nextInt();

                            samN=sinScanner.nextInt();

                            //System.out.println(attN+" "+outN+" "+hidN+" "+samN);

                            double samin[][]=new double[samN][attN];

                            double samout[][]=new double[samN][outN];

                            for(int i=0;i<samN;++i)

                            {

                                     for(int j=0;j<attN;++j)

                                     {

                                               samin[i][j]=sinScanner.nextDouble();

                                     }

                                     for(int j=0;j<outN;++j)

                                     {

                                               samout[i][j]=sinScanner.nextDouble();

                                     }

                            }

                            int times=10000;

                            double rate=0.5;

                            BP2 bp2=new BP2(attN,outN,hidN,samN,times,rate);

                            bp2.train(samin, samout);

                            for(int i=0;i<hidN;++i)

                            {

                                     for(int j=0;j<attN;++j)

                                               System.out.print(bp2.dw1[i][j]+" ");

                                     System.out.println();

                            }

                            for(int i=0;i<outN;++i)

                            {

                                     for(int j=0;j<hidN;++j)

                                               System.out.print(bp2.dw2[i][j]+" ");

                                     System.out.println();

                            }

                            while(true)

                            {

                                     double testout[]=new double[outN];

                                     double testin[]=new double[attN];

                                     Scanner testinScanner=new Scanner(System.in);

                                     for(int i=0;i<attN;++i)

                                     {

                                               testin[i]=testinScanner.nextDouble();

                                     }

                                     testout=bp2.getResault(testin);

                                     for(int i=0;i<outN;++i)

                                               System.out.print(testout[i]+" ");

                                     System.out.println(outN);

                            }

                   } catch (IOException e) {

                            // TODO: handle exception

                   }

                   System.out.println("End");

         }

}

class BP2//包含一个隐含层的神经网络

{

         double dw1[][],dw2[][];

         int hidN;//隐含层单元个数

         int samN;//学习样例个数

         int attN;//输入单元个数

         int outN;//输出单元个数

         int times;//迭代次数

         double rate;//学习速率

         boolean trained=false;//保证在得结果前，先训练

         BP2(int attN,int outN,int hidN,int samN,int times,double rate)

         {

                   this.attN=attN;

                   this.outN=outN;

                   this.hidN=hidN;

                   this.samN=samN;

                   dw1=new double[hidN][attN+1];//每行最后一个是阈值w0

                   for(int i=0;i<hidN;++i)//每行代表所有输入到i隐藏单元的权值

                   {                          

                            for(int j=0;j<=attN;++j)

                                     dw1[i][j]=Math.random()/2;

                   }

                   dw2=new double[outN][hidN+1];//输出层权值,每行最后一个是阈值w0

                   for(int i=0;i<outN;++i)//每行代表所有隐藏单元到i输出单元的权值

                   {                          

                            for(int j=0;j<=hidN;++j)

                                     dw2[i][j]=Math.random()/2;

                   }

                   this.times=times;

                   this.rate=rate;

         }

         public void train(double samin[][],double samout[][])

         {

                   double dis=0;//总体误差

                   int count=times;

                   double temphid[]=new double[hidN];

                   double tempout[]=new double[outN];

                   double wcout[]=new double[outN];

                   double wchid[]=new double[hidN];

                   while((count--)>0)//迭代训练

                   {

                            dis=0;

                            for(int i=0;i<samN;++i)//遍历每个样例 samin[i]

                            {

                                     for(int j=0;j<hidN;++j)//计算每个隐含层单元的结果

                                     {

                                               temphid[j]=0;

                                               for(int k=0;k<attN;++k)

                                                        temphid[j]+=dw1[j][k]*samin[i][k];

                                               temphid[j]+=dw1[j][attN];//计算阈值产生的隐含层结果

                                               temphid[j]=1.0/(1+Math.exp(-temphid[j] ));

                                     }

                                     for(int j=0;j<outN;++j)//计算每个输出层单元的结果

                                     {

                                               tempout[j]=0;

                                               for(int k=0;k<hidN;++k)

                                                        tempout[j]+=dw2[j][k]*temphid[k];

                                               tempout[j]+=dw2[j][hidN];//计算阈值产生的输出结果

                                               tempout[j]=1.0/(1+Math.exp( -tempout[j] ));

                                     }

                                     //计算每个输出单元的误差项

                                    

                                     for(int j=0;j<outN;++j)

                                     {

                                               wcout[j]=tempout[j]*(1-tempout[j])*(samout[i][j]-tempout[j]);

                                               dis+=Math.pow((samout[i][j]-tempout[j]),2);

                                     }

                                     //计算每个隐藏单元的误差项

                                    

                                     for(int j=0;j<hidN;++j)

                                     {

                                               double wche=0;

                                               for(int k=0;k<outN;++k)//计算输出项误差和

                                               {

                                                        wche+=wcout[k]*dw2[k][j];

                                               }

                                               wchid[j]=temphid[j]*(1-temphid[j])*wche;

                                     }

                                     //改变输出层的权值

                                     for(int j=0;j<outN;++j)

                                     {

                                               for(int k=0;k<hidN;++k)

                                               {

                                                        dw2[j][k]+=rate*wcout[j]*temphid[k];

                                               }

                                               dw2[j][hidN]=rate*wcout[j];

                                     }

                                     //改变隐含层的权值

                                     for(int j=0;j<hidN;++j)

                                     {

                                               for(int k=0;k<attN;++k)

                                               {

                                                        dw1[j][k]+=rate*wchid[j]*samin[i][k];

                                               }

                                               dw1[j][attN]=rate*wchid[j];

                                     }

 

                            }

                            if(dis<0.003)

                                     break;

                   }

                   trained=true;

         }

        

         public double[] getResault(double samin[])

         {

                   double temphid[]=new double[hidN];

                   double tempout[]=new double[outN];

                   if(trained==false)

                            return null;

 

                   for(int j=0;j<hidN;++j)//计算每个隐含层单元的结果

                   {

                            temphid[j]=0;

                            for(int k=0;k<attN;++k)

                                     temphid[j]+=dw1[j][k]*samin[k];

                            temphid[j]+=dw1[j][attN];//计算阈值产生的隐含层结果

                            temphid[j]=1.0/(1+Math.exp(-temphid[j] ));

                   }

                   for(int j=0;j<outN;++j)//计算每个输出层单元的结果

                   {

                            tempout[j]=0;

                            for(int k=0;k<hidN;++k)

                                     tempout[j]+=dw2[j][k]*temphid[k];

                            tempout[j]+=dw2[j][hidN];//计算阈值产生的输出结果

                            tempout[j]=1.0/(1+Math.exp( -tempout[j]));                    

                            //System.out.print(tempout[j]+" ");                          

                   }

                   return tempout;               

         }

}

JimMa
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java实现BP神经网络，实现对空气质量的分析和评级
木子的博客
12-01 1万+
使用java实现BP神经网络进行回归分析，并利用训练好的神经网络实现空气质量的评级。
java神经网络_实现简单神经网络
weixin_31320437的博客
02-19 1438
最近开始进军人工智能，但是对于其基础还是要打牢固的！对于神经网络，其原型及人体神经元，通过信息数据的输入交给神经元判断，再尤其将计算后的结果(高低电平)发送给下一个。本手记记录了感知器分类算法的python实现——实现感知器对象——数据解析和可视化——神经网络对数据实现分类以上是其算法流程图，权重向量W，训练样本X1、把权重向量初始化为0，或把每个分量初始化为【0，1】间任意小数2、把训练样本输入...
java实现的bp神经网络算法，代码超级简单，里面有实际数据例子
08-28
java实现的bp神经网络算法，代码超级简单，里面有实际数据例子，一看就懂！
BP神经网络算法在Java中的应用
我点评的博客
07-21 508
近年来，随着计算机技术的不断发展，BP神经网络算法在Java编程领域中的应用也越来越受到广泛的关注和使用。本文将探讨BP神经网络算法在Java中的应用，以及其在实际项目中的应用案例。Java语言具有良好的可移植性和跨平台性，可以方便的实现BP神经网络算法。综上所述，BP神经网络算法在Java编程领域中的应用具有重要的意义和潜在的应用价值。BP神经网络算法是一种有监督学习的神经网络算法，其基本原理是通过反向传播算法来进行误差的反向传播和网络参数的调整。BP神经网络算法在实际项目中的应用非常广泛。
基于JAYA算法优化的BP神经网络（预测应用） - 附代码
最新发布
Jack旭的博客
08-25 217
本案例数据一共2000组，其中1900组用于训练，100组用于测试。数据的输入为2维数据，预测的输出为1维数据。
BP神经网络实现（Java代码）
woodbean的专栏
01-04 3604
神经网络的原理虽然理解起来不难，但是要是想实现它，还是需要做一些工作的，并且有很多细节性的东西需要注意。通过参阅各种相关资料，以及参考网络上已有的资源，自己写了一个含有一个隐含层，且只能有一个输出单元的简单的BP网络，经过测试，达到了预期的效果。 需要说明的是，神经网络的每个输入都在[0,1]中，输出也在[0,1]中，在使用神经网络解决实际问题的时候，还需要对实际问题的输入输出进行归一化处理。另
Java实现BP神经网络
Zhang_ing的博客
07-24 1177
BP神经网络的过程主要分为两个阶段，第一阶段是信号的前向传播，从输入层经过隐含层，最后到达输出层；第二阶段是误差的反向传播，从输出层到隐含层，最后到输入层，依次调节隐含层到输出层的权重和偏置，输入层到隐含层的权重和偏置。这个类实现了一些具体且固定的Ann流程方法，如：读取文件并为属性赋值的构造方法、实现模型训练的train()方法以及实现激活函数的argmax()方法。其中线性运算可以将所有输入的值都作为有效输入信息抓入网络，非线性运算可以消除输入的线性结构。是待更新变量，另一个是学习率。
Java神经网络（一）——Neuroph初次使用
cynic233的博客
10-25 2612
初次使用Neuroph框架，记录所遇到的坑
Java实现BP神经网络MNIST手写数字识别
jingdianjiuchan的博客
02-02 444
由训练集数据可知，手写输入的数据维数为784维，而对应的输出结果为分别为0-9的10个数字，所以根据训练集的数据可知，在构建的神经网络的输入层的神经元的节点个数为784个，而对应的输出层的神经元个数为10个。参数的含义：将每个输入层中的神经元与神经元的权值信息weight[i][j]乘以对应的输入层神经元的阈值累加，然后再调用激活函数得到对应的隐层神经元的阈值。采用的是使用简单的随机数分配的方法,并且两层之间的神经元权值是通过二维数组进行保留，数组的索引就代表着两层对应的神经元的索引信息。
JAVA 人工神经网络实现，机器学习，人工智能
qq_18537055的博客
04-14 1690
人工智能（AI） 、机器学习（ML）、深度学习（DL）、神经网络（CNN） IT技术圈的人怼这些词汇大家都一定耳熟能...
开源java神经网络组件Joone、Encog和Neuroph的简单使用
12-13
Joone、Encog 和 Neuroph是三个著名的开源的java的神经网络的组件，各有特点。这里给出了三个开源代码的基于XOR的训练和测试过程。对于初涉神经网络的程序员是个很好的学习资料。
BP神经网络程序,java语言源代码
10-20
BP神经网络程序,java语言源代码,自己整理的
BP算法的java实现
12-30
BP算法的JAVA实现，BP神经网络的数学原理及其算法实现，实验使用IRIS数据集，BP神经网络，BP即Back Propagation的缩写，也就是反向传播的意思，顾名思义，将什么反向传播？文中将会解答。不仅如此，关于隐层的含义文中也会给出个人的理解。最后会用Java实现的BP分类器作为其应用以加深印象
JAVA实现bp神经网络
05-24
利用java实现bp神经网络，给定了UCI数据库的疝气病证预测病马数据，使用训练集训练BP神经网络并预测测试集的标签，错误率控制在30%以下。
BP神经网络JAVA实现
12-06
在Java中实现BP神经网络，我们需要了解以下几个关键概念和技术： 1. **神经元模型**：神经元是神经网络的基本构建单元，它接收输入信号，通过加权求和并加上偏置后，通过激活函数转化为输出信号。在BP网络中，常用...
BP神经网络的java实现
10-10
在Java中实现BP神经网络，需要理解其基本结构、训练过程以及核心算法。 1. **神经网络结构**： BP神经网络由输入层、隐藏层和输出层组成。输入层接收原始数据，隐藏层进行信息处理，输出层则给出预测结果。每层...
BpNeuralNetwork:BP神经网络的java实现
07-06
在Java编程环境中，实现BP神经网络可以帮助开发者进行复杂的非线性数据建模和预测任务。下面将详细介绍BP神经网络的结构、工作原理以及在Java中的实现方法。 **一、BP神经网络结构** BP神经网络通常由输入层、隐藏...
神经网络java_神经网络算法java实现
weixin_39806818的博客
02-12 438
神经网络的计算过程神经网络结构如下图所示，最左边的是输入层，最右边的是输出层，中间是多个隐含层，隐含层和输出层的每个神经节点，都是由上一层节点乘以其权重累加得到，标上“+1”的圆圈为截距项b，对输入层外每个节点：Y=w0*x0+w1*x1+…+wn*xn+b，由此我们可以知道神经网络相当于一个多层逻辑回归的结构。算法计算过程：输入层开始，从左往右计算，逐层往前直到输出层产生结果。如果结果值和目标值...
BP神经网络Java实现
04-27
BP神经网络是一种常见的人工神经网络，可以用来解决分类、回归等问题。在Java中，可以使用第三方库或自己实现BP神经网络。 以下是一个简单的BP神经网络Java实现示例： ```java import java.util.Arrays; public class BPNeuralNetwork { private int inputLayerSize; private int hiddenLayerSize; private int outputLayerSize; private double[][] weights1; private double[][] weights2; public BPNeuralNetwork(int inputLayerSize, int hiddenLayerSize, int outputLayerSize) { this.inputLayerSize = inputLayerSize; this.hiddenLayerSize = hiddenLayerSize; this.outputLayerSize = outputLayerSize; this.weights1 = new double[inputLayerSize + 1][hiddenLayerSize]; this.weights2 = new double[hiddenLayerSize + 1][outputLayerSize]; initializeWeights(); } private void initializeWeights() { for (int i = 0; i < inputLayerSize + 1; i++) { for (int j = 0; j < hiddenLayerSize; j++) { weights1[i][j] = Math.random() * 2 - 1; } } for (int i = 0; i < hiddenLayerSize + 1; i++) { for (int j = 0; j < outputLayerSize; j++) { weights2[i][j] = Math.random() * 2 - 1; } } } private double sigmoid(double x) { return 1 / (1 + Math.exp(-x)); } private double[][] addBias(double[][] matrix) { double[][] result = new double[matrix.length + 1][matrix[0].length]; for (int i = 0; i < matrix.length; i++) { for (int j = 0; j < matrix[0].length; j++) { result[i][j] = matrix[i][j]; } } Arrays.fill(result[matrix.length], 1); return result; } private double[][] removeBias(double[][] matrix) { double[][] result = new double[matrix.length - 1][matrix[0].length]; for (int i = 0; i < result.length; i++) { for (int j = 0; j < result[0].length; j++) { result[i][j] = matrix[i][j]; } } return result; } public double[] predict(double[] input) { double[] hiddenLayerOutput = new double[hiddenLayerSize]; double[] outputLayerOutput = new double[outputLayerSize]; // Forward propagation input = addBias(new double[][]{input})[0]; for (int i = 0; i < hiddenLayerSize; i++) { double sum = 0; for (int j = 0; j < inputLayerSize + 1; j++) { sum += input[j] * weights1[j][i]; } hiddenLayerOutput[i] = sigmoid(sum); } hiddenLayerOutput = addBias(new double[][]{hiddenLayerOutput})[0]; for (int i = 0; i < outputLayerSize; i++) { double sum = 0; for (int j = 0; j < hiddenLayerSize + 1; j++) { sum += hiddenLayerOutput[j] * weights2[j][i]; } outputLayerOutput[i] = sigmoid(sum); } return outputLayerOutput; } public void train(double[][] inputs, double[][] targets, int epochs, double learningRate) { for (int epoch = 0; epoch < epochs; epoch++) { double totalError = 0; for (int i = 0; i < inputs.length; i++) { double[] input = inputs[i]; double[] target = targets[i]; // Forward propagation input = addBias(new double[][]{input})[0]; double[] hiddenLayerOutput = new double[hiddenLayerSize]; for (int j = 0; j < hiddenLayerSize; j++) { double sum = 0; for (int k = 0; k < inputLayerSize + 1; k++) { sum += input[k] * weights1[k][j]; } hiddenLayerOutput[j] = sigmoid(sum); } hiddenLayerOutput = addBias(new double[][]{hiddenLayerOutput})[0]; double[] outputLayerOutput = new double[outputLayerSize]; for (int j = 0; j < outputLayerSize; j++) { double sum = 0; for (int k = 0; k < hiddenLayerSize + 1; k++) { sum += hiddenLayerOutput[k] * weights2[k][j]; } outputLayerOutput[j] = sigmoid(sum); } // Backpropagation double[] outputLayerError = new double[outputLayerSize]; for (int j = 0; j < outputLayerSize; j++) { outputLayerError[j] = outputLayerOutput[j] * (1 - outputLayerOutput[j]) * (target[j] - outputLayerOutput[j]); } double[] hiddenLayerError = new double[hiddenLayerSize]; for (int j = 0; j < hiddenLayerSize; j++) { double sum = 0; for (int k = 0; k < outputLayerSize; k++) { sum += outputLayerError[k] * weights2[j][k]; } hiddenLayerError[j] = hiddenLayerOutput[j] * (1 - hiddenLayerOutput[j]) * sum; } // Update weights for (int j = 0; j < outputLayerSize; j++) { for (int k = 0; k < hiddenLayerSize + 1; k++) { weights2[k][j] += learningRate * outputLayerError[j] * hiddenLayerOutput[k]; } } for (int j = 0; j < hiddenLayerSize; j++) { for (int k = 0; k < inputLayerSize + 1; k++) { weights1[k][j] += learningRate * hiddenLayerError[j] * input[k]; } } // Calculate error double error = 0; for (int j = 0; j < outputLayerSize; j++) { error += Math.pow(target[j] - outputLayerOutput[j], 2); } totalError += error; } System.out.println("Epoch: " + epoch + ", Error: " + totalError); } } } ``` 该实现中，`initializeWeights`方法用于初始化权重，`sigmoid`方法用于计算Sigmoid函数，`addBias`和`removeBias`方法用于增加和去除偏置项，`predict`方法用于预测输出，`train`方法用于训练BP神经网络。 使用以下代码进行测试： ```java public static void main(String[] args) { double[][] inputs = {{0, 0}, {0, 1}, {1, 0}, {1, 1}}; double[][] targets = {{0}, {1}, {1}, {0}}; BPNeuralNetwork network = new BPNeuralNetwork(2, 4, 1); network.train(inputs, targets, 10000, 0.1); System.out.println(Arrays.toString(network.predict(new double[]{0, 0}))); System.out.println(Arrays.toString(network.predict(new double[]{0, 1}))); System.out.println(Arrays.toString(network.predict(new double[]{1, 0}))); System.out.println(Arrays.toString(network.predict(new double[]{1, 1}))); } ``` 该代码实现了一个BP神经网络，用于解决XOR问题。在训练完毕后，输出几个测试样例的预测结果。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值