关于bp神经网络算法的总结

最新推荐文章于 2024-04-20 16:19:16 发布
最新推荐文章于 2024-04-20 16:19:16 发布
阅读量658 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42637581/article/details/86688130
版权

学习自： https://blog.csdn.net/QKK612501/article/details/52893803
需要用以下两行代码：

#include"bpNetwork.h"
using namespace bpNetwork;

介绍：

提供 “basicNode” 类
定义：

basicNode<typename _type>(nodeType type,_type(*function)(vector<_type>,int,_type theta));

nodeType 有如下种类：
FRONT_NODE ：输入节点
MID_NODE ：隐藏节点（默认）
END_NODE：输出节点

function 是数据处理函数指针，
数据处理函数要有如下参数：
vector<_type> :提供数据
int :数据长度
_type :权值

头文件自带数据处理函数有：
Identity
Binary_Step
Logistic（Sigmoid）
tanh
arctan
RelU
PRelU
ElU
Softplus
转载图片
basicNode类提供以下函数：

void giveData(_type Num);

提供输入。参数：输入数据

void addSon(basicNode* sonNode,_type(*con)(_type,_type),_type w=1);

添加子节点。参数：子节点指针，连接函数指针，权值（默认为1）
连接函数参数：数据，权值
头文件目前只提供：
Identity

void func(_type(*solveDat)(vector<_type>,int,_type));

改变数据处理函数。参数：见上

void searchSon(vector<basicNode<_type>*>* hiddenPoints,vector<basicNode<_type>*>* endPoints,vector<basicNode<_type>*>* edgeStack,vector<basicNode<_type>*>* nodeStack)

搜索子节点并入vector。参数：隐藏节点vector指针，末节点vector指针，读边学习vector指针，读节点学习vector指针

void endResult(_type* res)

确定返回数据指针。参数：返回指针

void exchangeTheta(_type newTheta);
void exchangeTheta(long id,_type newTheta);
void exchangeDerta(_type newTheta);
void exchangeDerta(long id,_type newTheta);

改权值。

long long getSonNum()

获得子节点数

void saveNode(const char * __restrict__ _Filename);
void saveNode(FILE* _FilePointer);
void readNode(const char * __restrict__ _Filename);
void readNode(FILE* _FilePointer);

存储节点到文件（不完备）

头文件自带学习函数（不完备）：

void faltBack(vector<_type> inputs,vector<_type> outputs,vector<basicNode<_type>*>* inputPoints,unsigned long long learnTimes,_type learnWeight,double(*resultFunction)(vector<_type>*,vector<_type>*,vector<_type>*));//double resultFunciton(vector<_type>* wantOut,vector<_type*>* factOut,vector<_type>* oldOut) return weight:positive for

参数：输入数据vector，期望输出数据vector，输入节点指针vector的指针，学习次数，学习力度，权值计算函数（参数：希望输出数据vector的指针，实际输出的指针vector的指针，测试优化前输出。返回值：正数表示劣化了，负数表示优化了）

应用

我写的小型bp神经网络
bp神经网络
源代码(C++)

#include<bits/stdc++.h>
#include"bpNetwork.h"
using namespace std;
using namespace bpNetwork;

FILE* sav;
float result,input;
int main(){
	sav=fopen("save.sav","r");
	basicNode<float>
	node1(FRONT_NODE,&Logistic),
	node2(MID_NODE,&Logistic),
	node3(MID_NODE,&Logistic),
	node4(MID_NODE,&Logistic),
	node5(MID_NODE,&Logistic),
	node6(MID_NODE,&Logistic),
	node7(MID_NODE,&Logistic),
	node8(MID_NODE,&Logistic),
	node9(MID_NODE,&Logistic),
	node10(END_NODE,&Logistic);
	node1.addSon(&node2,&Identity);
	node1.addSon(&node3,&Identity);
	node1.addSon(&node4,&Identity);
	node2.addSon(&node4,&Identity);
	node2.addSon(&node6,&Identity);
	node3.addSon(&node4,&Identity);
	node3.addSon(&node5,&Identity);
	node4.addSon(&node6,&Identity);
	node4.addSon(&node7,&Identity);
	node5.addSon(&node7,&Identity);
	node5.addSon(&node8,&Identity);
	node6.addSon(&node7,&Identity);
	node6.addSon(&node9,&Identity);
	node7.addSon(&node8,&Identity);
	node7.addSon(&node9,&Identity);
	node7.addSon(&node10,&Identity);
	node8.addSon(&node10,&Identity);
	node9.addSon(&node10,&Identity);
	node10.endResult(&result);
	scanf("%f",&input);
	node1.giveData(input);
	printf("%f",result);
}

