人工智能之BP神经网络

最新推荐文章于 2023-12-29 09:20:43 发布
最新推荐文章于 2023-12-29 09:20:43 发布
阅读量2.9k 收藏 12
点赞数 1
分类专栏： ML&DL 文章标签： 人工智能 神经网络 BP网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangchinlung/article/details/72763307
版权

什么是BP神经网络，BP网络是一种按照误差逆向传播算法训练的多层前馈神经网络。基本的BP神经网路包括信号的前向传播和误差的反向传播两个过程。这里我们具体研究的是简单的三层BP网络。这三层分别是，输入层、隐含层和输出层。如下图，输入层有输入X共n个输入，隐含层的神经元个数由自己来定义，为S1个，输出层即是目标输出共S2个。


如上图所示，我们可以得知，输入层到隐含层的加权矩阵为：S1*n，偏置矩阵为S1*1；隐含层到输出层的加权矩阵为S2*S1，偏置矩阵为S2*1。

首先，我们先来定义误差函数：

这是一个样本的误差，一组样本的误差就是所有误差之和去均值即可。

相比与感知器神经元，BP网络在权值变化时引入了一个误差效能δk


输入层的权值变化：


隐含层的权值变化：




这里，公式中有一个函数f，我们称之为激活函数，激活函数可以选用：


我这里使用的是logsig函数。

具体的算法实现过程：

1.  初始化权矩阵W1、W2，阈值向量B1、B2；

2.  初置精度控制参数e,学习率a，精度控制变量d= e+1；(t=0,T迭代次数)

3.  While d³ e do

4.  d=0;

5.  for 每个样本（X,Y） do

6.  输入X，计算隐含层输出A；

7.  隐含层输出A作为输出层的输入，计算输出层的输出O（即模型输出）；

8.  计算累积误差：d=d+(yi-oi)2 

9.  根据输出层的误差效能计算隐含层的误差；

10.          根据输出层的误差效能修正W2、B2；

11.          根据隐含层的误差效能修正W1、B1（t++）观察t最后的值是根据t还是精度退出的，如果是根据精度退出则收敛，如果根据T则可能修改算法

下面是具体实现：

主流程类BP()：

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Scanner;

