@丁香丛中的雪狼 看起来是很高深的东西呢。。。楼主能不能告诉我，这些是用于做什么的？

就是拟合出个函数，输入任意维度的那种。。。
虽然不管怎么想，最简单的方法就是最小二乘法处理下就完事了。但想象中觉得写个 自动生成函数然后进行矩阵运算 的程序好麻烦呀。。。
其实原理很简单的。而且发这帖子主要因为，反向传播的那个公式，昨天我刚发现公式推导是错的，而且当时我稀里糊涂的就信了，就好气了。。。

设第n层和第m层，且n=m+1
如代码所示，
将神经模型： \( y_n = f( \sum y_{m,i} * w_{m,i} ) \) ，\( y_{0,i}=x_i\)
改为： \( y_n = \sum x_i * y_{m,i}\)
将反向传播模型：\( dw_{m,i} = dy_n * f' * y_{m,i}\)
\( dy_{m,i} = dy_n * f' * w_{m,i}\)
改为： \( dy_{m,i} = dy_n / x_i ,(x_i 不为0) \)
\( dy_{m,i} = 0 ,(x_i = 0) \)

测试用代码

#include <stdio.h>
#include <time.h>
#include <math.h>
#include <stdlib.h>
#include <iostream>
#include <fstream>
#include<vector>

#include"B_poly.h"

using std::cout;
using std::cerr;
using std::endl;
using std::ends;
using std::ofstream;
using std::ifstream;

using std::vector;




int Data=11000;
int Inn=2;
int Outn=1;

vector<vector<double> > In;
vector<vector<double> > Out;

void writeTest(){
	double r1,r2;
	int i;
	srand((unsigned)time(NULL));
	
	ofstream f1("in_1.txt");
	if(f1.fail()){
		cerr<<"can not open the in file"<<endl;
		exit(0);
	}
	ofstream f2("out_1.txt");
	if(f2.fail()){
		cerr<<"can not open the out file"<<endl;
		exit(0);
	}


	for(i=0;i<Data;i++){
		r1=rand()%1000/1.0;
		r2=rand()%1000/1.0;
		f1<<r1<<" "<<r2<<endl;
		f2<<sqrt(r1*r1+r2*r2)<<endl;
	}
	f1.close();
	f2.close();
}

void readData(){
	int i,j;
	double t;
	vector<double> in_;
	
	ifstream f1("in_1.txt");
	if(f1.fail()){
		cerr<<"can not open the in file"<<endl;
		exit(0);
	}
	for(i=0;i<Data;i++){
		for(j=0; j<Inn; j++){
			f1 >> t;
			in_.push_back(t);
		}
		In.push_back(in_);
		in_.clear();
	}
		
			
	ifstream f2("out_1.txt");
	if(f2.fail()){
		cerr<<"can not open the out file"<<endl;
		exit(0);
	}
	for(i=0;i<Data;i++)
		for(j=0; j<Outn; j++){
			f2 >> t;
			in_.push_back(t);
			Out.push_back(in_);
			in_.clear();
		}
}



int main(){
	Ploy_stream p;
	p.updatatime=20;
	
	writeTest();
	readData();
	
	int i,n=In.size();
	//cout<<n<<endl;
	for(i=0;i<n;++i){
		p.add_sample(In[i],Out[i][0]);
	}
	p.train();
	
	int j,x=0;
	vector<double> a;
	for (i = 1;i <= 1000; i+=100){
        for (j = 1;j <= 1000; j+=100){
        	a.push_back(i);
        	a.push_back(j);
        	p.math(a);
            printf("[%d,%d]=%.1lf  ",i,j,p.poly.y);
            a.clear();
            x++;
            if (x%10==0){
				printf("\n");
            }
        }
	}
}

实现的代码

#include<vector>
#include<cassert>
#include<cmath> 
#include<iostream>
using std::fabs;
using std::vector;
using std::cout;
using std::endl;
using std::ends;

typedef double Data_0;
class Data_1{
public:
	vector<double> 	data;
	
	Data_1(){}
	Data_1(vector<double> d){
		int i,n=d.size();
		for(i=0;i<n;++i){
			data.push_back(d[i]);
		}
	}
	operator vector<double>(){		return data;	}
	double& operator[](unsigned int i){
		assert(i<=data.size());
		if(i==data.size()){
			data.resize(i+1);
		}
		return data[i];
	}
	int size(){		return data.size();	}
	void add(vector<double> a){		data.insert(data.end(),a.begin(),a.end());	}
};



/*
class Cell{
public:
	double y;
	double dy;
	vector<double > w;
};*/
class Ploycell{
public:
	double y;
	double dy;
	vector<Ploycell > *w;
	
	
	Ploycell():y(0),dy(0){	
		w = new vector<Ploycell>;
	}
	//Ploycell(int y_):y(y_),dy(0){		w = new vector<Ploycell>;}
	Ploycell(const Ploycell &p):y(p.y),dy(p.dy),w(p.w){}
	Ploycell& operator =(const Ploycell &p){		y=p.y,dy=p.dy,w=p.w;return *this;	}
	void clean(){
		int i,n=w->size();
		for(i=0;i<n;++i){
			(*w)[i].clean();
		}
		delete w;
	}
	~Ploycell(){}
	operator Data_1(){
		Data_1 a;
		int i,n=w->size();
		for(i=0;i<n;++i){
			a.data.push_back((*w)[i].y);
		}
		return a;
	}
	
	
	
	void fun(Data_1& d){	//Data_1 operator*(Data_1);
		y=0;
		dy=0;
		unsigned int i,n=d.size();
		if(w->size()<n){
			w->resize(n);
		}
		n=w->size();
		d.data.resize(n,0);
		for(i=0;i<n;++i){
			if((*w)[i].w->size()!=0){/////////////////
				(*w)[i].fun(d);
			}
			y += (*w)[i].y * d[i];//f(x)=x
		}
	}
	void updata_0(const Data_1& d){
		int i,n=w->size();
		if(n==0)	return;
		for(i=0;i<n;++i){
			(*w)[i].dy = dy * d.data[i];
			(*w)[i].updata_0(d);
		}
		dy=0;
	}
	void updata_1(double p=1){
		int i,n=w->size();
		if(n==0){
			y -= dy;
			dy *= p;
		}else{
			for(i=0;i<n;++i)
				(*w)[i].updata_1();
		}
	}
	void updata_2(){
		int i,n=w->size();
		if(n==0){
			(*w).resize(1);
			return;
		}
		for(i=0;i<n;++i){
			(*w)[i].updata_2();
		}
	}
};

class Ploy_stream{
public:
	Ploycell poly;
	vector<Data_1> sample_i;
	vector<double> sample_o;
	double e000;
	int updatatime;
	
	
	Ploy_stream():e000(0.01),updatatime(100){}
	~Ploy_stream(){
		poly.clean();
	}
	
	
	void add_sample(Data_1 i,Data_0 o){
		sample_i.push_back(i);
		sample_o.push_back(o);
	}
	void add_sample(vector<double> i,double o){
		Data_1 a;
		a.data.push_back(1);
		a.data.insert(a.data.end(),i.begin(),i.end());
		add_sample(a,o);
	}
	double math(Data_1 in){
		poly.fun(in);
		return poly.y;
	}
	void math(vector<double> in){
		Data_1 a;
		a.data.push_back(1);
		a.data.insert(a.data.end(),in.begin(),in.end());
		math(a);
	}
	void train(){
		double l=1;
		int i,n=sample_i.size();
		double E,e=1000000000;
		int t=0,time=10000;
		int T=0;//updatatime=100
		
		Data_1 a; 
		int j,m;
		
		
		do{
			E=0;
			for(i=0;i<n;++i){
				poly.fun(sample_i[i]);
				poly.dy = (poly.y-sample_o[i])*l/n;
				E=fabs(poly.y-sample_o[i]);
				//a=sample_i[i];
				m=sample_i[i].data.size();
				a.data.resize(m);//a.data.clear(); 
				for(j=0;j<m;++j){
					//误差还原 		//y=sum(w[i]*x[i]),,dy=sum(dw*x),dw[i]=dy/x[i]	// ->dw[i]=dy/x[i]*k?
					if(sample_i[i][j]==0){
						a[j]=0;
					}else{
						a[j]=1.0/sample_i[i][j];
					} 
				}
				poly.updata_0(a);
			}
			poly.updata_1(1);
			
			if(e/E<1.1){
				l*=0.5;
				++T;
				if(T%updatatime==0){// updatatime=10； 
					poly.updata_2();
					l=1;
				}
			}
			cout<<t<<"\t"<<E<<endl;
			e=E;
			++t;
		}while(t<time&&E>e000);
		
		if(t==time){
			cout<<"train_uncomplate"<<endl;
		}else{
			cout<<"train_complate"<<endl;
		}
	}
};

设k=k_1时，设F(x)为∫(x^k_1)f(x)dx的原函数，且F(a)-F(b)=0。
由罗尔中值定理得
存在ξ_1∈(a，b)，使F'(ξ_1)=0，即，设( g(x)=(x^k1)f(x) )，g(ξ_1)=0。
若ξ_1^k_1≠0，则f(ξ_1)=0。
因为，k=0，1，…，n。
所以有n+1个ξ。

设k_1，k_2，(k_1=1+k_2)。设对应原函数F1(x)，F2(x)，和对应的ξ_1，ξ_2。则F1'(ξ_1)=0，F1(x)=∫xd(F2(x))
F1'(x)=xF2'(x)……
…………

额，以我的水平，不能证明出，有不同的点…(逃)

0.0我还以为这里是提交bug的……。
蛾子传记

@sophie 其实是这样一个问题，按你的话说，就是：要是没有车，也没有罐头和铁皮，“把所有车称为铁皮罐头”这个“称”可以单独存在吗？

其实，如果我表述足够完善，你就会理解足够主观的话，那么就独立于客观现实了……
我们可以建那么个名称为车的类别，然后他是宇宙中所有东西，或者定义它无处不再。
也可以这么建两个颜色的类别，存在一个物体是a颜色，周围环境都是b颜色，且这两种颜色都无法观察。

最后说两句，客观真理要是不依附于客观世界，那还怎么存在。而且，其实并不能确定是否存在这么个真理，个人比较倾向将规律称为客观物体本身拥有的性质。

@sophie 正是。（假定数学是普世的话）

现实物体某一/全部特征映射到数学/语言的规则，（就不对加减乘除和对语言的逻辑推到/分析过程，是否正确进行讨论了），还有处理好后反向指代的规则。
比如，其实我可以把所有车称为铁皮罐头，只要长得像，管他是不是纸做的。
 /asnowwolf-amuse

@sophie 我则是想讨论事物的本质原因，比如说，上文所说的：“意识是客观世界的主观映射”这一点，我认为也有探究的必要。不过我所做的探究放在物理学中可能有一点累赘的意味。

豁然发现我对于这句的表述有点问题……。还有这个探讨起来有点困难。

是指物理学的宗旨在于归纳简化现象，并分析将会发生的事件的结果。是这样吗？

我回答问题时其实完全没想这个……

我们对我们感受到的现象归纳总结出某种规律。但是符合这种规律的解释，可以是相当多的。

我也没想到你的问题是这个。

而且问题超出我的回答范围，为此我需要引用下他人的话

霍金《大设计》第三章 何为实在：……然而，我们何以得知我们拥有真是没有被歪曲的实在图像？难道我们自己不也可能处在某个大鱼缸之内，一个巨大的透镜扭曲我们的美景？……金鱼的实在图像和我们自己的不同，但金鱼仍然可以表述约束它们观察到的在鱼缸外面物体运动的科学定律。……金鱼可以从它们形变的参考系中表示科学定律，这些定律总是成立，而且使他们能预言鱼缸外的物体的未来运动。它们的定律会总比我们参考系的定律更为复杂，但简单性只不过是口味而已。……
在托勒密模型中，地球位于中心，行星和恒星在非常复杂的轨道上围绕着它运行，这些轨道牵扯到周转圆，正如轮子上的轮子。……托勒密系统或哥白尼系统，哪个是真实？尽管人们时常说哥白尼证明了托勒密是错的，但那不是真的。……人们可以利用任一种图像作为宇宙模型，对于我们天空的观测即可以从假定地球处于静止，也可以假定太阳处于静止得到解释。……
我们将采用将其称为依赖模型的实在论观点：一个物理理论和世界图像是一个模型（通常具有数学性质）以及一组将这个模型的元素和观测连接起来的规则的思想。这提供了一个用以解释现代科学的框架。
……按照依赖模型的实在论，去问一个模型是否真实是无意义的，只有是否与观测相符才有意义。如果存在两个都和观测相符的模型，……，那么人们不能我们对我们感受到的现象归纳总结出某种规律。但是符合这种规律的解释，可以是相当多的。讲这一个比另一个更真实。
……
一个模型是好模型，如果：
1.它是优雅的。
2.它包含很少任意或者可以调整的元素，
3.它和全部已有的观测一致并能解释之，
4.它对将来的观测做详细的预言，如果这些预言不成立，观测就能证伪这个模型。

弱弱的问下，你说的是数学吗……

@sophie 我们为什么在不知道物体真正是什么的情况下就能够使用物体？

严格的讲，你问的不是物理问题。而是以认识世界的角度对物理和逻辑的合理性的质疑。
首先，意识是客观世界的主观映射。你想象中的物体和语言里讲的物体，只是指代某一物体过某一类物体。而且实际上没有主观意义上的知道/理解某一某一物体/定律，只是我们的经验可以拼凑（脑补）出这么和画面/中间过程。也就是说，没有视力，就很难理解匀速移动或变速移动，因为很难想象出来。

或者是明明无法检验逻辑学的排中律却在一直使用它并且还能取得一定的成果？

其次，这个排中律首先是逻辑对物体/事件/经验下定义的结果，在定义时已经将所有能考虑的可能分类了，因此排中律是不需证明的，如果确实出了矛盾，那么就是定义没下好。

为什么我们就可以忽略“更高层次物体作用”的可能而去把这种行为看作力呢？

最后，我们不理解更高层次作用，那是需要探索的领域。且如前面说的，我们实际上确实不能看到发生了什么作用。。。但不过你的这个问题，让我想起以前和朋友开玩笑时说的《论白菜的价格和世界和平的辩证关系》……这把问题过于复杂了。如上楼言，其实只要知道

现象可重复，并且可推广

就行了