代码

(我写的)头文件：bpNetwork.h

/*
   Copyright (c) 2019 BooleanWar project,all rights reserved.

   Permission is hereby granted, free of charge, to any person obtaining a
   copy of this software and associated documentation files (the "Software"),
   to deal in the Software without restriction, including without limitation
   the rights to use, copy, modify, merge, publish, distribute, sublicense,
   and/or sell copies of the Software, and to permit persons to whom the
   Software is furnished to do so, subject to the following conditions:

   The above copyright notice and this permission notice shall be included in
   all copies or substantial portions of the Software.

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
   DEALINGS IN THE SOFTWARE.
*/
#include<bits/stdc++.h>
#include<windows.h>
#include<conio.h>
#include<math.h>
#include<pthread.h>
using namespace std;
/************************************************************************************************************************/
namespace bpNetwork{
#define FUNC(e,f,p) e(*f)(p)
typedef int nodeType;
#define FRONT_NODE 0
#define MID_NODE 1
#define END_NODE 2

double arctan(double x)
{
	int i;
	double r,e,f,sqr;
	sqr=x*x;
	r=0; e=x; i=1;
	while(e/i>1e-15)
	{
		f=e/i;
		r=(i%4==1)? r+f : r-f;
		e=e*sqr; i+=2;
	}
	return r;
}
/************************************************************************************************************************/
//connection function
template <typename _type>
_type Identity(_type DATA,_type weight){
	return DATA*weight;
}
//solve Data Functions 
template <typename _type>
_type Identity(vector<_type>DATA,int vectorLen,_type THETA)
{
	_type res=DATA[0];
	for(int i=1;i<vectorLen;i++)
		res=res+DATA[i];
	res=res*THETA;
	return res;
}

template <typename _type>
_type Binary_Step(vector<_type>DATA,int vectorLen,_type THETA)
{
	_type res=DATA[0];
	for(int i=1;i<vectorLen;i++)
		res=res+DATA[i];
	res=res*THETA;
	return res>=0?1:0;
}

template <typename _type>
_type Logistic(vector<_type>DATA,int vectorLen,_type THETA)
{
	_type res=DATA[0];
	for(int i=1;i<vectorLen;i++)
		res=res+DATA[i];
	res=res*THETA;
	return 1/(1+pow(M_E,res));
}

template <typename _type>
_type Sigmoid(vector<_type>DATA,int vectorLen,_type THETA)
{
	_type res=DATA[0];
	for(int i=1;i<vectorLen;i++)
		res=res+DATA[i];
	res=res*THETA;
	return 1/(1+pow(2.7182818,res));
}

template <typename _type>
_type tanh(vector<_type>DATA,int vectorLen,_type THETA)
{
	_type res=DATA[0];
	for(int i=1;i<vectorLen;i++)
		res=res+DATA[i];
	res=res*THETA;
	return tanh(res);
}

template <typename _type>
_type arctan(vector<_type>DATA,int vectorLen,_type THETA)
{
	_type res=DATA[0];
	for(int i=1;i<vectorLen;i++)
		res=res+DATA[i];
	res=res*THETA;
	return arctan(res);
}

template <typename _type>
_type RelU(vector<_type>DATA,int vectorLen,_type THETA)
{
	_type res=DATA[0];
	for(int i=1;i<vectorLen;i++)
		res=res+DATA[i];
	res=res*THETA;
	return res>=0?res:0;
}

template <typename _type>
_type PRelU(vector<_type>DATA,int vectorLen,_type THETA)
{
	_type res=DATA[0];
	for(int i=1;i<vectorLen;i++)
		res=res+DATA[i];
	return res>=0?res*THETA:res;
}

template <typename _type>
_type ElU(vector<_type>DATA,int vectorLen,_type THETA)
{
	_type res=DATA[0];
	for(int i=1;i<vectorLen;i++)
		res=res+DATA[i];
	return res>=0?res*THETA:res;
}

template <typename _type>
_type Softplus(vector<_type>DATA,int vectorLen,_type THETA)
{
	_type res=DATA[0];
	for(int i=1;i<vectorLen;i++)
		res=res+DATA[i];
	return log(1+pow(M_E,res));
}
/************************************************************************************************************************/
//other public functions
template<typename _type>
	class basicNode{
	public:
		basicNode(nodeType type=MID_NODE,_type(*function)(vector<_type>,int,_type)=NULL):fatherNum(NULL),sonNum(NULL),type(type),theta(NULL),solveData(function),dataPoint(0),singleWeight(1){}