public class BP {
	private ArrayList<Input> inputList = new ArrayList<Input>();
	private double[][] weightOne,weightTwo;
	private double[] baisOne,baisTwo;
	private int hide = 10;
	private int inputLong,outLong;
	public static double alpha = 0.2;
	private double LIMIT = 0.0001;
	private int MAX = 1000000;
	public static void main(String[] args){
		new BP();
	}
	public BP(){
		initMethod();	//读取数据
		weightOne = new double[hide][inputLong];	//输入层到隐含层
		weightTwo = new double[outLong][hide];	//隐含层到输出层
		baisOne = new double[hide];		//输入层到隐含层偏置
		baisTwo = new double[outLong];	//隐含层到输出层偏置
		for(int i = 0;i < weightOne.length;i ++){	//加权阵初始化
			baisOne[i] = Math.random()*2-1;
			for(int j = 0;j < weightOne[i].length;j ++){
				weightOne[i][j] = Math.random()*2-1;
			}
		}
		for(int i = 0;i < weightTwo.length;i ++){	//加权阵初始化
			baisTwo[i] = Math.random()*2-1;
			for(int j = 0;j < weightTwo[i].length;j ++){
				weightTwo[i][j] = Math.random()*2-1;
			}
		}
		for(int i = 0;i < inputList.size();i ++){
			//inputList.get(i).show();
			int temp = 0;
			temp = (int)(Math.random()*10);
			if(temp < 7){
				inputList.get(i).setRead(true);
			}else
				inputList.get(i).setRead(false);
		}
		doing();
	}
	private void doing() {
		// TODO Auto-generated method stub
		double sum = 0;int a = 0,t = 0;
		boolean test = true;
		int temp = 0;
		while(true){
			temp++;
			test = true;
			t=0;
			sum = 0;
			for(int i = 0;i < inputList.size();i ++){
				if(inputList.get(i).isRead()){
					inputList.get(i).firstStep(weightOne, baisOne);
					inputList.get(i).secondStep(weightTwo, baisTwo);
					inputList.get(i).threeStep(weightTwo);
					inputList.get(i).fourStep(weightTwo, baisTwo);
					inputList.get(i).fiveStep(weightOne, baisOne);
					sum += inputList.get(i).getTotalTwo();
					t++;
					/*System.out.print(sum);
					if(sum > LIMIT){
						test = false;
						System.out.print(" *");
					}
					System.out.println("");*/
				}
			}
			sum = 1.0/(2*t)*sum;
			if(sum < LIMIT){
				a = 1;
				for(int m = 0;m < inputList.size();m ++){
					//System.out.println(inputList.get(m).isRead());
					if(!inputList.get(m).isRead()){
						inputList.get(m).test(weightOne, weightTwo, baisOne, baisTwo);
						inputList.get(m).showAnswer();
					}
				}
				/*for(int n = 0;n <weightOne.length;n ++){
					for(int l = 0;l < weightOne[n].length;l ++)
					System.out.print(weightOne[n][l]+" ");
					System.out.println("");
				}
				System.out.println("+++++++++++++++++++");
				for(int n = 0;n <weightTwo.length;n ++){
					for(int l = 0;l < weightTwo[n].length;l ++)
					System.out.print(weightTwo[n][l]+" ");
					System.out.println("");
				}*/
				break;
			}
			if(temp > MAX) {break;}
			if(a == 1){
				break;
			}
		}
		if(temp > MAX)
		System.out.println("尴尬，超出次数了！");
	}
	private void initMethod() {
		// TODO Auto-generated method stub
		String testPath = "carb_x.txt";
		String resultPath = "carb_t.txt";
		try{
			File testFile = new File(testPath);
			File resultFile = new File(resultPath);
			if(testFile.isFile()&&testFile.exists()&&resultFile.isFile()&&resultFile.exists()){
				InputStreamReader readOne = new InputStreamReader(new FileInputStream(testFile),"gbk");
				InputStreamReader readTwo = new InputStreamReader(new FileInputStream(resultFile),"gbk");
				BufferedReader readerOne = new BufferedReader(readOne);
				BufferedReader readerTwo = new BufferedReader(readTwo);
				String lineOne,lineTwo;
				while((lineOne = readerOne.readLine())!=null){
					String[] strOne;
					strOne = lineOne.split("\t");
					Input input = new Input(hide);
					input.setData(change(strOne));
					inputList.add(input);
					inputLong = strOne.length;
				}
				int m = 0;
				while((lineTwo = readerTwo.readLine())!=null){
					String[] strTwo;
					strTwo = lineTwo.split("\t");
					inputList.get(m++).setAim(change(strTwo));
					outLong = strTwo.length;
				}
			
			}
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	private double[] change(String[] strOne) {
		// TODO Auto-generated method stub
		double[] str;
		str = new double[strOne.length];
		for(int i = 0;i < strOne.length;i ++){
			str[i] = Double.parseDouble(strOne[i]);
		}
		return str;
	}
}

输入类型Input()：

public class Input {
	private double[] data;//输入
	private double[] middle;//输入层到隐含层
	private double[] borrow;//隐含层到输出层
	private double[] tempOne;//未激活的隐含层结果
	private double[] tempTwo;//未激活的输出层结果
	private double[] aim;//目标
	private double[] errorTwo;
	private double totalTwo;
	private double[] answer;
	private double[] one,two;	//误差效能
	private boolean read = false;//是否用于测试结果，false表示还未用来学习，true表示
								//这个输入用来学习，不能用于测试了
	//private double[][] w1,w2;
	private void clean(){
		for(int i = 0;i < tempOne.length;i ++){
			tempOne[i] = 0;
			middle[i] = 0;
		}
		for(int i = 0;i < tempTwo.length;i ++){
			tempTwo[i] = 0;
			errorTwo[i] = 0;
			borrow[i] = 0;
		}
		totalTwo = 0;
		for(int i = 0;i < one.length;i ++){
			one[i] = 0;
		}
		for(int i = 0;i < errorTwo.length;i ++){
			two[i] = 0;
		}
		
	}
	
	public void firstStep(double[][] weightOne,double[] baisOne){		//输入层到隐含层
		clean();
		/*w1 = new double[weightOne.length][weightOne[0].length];
		for(int i = 0;i < w1.length;i ++){
			for(int j = 0;j < w1[i].length;j ++){
				w1[i][j] = weightOne[i][j];
			}
		}*/
		for(int i = 0;i < weightOne.length;i ++){
			tempOne[i] = 0;
			for(int j = 0;j < weightOne[i].length;j ++){
				tempOne[i] = tempOne[i] + weightOne[i][j]*data[j];
			}
			tempOne[i]=tempOne[i]+baisOne[i];
			middle[i] = 1.0/(1.0+Math.exp(-tempOne[i]));
		}
	}
	
	public void secondStep(double[][] weightTwo,double[] baisTwo){	//隐含层到输出层
		/*w2 = new double[weightTwo.length][weightTwo[0].length];
		for(int i = 0;i < w2.length;i ++){
			for(int j = 0;j < w2[i].length;j ++){
				w2[i][j] = weightTwo[i][j];
			}
		}*/
		for(int i = 0;i < weightTwo.length;i ++){
			tempTwo[i] = 0;borrow[i]=0;
			for(int j = 0;j < weightTwo[i].length;j ++){
				tempTwo[i] =tempTwo[i] + weightTwo[i][j]*middle[j];
			}
			tempTwo[i]=tempTwo[i]+baisTwo[i];
			borrow[i] = 1.0/(1.0+Math.exp(-tempTwo[i]));
			errorTwo[i] = (aim[i] - borrow[i])*(aim[i] - borrow[i]);
			totalTwo = totalTwo+errorTwo[i];
		}
		//totalTwo = ((double)1/2*totalTwo);
	}

	public void threeStep(double[][] weightTwo){	//计算输出层误差效能
		for(int i = 0;i < errorTwo.length;i ++){
			two[i] = (aim[i] - borrow[i])*borrow[i]*(1-borrow[i]);
		}
		for(int j = 0;j < weightTwo[0].length;j ++){//列
			for(int k = 0;k < weightTwo.length;k ++){//行
				one[j]+= weightTwo[k][j]*two[k];
			}
			one[j] = one[j]*middle[j]*(1-middle[j]);
		}
	}
	
	public void fourStep(double[][] weightTwo,double[] baisTwo){		//重新更新偏置矩阵
		for(int i = 0;i < weightTwo.length;i ++){
			for(int j = 0;j < weightTwo[i].length;j ++){
				weightTwo[i][j] = weightTwo[i][j] + (BP.alpha*two[i]*middle[j]);
			}
			baisTwo[i] = baisTwo[i] + BP.alpha*two[i];
		}
	}
	public void fiveStep(double[][] weightOne,double[] baisOne){		//重新更新偏置矩阵
		for(int i = 0;i < weightOne.length;i ++){
			for(int j = 0;j < weightOne[i].length;j ++){
				weightOne[i][j] = weightOne[i][j] + (BP.alpha*one[i]*data[j]);
			}
			baisOne[i] = baisOne[i] + BP.alpha*one[i];
		}
	}
	
	/*public double activate(double total){		//激活函数
		return (1.0/(1.0+Math.exp(-total)));
	}
	
	public double activateDer(double total){	//激活函数的导数
		return total*(1-total);
	}*/
	
	public void test(double[][] weight1,double[][] weight2,double[] bais1,double[] bais2){
		for(int i = 0;i < weight1.length;i ++){
			for(int j = 0;j < weight1[i].length;j ++){
				tempOne[i] = tempOne[i] + weight1[i][j]*data[j];
			}
			tempOne[i]+=bais1[i];
			middle[i] = 1.0/(1.0+Math.exp(-tempOne[i]));
		}
		for(int i = 0;i < weight2.length;i ++){
			for(int j = 0;j < weight2[i].length;j ++){
				tempTwo[i] = tempTwo[i] + weight2[i][j]*middle[j];
			}
			tempTwo[i] = tempTwo[i]+bais2[i];
			answer[i] = 1.0/(1.0+Math.exp(-tempTwo[i]));
		}
	}
	public void showAnswer(){
		System.out.println("输入：");
		for(int i = 0;i < data.length;i ++){
			System.out.print(data[i]+"  ");
		}
		System.out.println("\n应输出：");
		for(int i = 0;i < aim.length;i ++){
			System.out.print(aim[i]+"  ");
		}
		System.out.println("\n实际输出：");
		for(int i = 0;i < answer.length;i ++){
			System.out.print(answer[i]+"  ");
		}
		System.out.println("\n----------------------------------------------------------------------");
	}
	
	public double[] getAnswer() {
		return answer;
	}
	
	public Input(int hide){
		this.middle = new double[hide];
		this.tempOne = new double[hide];
		this.one = new double[hide];
	}
	public void show(){
		for(int i = 0;i <data.length;i ++){
			System.out.print(data[i]+"  ");
		}
		System.out.print("XXX");
		for(int i = 0;i < aim.length;i ++){
			System.out.print(aim[i]+"  ");
		}
		System.out.println("");
	}
	//------------------set和get方法----------------------------------------------------
	public double[] getData() {
		return data;
	}
	public void setData(double[] data) {
		this.data = data;
	}
	public double[] getMiddle() {
		return middle;
	}
	public void setMiddle(double[] middle) {
		this.middle = middle;
	}
	
	public double[] getTempOne() {
		return tempOne;
	}

	public void setTempOne(double[] tempOne) {
		this.tempOne = tempOne;
	}

	public double[] getTempTwo() {
		return tempTwo;
	}

	public void setTempTwo(double[] tempTwo) {
		this.tempTwo = tempTwo;
	}

	public double[] getAim() {
		return aim;
	}
	public void setAim(double[] aim) {
		this.aim = aim;
		this.borrow = new double[aim.length];
		this.answer = new double[aim.length];
		this.errorTwo = new double[aim.length];
		this.tempTwo = new double[aim.length];
		this.two = new double[aim.length];
	}
	public double[] getErrorTwo() {
		return errorTwo;
	}
	public void setErrorTwo(double[] errorTwo) {
		this.errorTwo = errorTwo;
	}
	public double getTotalTwo() {
		return totalTwo;
	}
	public void setTotalTwo(double totalTwo) {
		this.totalTwo = totalTwo;
	}
	public boolean isRead() {
		return read;
	}
	public void setRead(boolean read) {
		this.read = read;
	}
}

这里参考了一下百度百科： 点击打开链接

Wangchinlung
关注
专栏目录
人工智能 | BP神经网络
⊳ideal world⊲~ヽ(ﾟ︺ﾟ)Hi
01-15 1万+
教材 多层前向神经网络 多层感知网络 多层感知机特点 BP学习 BP算法步骤 给权重赋值 输入样本，开始计算 从后往前计算误差 根据误差修正权重 结束 BP算法学习过程中需要注意的问题 BP网的缺陷 PPT 教师信号、有导师学习 线性可分与线性不可分 例题 多层感知器的提出 感知器能力比较 梯度下降 BP算法局限性 输入量选择
人工智能——神经网络
qq_45882525的博客
06-13 1162
一、人工智能发展简史 1950年，英国科学家艾伦图灵发表了论文讨论创造出具有真正智能的机器的可能性，并提出了著名的图灵测试：如果一台机器能够与人类展开对话而不能被辨别出其机器身份，那么称这台机器具有智能。现在活跃于电脑，手机，还有各种硬件上的“智能助手”在各自的功能领域，通常被大众认为挺有智能的。 从1956年的达特茅斯会议开始，人工智能（Artificial Intelligence，AI）作为一个专门的研究领域出现，经历了超过半个世纪的起伏，终于在2007年前后，迎来了又一次大发展。 二、人工智能的定
BP神经网络简单应用实例,bp神经网络的设计方法
神经网络爱好者
10-04 2664
BP（Back Propagation）网络是1986年由Rumelhart和McCelland为首的科学家小组提出，是一种按误差逆传播算法训练的多层前馈网络，是目前应用最广泛的神经网络模型之一。BP网络能学习和存贮大量的输入-输出模式映射关系，而无需事前揭示描述这种映射关系的数学方程。它的学习规则是使用最速下降法，通过反向传播来不断调整网络的权值和阈值，使网络的误差平方和最小。BP神经网络模型拓扑结构包括输入层（input）、隐层(hide layer)和输出层(output layer)。 人工神经网络
【人工智能】BP神经网络
一拳Marx
12-23 260
人工智能——BP神经网络一、感知器二、反向传播，不断调整三、梯度3.1 局部梯度3.2 Sigmoid函数 一、感知器 二、反向传播，不断调整 三、梯度 3.1 局部梯度 3.2 Sigmoid函数
人工智能——BP神经网络
weixin_41171064的博客
05-29 4914
BP神经网络应该是所有神经网络里面的比较简单易懂的一种。 当然，python是有BP神经网络的库，但是我这次要给的代码，是我自己根据网上大佬的案例，自己手动编写的一个隐含层的一个神经网络模型。 代码的流程如下： 1.读取train训练集数据，读取test测试集数据。 2.对数据进行归一化处理。 3.初始化其中的w（权值），b（偏置）。 4.随机选取一个训练集数据，进行正向传播，h = wi*xi ...
bp神经网络.zip_BP神经网络_bp数据集_人工智能_神经网络_训练集
07-14
训练bp神经网络，内含数据集，直接使用即可
人工智能、优化算法、GA优化BP神经网络对比BP神经网络、回归预测
08-30
在IT领域，人工智能是当前最热门的研究方向之一，而优化算法是实现人工智能高效运作的关键工具。本主题聚焦于一种特定的优化技术——遗传算法（Genetic Algorithm, GA），以及它如何应用于改进传统的反向传播...
人工智能_手写体_BP神经网络实现
09-29
在IT领域，人工智能（AI）是目前最热门的研究方向之一，尤其在图像识别技术中，手写体识别是一项重要的应用。本项目聚焦于利用BP（Backpropagation）神经网络实现手写体识别，通过Python编程语言进行搭建和训练。...
人工智能-项目实践-鸢尾花分类-Python 基于BP神经网络实现鸢尾花的分类
06-22
人工智能-项目实践-鸢尾花分类-Python 基于BP神经网络实现鸢尾花的分类 本文用Python实现了BP神经网络分类算法，根据鸢尾花的4个特征，实现3种鸢尾花的分类。 算法参考文章：纯Python实现鸢尾属植物数据集神经网络...
基于 BP 神经网络的加法器设计与实现（原创17页） 人工智能技术大报告 MATLAB BP神经网络工具箱
11-21
如何使用Matlab中BP神经网络工具箱进行加法器的设计和代码的编写 压缩包内容: BP.m----MATLAB代码实现 ; 基于BP神经网络的加法器设计与实现.docx ; 基于BP神经网络的加法器设计与实现.pdf ; 所有数据.xlsx 文档目录:...
人工智能神经网络BP算法简单示例
04-08
该程序是根据《人工智能》教材中一个小示例编写的神经网络程序。实现权值的调节。
人工智能课内实验之神经网络的BP算法
06-22
用BP算法拟合Sin函数，可视化，可动态模拟训练过程。不限于拟合Sin，可以修改为其它函数。 文章的说明链接：http://blog.csdn.net/zheng_ai/archive/2010/06/22/5685663.aspx 本工程是VS2008下建立的。
智能计算之神经网络(BP)介绍
PY洋洋
06-21 8924
1. 神经网络流行原因 2. 人工神经网络定义 3. 人工神经网络的学习能力 4.人工神经网络的基本原理 5. 神经网络的研究进展 6.神经网络的典型结构 6.1 单层感知器网络 6.2 前馈型网络 6.3 前馈内层互联网络 6.4 反馈型网络 6.5 全互联网络 7. 神经网络的学习算法 7.1 学习方法 7.2 学习规则 8. BP神经网络 8.1 基本思想 8.2 算法流程 8.3 举例...
人工智能导论课对BP神经网络的实践 记录
weixin_59398528的博客
12-09 866
第一次写BP神经网络，纪念一下，顺便以后用的时候方便拿
【人工智能Ⅰ】实验9：BP神经网络
最新发布
m0_65787507的博客
12-29 2899
整体代码和准确率计算结果如下图所示，其中图1为整体代码，图2为计算的准确率结果（分类的准确率为0.7）。整体代码、标签对比结果和混淆矩阵结果如下图所示，其中图1为整体代码，图2为程序输出的标签对比结果，图3为程序输出的混淆矩阵结果。整体代码和直方图可视化结果如下图所示，其中图1为整体代码，图2为花萼长度直方图，图3为花萼宽度直方图，图4为花瓣长度直方图，图5为花瓣宽度直方图。整体代码和输出结果如下图所示，其中图1为整体代码，图2为程序输出的计算结果（训练集准确率为98%，测试集准确率为98%）。
BP神经网络-（参考游戏编程中的人工智能技术）
魏军的博客
10-18 457
BP神经网络，采用有监督的训练方法，有监督的训练方法适用于已经具备可以用来训练网络的各种数据例子。 他的工作过程：把一个输入模式送给网络，考察他这时的输出，并将它的输出与慕白哦输出进行比较，如果实际的输出和目标的输出不同，则网络的所有权重都要稍作改变。 使它下一次的输出和期望的记过接近一i点。这一过程必须对要求网络学习的每一种输入模式进行重复，直到网络能正确识别每一种为止。 反向传播
BP神经网络
热门推荐
ACdreamer
03-26 20万+
今天来讲BP神经网络，神经网络在机器学习中应用比较广泛，比如函数逼近，模式识别，分类，数据压缩，数据 挖掘等领域。接下来介绍BP神经网络的原理及实现。   Contents     1. BP神经网络的认识   2. 隐含层的选取   3. 正向传递子过程   4. 反向传递子过程   5. BP神经网络的注意点   6. BP神经网络的C++实现     1. BP神经
【转载】用平常语言介绍神经网络
weixin_30809173的博客
02-16 387
http://wenku.baidu.com/link?url=23jM13V3Qe9Zx84FuEMebOMbTSk4i0Oaa5YPAVL1dfbSFC4G20GYDkUbbRvcJILgTGliXHPQgZqx5ToZscEOt0Iwp4eT71mRZhZ64USYk63 用平常语言介绍神经网络 (Neural Networks in Plain English) 因为我们没有能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值