		void giveData(_type Num){
			_type dat;
			data.push_back(Num);
			dataPoint++;
			if(dataPoint>=fatherNum)
				if(type==MID_NODE||type==FRONT_NODE){
					dat=solveData(data,fatherNum,singleWeight);
					for(int i=0;i<sonNum;i++){
						(*sons[i]).giveData((*connections[i])(dat,weight[i]));//wrong grammer
					}
					resetData();
				}
				else
				{
					(*result)=solveData(data,fatherNum,singleWeight);
				}
		}

		void addSon(basicNode* sonNode,_type(*con)(_type,_type),_type w=1){
			sons.push_back(sonNode);
			connections.push_back(con);
			weight.push_back(w);
			sonNum++;
			(*sonNode)._addFa(this);
		}

		void _addFa(basicNode* fatherNode){
			fathers.push_back(fatherNode);
			fatherNum++;
		}
		
		void func(_type(*solveDat)(vector<_type>,int,_type)){
			solveData=solveDat; 
		}
		
		void searchSon(vector<basicNode<_type>*>* hiddenPoints,vector<basicNode<_type>*>* endPoints,vector<basicNode<_type>*>* edgeStack,vector<basicNode<_type>*>* nodeStack){
			(*nodeStack).push_back(this);
			for(int i=0;i<sonNum;i++){
				switch((*sons[i]).type){
					case FRONT_NODE:
					case MID_NODE:
						(*edgeStack).push_back(this);
						for(int j=0;j<(*hiddenPoints).length();j++)
							if((*hiddenPoints)[j]==sons[j])return;
						(*hiddenPoints).push_back(sons[i]);
						(*sons[i]).search(hiddenPoints,endPoints);
						break;
					case END_NODE:
						for(int i=0;i<(*endPoints).length();i++)
							if((*endPoints)[i]==sons[i])return;
						(*endPoints).push_back(sons[i]);						
						break;
				}
			}
		}
		
		void endResult(_type* res){
			result=res;
		}
		void exchangeTheta(_type newTheta){
			theta=newTheta;
		}
		void exchangeTheta(long id,_type newTheta){
			weight[id]=newTheta;
		}
		void exchangeDerta(_type newTheta){
			theta=newTheta+theta;
		}
		void exchangeDerta(long id,_type newTheta){
			weight[id]=newTheta+weight[id];
		}
		long long getSonNum(){
			return sonNum;
		}
/************************************************************************************************************************/
//save Node functions
		void saveNode(const char * __restrict__ _Filename){
		FILE* standard=stdout;
		freopen(_Filename,"w",stdout);
		cout<<"Node Theta:"<<theta<<endl;
		stdout=standard;
		}
		void saveNode(FILE* _FilePointer){
		FILE* standard=stdout;
		stdout=_FilePointer;
		cout<<"Node Theta:"<<theta<<endl;
		stdout=standard;
		}
/************************************************************************************************************************/
//read Node functions
		void readNode(const char * __restrict__ _Filename){
		FILE* standard=stdin;
		freopen(_Filename,"r",stdin);
		scanf("Node Theta:");
		cin>>theta;
		scanf("\n");
		stdin=standard;
		} 
		void readNode(FILE* _FilePointer){
		FILE* standard=stdin;
		stdin=_FilePointer;
		scanf("Node Theta:");
		cin>>theta;
		scanf("\n");
		stdin=standard;
		} 
/************************************************************************************************************************/
	private://private defines
		nodeType type;									
		_type* result;										
		vector<basicNode*>sons;								
		vector<basicNode*>fathers;							
		vector<_type(*)(_type,_type)>connections;					
		vector<_type>data;									
		vector<_type>weight;
		_type(*solveData)(vector<_type>,int,_type);
		long long fatherNum;
		long long sonNum;
		int dataPoint;
		_type singleWeight;									
		_type theta;								
/************************************************************************************************************************/
//private functions
		void resetData(){
			data.clear();
			dataPoint=0;
		}
	};
/************************************************************************************************************************/
//global functions
template<typename _type>
	void faltBack(vector<_type> inputs,vector<_type> outputs,vector<basicNode<_type>*>* inputPointsPointer,unsigned long long learnTimes,_type learnWeight,double(*resultFunction)(vector<_type>*,vector<_type>*,vector<_type>*)){//double resultFunciton(vector<_type>* wantOut,vector<_type*>* factOut,vector<_type>* oldOut) return weight:positive for
		vector<basicNode<_type>*> inputPoints=*inputPointsPointer;
		vector<basicNode<_type>*> hiddenPoints;
		vector<basicNode<_type>*> endPoints;
		vector<basicNode<_type>*> exchangeEdge;
		vector<basicNode<_type>*> exchangeNode;
		vector<_type*> outputsPoints;
		vector<_type> outputsPast;
		_type derta;
		int weight;
		bool lastIsNegative=false;
		for(long long i=0;i<inputPoints.length();i++)
		{
			exchangeEdge.push_back(inputPoints[i]);
			exchangeNode.push_back(inputPoints[i]);
			(*inputPoints)[i].searchSon(&hiddenPoints,&endPoints,&exchangeEdge,&exchangeNode);
		}//search nodes
		for(long long i=0;i<outputs.length();i++){
			endPoints.push_back(new _type);
			(*endPoints).endResult(outputsPoints[i]);
		}//set return points
		for(long long i=0;i<inputPoints.length();i++)
			(*inputPoints).giveData(inputs[i]);
		//input
		for(long long i=0;i<endPoints.length();i++)
			outputsPast.push_back(*endPoints[i]);
		//set outputs
		for(long long i=0;i=learnTimes;i++){
			//study
			for(long long j=0;j<exchangeEdge.length();j++)
				//start&mid nodes
				for(long long k=0;k<(*exchangeEdge[j]).getSonNum;k++)
				{
					//for each edge
					weight=1;
reset:				for(long long i=0;i<endPoints.length();i++)
						outputsPast[i]=*endPoints[i];
					//reset old output
					(*exchangeEdge[j]).exchangeDerta(k,learnWeight*weight);
					//reset weight
					for(long long i=0;i<inputPoints.length();i++)
						(*inputPoints).giveData(inputs[i]);
					//input
					if(resultFunction(&outputs,&endPoints,&outputsPast)>0){
						weight*=-1;
						if(lastIsNegative)
							weight*=0.5;
						else lastIsNegative=true;
					}
					else lastIsNegative=false;
					//change weight
					if(weight>=0.01||weight<=-0.01)
						goto reset;
					//loop
				}
			for(long long j=0;j<exchangeNode.length();j++){
					weight=1;
					//set weight
reset2:				for(long long i=0;i<endPoints.length();i++)
						outputsPast[i]=*endPoints[i];
					//reset old output
					(*exchangeEdge[j]).exchangeDerta(k,learnWeight*weight);
					//change weight
					for(long long i=0;i<inputPoints.length();i++)
						(*inputPoints).giveData(inputs[i]);
					//input
					if(resultFunction(&outputs,&endPoints,&outputsPast)>0){
						weight*=-1;
						if(lastIsNegative)
							weight*=0.5;
						else lastIsNegative=true;
					}
					else lastIsNegative=false;
					//change weight
					if(weight>=0.01||weight<=-0.01)
						goto reset2;
					//loop
			}
		}
	for(long long i=0;i<outputs.length();i++){
		delete endPoints[i];
	//free memory
}
}
Ritanlisa
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
BP 神经网络 定位算法实现过程总结
tiny_xie的专栏
12-17 2182
BP神经网络定位想法，以及实现， 如果要实现代码。 发邮件给我。 不过网上也多得很。
BP算法
linnayoo的博客
04-23 5816
BP神经算法 (一)Bp 神经网络的简单理解 Bp神经网络可以分为两个部分，bp和神经网络。 bp是 Back Propagation 的简写 ，意思是反向传播。而神经网络，听着高大上，其实就是一类相对复杂的计算网络。举个简单的例子来说明一下，什么是网络。 看这样一个问题，假如我手里有一笔钱，N个亿吧(既然是假设那就不怕吹牛逼)，我把它分别投给5个公司，分别占比 M1，M2，M3，M4，M5（M1到M5均为百分比 %）。而每个公司的回报率是不一样的，分别为 A1， A2， A3， A4， A5，（A1到A5
BP神经网络的总结
RitaAndWakaka的博客
06-03 571
参考优秀博客： 一文彻底搞懂BP算法：原理推导+数据演示+项目实战（上篇） 深度学习 --- BP算法详解（流程图、BP主要功能、BP算法的局限性 我的思维导图整理： 我的手写笔记： ...
（原创）大数据时代：基于微软案例数据库数据挖掘知识点总结（Microsoft 神经网络分析算法）...
weixin_33885253的博客
11-02 238
前言 有段时间没有进行我们的微软数据挖掘算法系列了，最近手头有点忙，鉴于上一篇的神经网络分析算法原理篇后，本篇将是一个实操篇，当然前面我们总结了其它的微软一系列算法，为了方便大家阅读，我特地整理了一篇目录提纲篇：大数据时代：深入浅出微软数据挖掘算法总结连载，我打算将微软商业智能中在DM这块所用到的算法全部集中在这个系列中，每篇包含简要算法原理、算法特点、应用场景以及具体的操作详细步骤，基本能涵盖...
BP神经网络算法原理-bp神经网络模型-bp神经网络代码matlab-学习笔记
botf201802的博客
04-20 2045
matlab提供了一个工具箱来实现BP神经网络，bp神经网络模型matlab工具箱还提供了非常多的训练算法，不过默认一般使用trainlm算法。BP神经网络的原理就像下面的图一样，模仿人的大脑的原理，把看到的东西作为输入，然后经过大脑，最后作为输出。在学习一段时间后，开始有些知识有些遗忘，所以整理一下，作为自己的学习笔记，以及帮助其他人学习。这是一个只有一个隐层的BP神经网络(加上输入层、输出层，称为三层BP神经网络)，在代码中我们用到newff函数，train函数，sim函数，具体的意义可以参考。
BPN.zip_BP神经网络算法
09-24
总结来说，BP神经网络算法是一种基于梯度下降的学习算法，通过不断调整权重来最小化预测误差。虽然存在一些挑战，但通过不断的理论研究和实践创新，BP神经网络仍然是现代人工智能领域的重要工具。
BP神经网络算法步骤.pdf
04-01
总结来说，BP神经网络算法通过不断迭代，逐步调整网络的权重和偏置，以最小化输出误差，实现对输入样本的准确预测。这个过程需要大量的计算资源，但通过现代计算机硬件和优化算法，BP网络已经成为解决许多复杂问题的...
遗传算法优化BP神经网络
08-18
总结来说，遗传算法优化的BP神经网络是利用生物进化策略改进传统神经网络学习过程的一种有效手段，它能够克服BP网络的局限性，提升模型在处理复杂非线性问题时的性能。案例中的实现展示了如何将这两种技术结合，为非...
BP神经网络算法程序.doc
05-07
总结来说，BP神经网络算法是通过反向传播误差来不断调整网络权重，以实现对复杂函数的近似。动量梯度下降和贝叶斯正则化都是为了改善训练过程，前者加速收敛，后者提升泛化性能。在MATLAB中，可以利用内置函数方便地...
基于python实现的BP神经网络算法源码.zip
最新发布
06-16
**BP神经网络算法详解** BP（Backpropagation）神经网络是一种经典的、用于处理非线性问题的监督学习算法，尤其在模式识别、函数拟合等领域有着广泛应用。它通过反向传播误差来调整网络中各层权重，从而实现对输入...
神经网络实验报告
04-09
这是一个BP算法实验报告，是郑州大学的，大家可以参考下
关于BP神经网络概念与实践
WeskerXR的博客
10-06 1056
BP神经网络 BP神经网络的概念 BP（Back Propagation）算法，是一种有效的多层神经网络学习方法，能学习和存贮大量的 输入-输出模式映射关系。 学习规则 是使用最速下降法，通过反向传播来不断 调整网络的权值和阈值，使网络的误差平方和最小。而无需事前揭示描述这种映射关系的数学方程。 主要特点 是信号前向传递，而误差后向传播，通过不断调节网络权重值，使得网络的最终输出与期望输出尽可能接...
BP神经网络学习心得1
weixin_43905656的博客
11-05 510
1
【机器学习】BP算法学习笔记
木木家
06-02 4230
BP即Back Propagation的缩写，也就是反向传播的意思，顾名思义，将什么反向传播？一张动态图可以说明 这个网络的工作原理应该很清楚了，首先，一组输入x1、x2、…、xm来到输入层，然后通过与隐层的连接权重产生一组数据s1、s2、…、sn作为隐层的输入，然后通过隐层节点的f(.) 激活函数后变为fi(e)f 其中sj表示隐层的第j个节点产生的输出，这些输出将通过隐层与输出层
BP算法心得体会
SCUT_Sam
01-15 3806
摘要： 关于BP算法（误差反向传播）网上的学习、参考资料已经有很多了。每篇文章都差不多，都是在阐述BP的数学原理或者实践。本篇文章其实也和网上大部分文章一样，但从一个初学者的角度来分享学习这个算法的过程的一些体会。 参考资料： 知乎-BP算法 清晰的数学推导 预先定义： 网上许多资料都是以单层的神经网络为例推导BP算法，本文用一个两个隐藏层的神经网络为例推导BP算法。（其实结果
BP神经网络学习与实践
肖永威的专栏
11-02 1834
BP(back propagation)神经网络是1986年由Rumelhart和McClelland为首的科学家提出的概念，是一种按照误差逆向传播算法训练的多层前馈神经网络，是目前应用最广泛的神经网络。 目前，在人工神经网络的实际应用中，绝大部分的神经网络模型都采用BP网络及其变化形式。它也是前向网络的核心部分，体现了人工神经网络的精华。 本文学习网上资源，重新推导一遍公式，加深来对神经网络的理解。 ...
BP神经网络 原理 心得
aflyeagle的专栏
11-05 2370
        近日我看BP神经网络，有这样一点心得：      所谓“反向传播”，并不是误差真的由后面传过来的，而是因为，在计算第i层到第i+1层 之间的网络权值的修改量时，要用到要用到第i+1层网络输出的误差值，而第i+1层网络输出的误差值的求取，却要用到第i+2层网络的的误差值。因此，这个误差从整个网络系统的输出层一层一层往前传播，直到输入层，正是在这
bp神经网络实验分析,BP神经网络实验报告
aifamao6的博客
09-07 3188
网络的训练过程与使用过程了两码事。比如BP应用在分类，网络的训练是指的给你一些样本，同时告诉你这些样本属于哪一类，然后代入网络训练，使得这个网络具备一定的分类能力，训练完成以后再拿一个未知类别的数据通过网络进行分类。这里的训练过程就是先伪随机生成权值，然后把样本输入进去算出每一层的输出，并最终算出来预测输出（输出层的输出），这是正向学习过程；最后通过某种训练算法（最基本的是感知器算法）使得代价（预测输出与实际输出的某范数）函数关于权重最小，这个就是反向传播过程。
对于BP神经网络的一些理解
m0_64818136的博客
08-13 458
一些小理解
BP神经网络详解与学习算法总结
总结来说，该文档详细介绍了BP神经网络的基础结构，学习问题的定义，以及BP学习算法的核心思想，这对于理解和应用神经网络技术，特别是解决实际问题中的分类、回归等问题具有重要意义。通过深入理解BP算法，学生可以...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值