精华内容
下载资源
问答
  • 器学习一次回归和二次回归 reshape(行,列)可以根据指定的数值将数据转换为特定的行数和列数###reshape(-1,1)之后,数据集变成了一列 #采用线性回归方程预测 lr=LinearRegression() lr.fit (X,y) from sklearn....

    器学习一次回归和二次回归

    reshape(行,列)可以根据指定的数值将数据转换为特定的行数和列数###reshape(-1,1)之后,数据集变成了一列

    #采用线性回归方程预测
    lr=LinearRegression()
    lr.fit (X,y)
    from sklearn.linear_model import LinearRegression
    lr = LinearRegression()
    # 训练模型(为了方便没有拆封训练集和测试集)
    X = x.reshape(-1,1)
    print(X.shape)
    lr.fit(X,y)
    # 训练过程就是寻找最佳权重和偏置的过程
    print('权重',lr.coef_,'偏置',lr.intercept_)
    y_predict = lr.predict(X)
    plt.scatter(x,y)
    # 生成线性图,观察预测值与真实值的误差
    plt.plot(x,y_predict,color='r')
    plt.show()
    print(lr.score(X,y))

    一次线性方程不合适,转变为二次线性方程

    # y = w * x + b ===>  y = w1 * x**2 + w2 * x + b
    print((X**2).shape)
    # hstack 在水平方向追加, vstack垂直方向叠加
    X2 = np.hstack([X**2,X])   # 将x^2 作为跟X一样的参数,使多计算一个权重
    print(X2.shape)
    
    ## 
    
    ```python
    import numpy as np
    import matplotlib.pyplot as plt
    # 在指定[-3,3]随机生成size个随机数(代表的特征值)
    x = np.random.uniform(-3,3,size=100)
    print(x,x.shape)
    # 模拟目标值(y) 与x并不是简单的线性关系
    y = 0.5 * x**2 + x + 2 + np.random.normal(0,1,size=100)
    
    # 采用线性回归的方程来预测
    from sklearn.linear_model import LinearRegression
    lr = LinearRegression()
    # 训练模型(为了方便没有拆封训练集和测试集)
    X = x.reshape(-1,1)
    print(X.shape)
    lr.fit(X,y)
    # 训练过程就是寻找最佳权重和偏置的过程
    print('权重',lr.coef_,'偏置',lr.intercept_)
    y_predict = lr.predict(X)
    plt.scatter(x,y)
    # 生成线性图,观察预测值与真实值的误差
    plt.plot(x,y_predict,color='r')
    plt.show()
    print(lr.score(X,y))
    
    
    # y = w * x + b ===>  y = w1 * x**2 + w2 * x + b
    print((X**2).shape)
    # hstack 在水平方向追加, vstack垂直方向叠加
    X2 = np.hstack([X**2,X])   # 将x^2 作为跟X一样的参数,使多计算一个权重
    print(X2.shape)
    # 线性回归模型进行训练
    lr = LinearRegression()
    lr.fit(X2,y)
    # 训练过程就是寻找最佳权重和偏置的过程
    print('权重',lr.coef_,'偏置',lr.intercept_)
    y_predict = lr.predict(X2)
    # 真实的数据集采用散点图显示
    plt.scatter(x,y)
    # 预测数据集,采用线形图显示,必须按照x轴从小到大进行绘制
    # plt.plot(x,y_predict,color='r')
    plt.plot(np.sort(x),y_predict[np.argsort(x)],color='r')
    plt.show()
    print(lr.score(X2,y))
    
    
    展开全文
  • 先看下要做的内容,创建一元二次函数y=x平方-0.5,其中为了更符合散点图模拟需要,在方程加噪点,以标准方差0.05行驶,如图所示 折线图 散点图 下面我们要做的,是要计算机自动拟合出该散点图的函数,画出...

    目录

    一、在TensorFlow中,首先定义

    二、统一的任务,pytorch来实现一下


    先看下要做的内容,创建一元二次函数y=x平方-0.5,其中为了更符合散点图模拟需要,在方程加噪点,以标准方差0.05行驶,如图所示

    折线图

    散点图

    下面我们要做的,是要计算机自动拟合出该散点图的函数,画出图样,如图

    下面,就通过TensorFlow来看如何做出这个样子

    一、在TensorFlow中,首先定义

    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    
    
    #定义隐藏层
    def add_layer(inputs,in_size,out_size,activation_function=None):
        Weights=tf.Variable(tf.random_normal([in_size,out_size]))  #权值
        biases=tf.Variable(tf.zeros([1,out_size])+0.1) #偏置
        Wx_plus_b=tf.matmul(inputs,Weights)+biases  #z=wx+b
        if activation_function is None:
            outputs=Wx_plus_b
        else:
            outputs=activation_function(Wx_plus_b)
        return outputs
    
    #make up some real data
    x_data=np.linspace(-1,1,300)[:,np.newaxis]#加维度
    noise=np.random.normal(0,0.05,x_data.shape)#加噪点,标准方差0.05
    y_data=np.square(x_data)-0.5+noise    #y=square(x)-0.5+noise
    
    #train_step所要输入的值
    xs=tf.placeholder(tf.float32,[None,1])
    ys=tf.placeholder(tf.float32,[None,1])
    ###建立第一,二次隐藏层layer
    ###add_layer(inputs,in_size,out_size,activation_function=None)
    l1=add_layer(xs,1,10,activation_function=tf.nn.relu)#激励函数(activation_function)ReLU
    prediction=add_layer(l1,10,1,activation_function=None)
    
    #创建损失函数
    loss=tf.reduce_mean(tf.reduce_sum(tf.square(ys-prediction),
                   reduction_indices=[1]))
    train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)#梯度下降优化器,减少误差,学习效率0.1
    
    #important step
    init=tf.initialize_all_variables()
    sess=tf.Session()
    sess.run(init)
    
    
    #绘图部分
    fig=plt.figure()
    ax=fig.add_subplot(1,1,1)
    ax.scatter(x_data,y_data)
    plt.ion()#不暂停
    plt.show()
    
    #学习1000步
    for i in range(1000):
        sess.run(train_step,feed_dict={xs:x_data,ys:y_data})
        if i%50==0:
            #print(sess.run(loss,feed_dict={xs:x_data,ys:y_data})) #输出误差
            try:
                ax.lines.remove(lines[0])
            except Exception:
                pass
                
            prediction_value=sess.run(prediction,feed_dict={xs:x_data})
            lines=ax.plot(x_data,prediction_value,'r',lw=5)
            plt.pause(0.1)
    

    输出误差截图,每50次输出一次,截图如下

     

    误差逐渐递减的截图

    这样就完成了

    二、统一的任务,pytorch来实现一下

    import torch
    from torch.autograd import Variable
    import torch.nn.functional as F
    import matplotlib.pylab as plt
    
    x=torch.unsqueeze(torch.linspace(-1,1,100),dim=1)   #dim=0列 dim=1行   (100,1)
    y=x.pow(2)+0.2*torch.rand(x.size())  #pow平方
    
    x,y=Variable(x),Variable(y)
    
    # plt.scatter(x.data.numpy(),y.data.numpy())
    # plt.show()
    
    class Net(torch.nn.Module):
        def __init__(self,n_features,n_hidden,n_output):
            super(Net,self).__init__()
            #定义网络有哪些层
            self.hidden=torch.nn.Linear(n_features,n_hidden)
            self.predict=torch.nn.Linear(n_hidden,n_output)
    
        #定义层的具体形式
        def forward(self,x):
            x=F.relu(self.hidden(x))
            y=self.predict(x)
            return y
    
    net=Net(1,10,1)
    print(net)
    
    ##可视化,实时打印
    plt.ioff()
    plt.show()
    
    optimizer=torch.optim.SGD(net.parameters(), lr=0.5)
    loss_func=torch.nn.MSELoss()
    
    for t in range(100):
        prediction=net(x)
    
        loss=loss_func(prediction,y)
    
        #优化步骤
        optimizer.zero_grad()####每次循环,梯度都先设为0
        loss.backward()
        optimizer.step()
    
        if t%5==0:
            plt.cla()
            plt.scatter(x.data.numpy(),y.data.numpy())
            plt.plot(x.data.numpy(),prediction.data.numpy(),'r-',lw=5)
            plt.text(0.5,0,'loss=%.4f'%loss.data.numpy(),fontdict={'size':20,'color':'red'})
            plt.pause(0.1)
    
    plt.ioff()
    plt.show()


     

    展开全文
  • 个工程中的应用,需要对组数据做上面四种形式的nihe

    一个工程中的应用,需要对一组数据做上面四种形式的拟合回归,并且根据模型对输入做evaluation,就是做一个函数曲线拟合。

    下面的RevPre定义了方法和结构,Util是使用案例,其中的Opt的type指示模型要拟合的是哪一种。


    1)直线拟合: y = kx+b

    2)   二次曲线拟合:y = AX^2 + BX + C

    以上两种很典型,不多解释;

    3) KNN

    KNN的Opt阶段什么也没做,只是保存了所有数据对,然后检测阶段选取最近的K(MIN_KNN_K < K < MAX_KNN_K)个点来计算距离加权后的结果。

    4) 折线拟合:

    前面先介绍KNN,是因为折线拟合的结果与之很类似,同样保存了一系列的数据对,检测的时候判断处于哪一段。不同之处是做了简化,而不是全部存储起来。

    首先对数据对按照x快排,然后以直线拟合判断总体是升序还是降序,接下来就是不断淘汰不符合顺序的点,发生“突起”或者“凹陷”时清除与拟合直线距离远的点,直到所有点都按序排列,形成一条单调折线。


    代码:

    RevPre.h

    #include <iostream>
    #include <math.h>
    
    /************************Model type*********************************/
    #define MAX_POL_DEPTH	3
    #define MAX_KNN_K			10
    #define MIN_KNN_K				1
    
    #define MAX(x,y)		(x) > (y) ? (x) : (y)
    #define MIN(x,y)			(x) < (y) ? (x) : (y)
    enum modelType{
    	StraightLine = 0, // default
    	CurveAt2,
    	BrokenLine,
    	KNNModel
    };
    typedef struct Model{
    	enum modelType type;
    	// Line parameters
    	double			lineParam[MAX_POL_DEPTH];
    	// Point model
    	double			*px, *py;
    	int				len;
    };
    Model* CreateModel();
    void ReleaseModel( Model** _ptr );
    bool SetOptData( Model* ptr, double *x, double *y, int len );
    bool Opt( Model *ptr, modelType type );
    double Predict( Model *ptr, double x );
    /**************************Polynomial*******************************/
    /* Internal */
    void CalculatePower(double *powers, int ptNum, int maxDepth, double *x );          //将初始x[i]的值的各幂次方存储在一个二维数组里面 
    void CalculateParams(double *powers, int ptNum, int maxDepth, 
    					 double *params, double *y);																	//计算正规方程组的系数矩阵 
    void DirectLU( double *params, int ptNum, int maxDepth, double *x );						//列主元LU分解
    inline void swap(double &,double &);																		//交换两个变量的值
    /* External */
    bool PolynomialOpt( Model *ptr );
    /************************StraightLine********************************/
    bool StraightLineOpt( Model *ptr );
    /************************BrokenLine********************************/
    /*Internal*/
    int SingleSort( double *index, double *context, int start, int end );
    void QuickSort( double *index, double *context, int start, int end );
    int CheckSequence( double *context, int start, int end, bool upTrend );
    /*External*/
    bool BrokenLineOpt( Model *ptr );
    /********************KNN(Lazy-learning)****************************/
    bool KNNOpt( Model *ptr );

    RevPre.cpp

    #include "Revise.h"
    
    Model* CreateModel(){
    	Model *ptr = new Model;
    	ptr->type = StraightLine;
    
    	ptr->px = ptr->py = NULL;
    	ptr->len = 0;
    	memset( ptr->lineParam, 0, sizeof(double)*MAX_POL_DEPTH );
    
    	return ptr;
    }
    
    void ReleaseModel( Model** _ptr ){
    	Model *ptr = *_ptr;
    	if ( ptr->px ) delete[] ptr->px;
    	if ( ptr->py ) delete[] ptr->py;
    	delete ptr;
    
    	*_ptr = NULL;
    	return ;
    }
    
    bool SetOptData( Model *ptr, double *x, double *y, int len ){
    	if ( !ptr || !x || !y ) return false;
    
    	if ( !ptr->px ) ptr->px = new double[len];
    	if ( !ptr->py ) ptr->py = new double[len];
    
    	ptr->len = len;
    	memcpy( ptr->px, x, sizeof(double)*len );
    	memcpy( ptr->py, y, sizeof(double)*len );
    	return true;
    }
    
    bool Opt( Model *ptr, modelType type ){
    	if ( !ptr ) return false;
    	switch( type )
    	{
    	case StraightLine:
    		return	StraightLineOpt( ptr );
    	case CurveAt2:
    		return	PolynomialOpt( ptr );
    	case BrokenLine:
    		return	BrokenLineOpt( ptr );
    	case KNNModel:
    		return	KNNOpt( ptr );
    	default:
    		return	false;
    	}
    }
    
    double Predict( Model *ptr, double x ){
    	if ( !ptr ) exit (-1);
    	switch( ptr->type )
    	{
    	case StraightLine:
    		return ptr->lineParam[0] + ptr->lineParam[1]*x;
    	case CurveAt2:
    		return ptr->lineParam[0] + ptr->lineParam[1]*x + ptr->lineParam[2]*x*x;
    	case BrokenLine:
    		{
    			if ( ptr->len < 3 ) exit(-2);
    			int first = 0;
    			if ( x <= ptr->px[0] )
    			{
    				double x0 = ptr->px[0], x1 = ptr->px[1];
    				double y0 = ptr->py[0], y1 = ptr->py[1];
    				return y0 - (x0-x)*(y1-y0)/(x1-x0);
    			}
    			else if ( x >= ptr->px[ptr->len-1] )
    			{
    				double x0 = ptr->px[ptr->len-2], y0 = ptr->py[ptr->len - 2];
    				double x1 = ptr->px[ptr->len-1], y1 = ptr->py[ptr->len - 1];
    				return y1 -(x-x1)*(y0-y1)/(x1-x0);
    			}
    			else
    			{
    				while ( ptr->px[first] < x ) { first ++ ;}
    				first --;
    				double deltay = ptr->py[first+1] - ptr->py[first];
    				double deltax = ptr->px[first+1] - ptr->px[first];
    				return ptr->py[first] + deltay*(x-ptr->px[first])/deltax;
    			}
    		}
    	case KNNModel:
    		{
    			int K = MAX( MIN_KNN_K, MIN( int(ptr->len*0.1), MAX_KNN_K ) );
    			// Prepare the initial K neighbours
    			double *dist_team = new double[K];
    			int		*idx_team = new int[K];
    			int		farestIdt = -1;
    			double	farestDist = 0;
    
    			int id = 0;
    			for ( ; id < K; id ++ )
    			{
    				idx_team[id] = id;
    				dist_team[id] = abs( ptr->px[id] - x );
    				if ( farestDist <= dist_team[id] )
    				{
    					farestIdt = id;
    					farestDist = dist_team[id];
    				}
    			}
    			// Looking for the K nearest neighbours
    			while ( id < ptr->len )
    			{
    				if ( abs( ptr->px[id] -x ) < farestDist )
    				{
    					// Update the team
    					idx_team[farestIdt] = id;
    					dist_team[farestIdt] = abs( ptr->px[id] - x );
    					// Update the farest record
    					farestIdt = 0;
    					farestDist = dist_team[0];
    					for ( int searchIdt = 1; searchIdt < K; searchIdt ++ )
    					{
    						if ( dist_team[searchIdt] > farestDist )
    						{
    							farestDist = dist_team[searchIdt];
    							farestIdt = searchIdt;
    						}
    					}
    				}
    				id ++;
    			}
    
    			// Calculate their contribution
    			double res = 0.0;
    			double weightSum = 0.0;
    			for ( int seachIdt = 0; seachIdt < K; seachIdt ++ )
    			{
    				weightSum += 1.0/dist_team[seachIdt];
    				res += 1.0/dist_team[seachIdt]*ptr->py[idx_team[seachIdt]];
    			}
    			delete[] dist_team;
    			delete[] idx_team;
    			return res/weightSum;
    		}
    	default:
    		exit(-2);
    	}
    }
    /**************************Polynomial*******************************/
    bool StraightLineOpt( Model *ptr )
    {
    	if ( !ptr ) return false; 
    	if ( !ptr->px || !ptr->py ) return false;
    
    	int outLen = 2;
    	int ptNum = ptr->len, maxDepth = outLen;
    
    	double *powers = new double[maxDepth*ptNum];
    	double *params = new double[maxDepth*(maxDepth+1)];
    
    	CalculatePower( powers, ptNum, maxDepth, ptr->px );
    
    	CalculateParams( powers, ptNum, maxDepth, params, ptr->py ); //计算正规方程组的系数矩阵
    
    	DirectLU( params, ptNum, maxDepth, ptr->lineParam ); //列主元LU分解
    	ptr->type = StraightLine;
    
    	std::cout<<"-------------------------"<<std::endl;
    	std::cout<<"拟合函数的系数分别为:\n";
    	for( int i=0;i<maxDepth;i++)
    		std::cout<<"a["<<i<<"]="<<ptr->lineParam[i]<<std::endl;
    	std::cout<<"-------------------------"<<std::endl;
    
    	delete[] powers;
    	delete[] params;
    
    	return true;
    }
    bool PolynomialOpt( Model *ptr )
    {
    	if ( !ptr ) return false; 
    	if ( !ptr->px || !ptr->py ) return false;
    
    	int outLen = MAX_POL_DEPTH;
    	int ptNum = ptr->len, maxDepth = outLen;
    
    	double *powers = new double[maxDepth*ptNum];
    	double *params = new double[maxDepth*(maxDepth+1)];
    
    	CalculatePower( powers, ptNum, maxDepth, ptr->px );
    
    	CalculateParams( powers, ptNum, maxDepth, params, ptr->py ); //计算正规方程组的系数矩阵
    
    	DirectLU( params, ptNum, maxDepth, ptr->lineParam ); //列主元LU分解
    	ptr->type = CurveAt2;
    
    	/*std::cout<<"-------------------------"<<std::endl;
    	std::cout<<"拟合函数的系数分别为:\n";
    	for( int i=0;i<maxDepth;i++)
    		std::cout<<"a["<<i<<"]="<<ptr->lineParam[i]<<std::endl;
    	std::cout<<"-------------------------"<<std::endl;*/
    
    	delete[] powers;
    	delete[] params;
    
    	return true;
    }
    
    void CalculatePower(double *powers, int ptNum, int maxDepth, double *x )
    {
    	if ( !powers || !x ) return ;
    
    	int			i, j, k;
    	double		temp;
    
    	for( i = 0; i < maxDepth; i ++ )
    		for( j = 0; j < ptNum; j ++ )
    		{
    			temp = 1;
    			for( k = 0; k < i; k ++ )
    				temp *= x[j];
    			powers[i*ptNum+j] = temp;
    		}
    	return ;
    }
    
    void CalculateParams(double *powers, int ptNum, int maxDepth, 
    					 double *params, double *y)
    {
    	if ( !powers || !params || !y ) return ;
    
    	int			i, j, k;
    	double		temp;
    	int			step = maxDepth + 1;
    
    	for( i = 0; i < maxDepth; i ++ )
    	{
    		for(j = 0; j < maxDepth; j ++ )
    		{
    			temp = 0;
    			for( k = 0; k < ptNum; k ++ )
    				temp += powers[i*ptNum+k]*powers[j*ptNum+k];
    			params[i*step+j] = temp;
    		}
    
    		temp = 0;
    		for( k = 0; k < ptNum; k ++ )
    		{
    			temp += y[k]*powers[i*ptNum+k];
    			params[i*step+maxDepth] = temp;
    		}
    	}
    
    	return ;
    }
    
    inline void swap(double &a,double &b)
    {
    	a=a+b;
    	b=a-b;
    	a=a-b;
    }
    
    void DirectLU( double *params, int ptNum, int maxDepth, double *x )
    {
    	int				i, r, k, j;
    	double			max;
    	int				step = maxDepth + 1;
    
    	double *s = new double[maxDepth];
    	double *t = new double[maxDepth];
    	// choose the main element
    	for( r = 0; r < maxDepth; r ++ )
    	{
    		max = 0;
    		j = r;
    		for( i = r; i < maxDepth; i ++ ) 
    		{
    			s[i] = params[i*step+r];
    			for( k = 0; k < r; k ++ )
    				s[i] -= params[i*step+k] * params[k*step+r];
    			s[i] = abs(s[i]);
    
    			if( s[i] > max ){
    				j = i;
    				max = s[i];
    			}
    		}
    		// if the "main"element is not @ row r, swap the corresponding element 
    		if( j != r ) 
    		{
    			for( i = 0; i < maxDepth + 1; i ++ )
    				swap( params[r*step+i], params[j*step+i] );
    		}
    		for( i = r; i < step; i ++ ) 
    			for( k = 0; k < r; k ++ ){
    				params[r*step+i] -= params[r*step+k] * params[k*step+i];
    			}
    			for(i = r+1; i < maxDepth; i ++ ) 
    			{
    				for ( k = 0; k < r; k ++ )
    					params[i*step+r] -= params[i*step+k] * params[k*step+r];
    				params[i*step+r] /= params[r*step+r];
    			}
    	}
    	for( i = 0; i < maxDepth; i ++ )
    		t[i] = params[ i*step + maxDepth ];
    	for ( i = maxDepth - 1; i >= 0; i -- ) //利用回代法求最终解
    	{
    		for ( r = maxDepth - 1; r > i; r -- )
    			t[i] -= params[ i*step + r ] * x[r];
    		x[i] = t[i]/params[i*step+i];
    	}
    
    	delete[] s;
    	delete[] t;
    
    	return ;
    }
    
    /**********************Broken Line***************************/
    // Quick Sort
    int SingleSort( double *index, double *context, int start, int end )
    {
    	if ( end - start < 1 ) return start;
    
    	int i = start, j = end;
    	double key = index[i];
    	double key_ = context[i];
    	while ( i < j )
    	{
    		while ( index[j] > key && j > i ) j --;
    		if ( index[j] < key )
    		{
    			index[i] = index[j];
    			context[i] = context[j];
    		}
    		while ( index[i] < key && j > i ) i ++;
    		if ( index[i] > key )
    		{
    			index[j] = index[i];
    			context[j] = context[i];
    		}
    	}
    	
    	index[i] = key;
    	context[j] = key_;
    
    	return i;
    }
    
    void QuickSort( double *index, double *context, int start, int end )
    {
    	if ( end - start < 1 ) return ; // important
    	int mid = SingleSort( index, context, start, end );
    	QuickSort( index, context, start, mid - 1 );
    	QuickSort( index, context, mid+ 1, end );
    }
    int CheckSequence( double *context, int start, int end, bool upTrend )
    {
    	int i = start;
    	for ( ; i < end; i ++ )
    	{
    		if ( upTrend && context[i+1] < context[i] )
    		{
    			return i;
    		}
    		if ( !upTrend && context[i] < context[i+1] )
    		{
    			return i;
    		}
    	}
    	return -1;
    }
    // Form the broken line
    bool BrokenLineOpt( Model *ptr )
    {
    	if ( !ptr ) return false;
    	if ( !ptr->len || !ptr->px || !ptr->py ) return false;
    
    	// analyse the trend of points and get its approximate line
    	StraightLineOpt( ptr );
    	double k = ptr->lineParam[1], b = ptr->lineParam[0];
    	bool upTrend = ( k > 0 );
    	// sort the sequence by py
    	QuickSort( ptr->px, ptr->py, 0, ptr->len - 1 );
    
    	int oddPoint = 0;
    	while ( (oddPoint = CheckSequence( ptr->py, oddPoint, ptr->len -1, upTrend ) ) != -1 )
    	{
    		double formerErr = abs( k*ptr->px[oddPoint] + b - ptr->py[oddPoint] );
    		double laterErr = abs( k*ptr->px[oddPoint+1] + b - ptr->py[oddPoint+1] );
    		oddPoint = formerErr > laterErr ? oddPoint : oddPoint + 1;
    		// remove the odd point
    		memcpy( ptr->py + oddPoint, ptr->py + oddPoint + 1, sizeof(double) );
    		memcpy( ptr->px + oddPoint, ptr->px + oddPoint + 1, sizeof(double) );
    		ptr->len --;
    		oddPoint --;
    	}
    	memset( ptr->lineParam, 0, sizeof(double)*MAX_POL_DEPTH );
    	ptr->type = BrokenLine;
    	return true;
    }
    
    /**********************Lazy Learning***************************/
    bool KNNOpt( Model *ptr )
    {
    	// We do nothing as we say it's a lazy-learning method
    	// Only when predict() is called, the learning process is invoked
    	memset( ptr->lineParam, 0, sizeof(double)*MAX_POL_DEPTH );
    	ptr->type = KNNModel;
    	return true;
    }

    Util.cpp

    #include "Revise.h"
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	double x[10], y[10];
    	for ( int i = 0; i < 10; i ++ )
    	{
    		x[i] = 10 - i;
    		y[i] = (i-2)*(i-2);
    	}
    
    	Model *model = CreateModel();
    	SetOptData( model, x, y, 10 );
    	Opt( model, BrokenLine );
    	double result = Predict( model, 1.5 );
    	ReleaseModel( &model );
    
    	return 0;
    }


    展开全文
  • 、插值和拟合的区别首先插值和拟合都是根据某个...插值和拟合的区别如下图所示[1](其中左边为插值,右边为拟合):、常见插值法1.基本概念设函数 有n个已知数据点,若存在简单函数 ,使 成立。则 为 的插值...

    一、插值和拟合的区别

    首先插值和拟合都是根据某个未知函数(或已知但难于求解的函数)的几个已知数据点求出变化规律和特征相似的近似曲线的过程。但是插值法要求的是近似的曲线需要完全经过数据点,而拟合则是得到最接近的结果,强调最小方差的概念。插值和拟合的区别如下图所示[1](其中左边为插值,右边为拟合):

    6b414c67a29ff5950c916eb216e78bef.png

    二、常见插值法

    1.基本概念

    设函数

    有n个已知数据点
    ,若存在一简单函数
    ,使
    成立。则
    插值函数,点
    为插值节点, 求
    的方法称为插值法。

    2.拉格朗日插值

    Lagrange插值多项式的公式如下:

    基函数:

    插值多项式:

    插值余项:

    时,截断误差界是:

    其中:

    matlab代码:

    function

    例1:设

    ,并给出如下节点数据

    x0=[0.4,0.5,0.7,0.8]

    y0=[-0.916291,-0.693147,-0.356675,-0.223144]

    估计x=0.6的值

    带入Lagrange()函数,得到

    ,实际值:

    3.Newton插值

    上面介绍的拉格朗日插值多项式,当插值节点增减时,计算要全部进行,很不方便,所以提出一种Newton插值。

    (1)差商和差分的性质

    一阶差商(均差):

    二阶差商(均差):一阶差商的差商

    阶差商(均差):

    (2)Newton插值多项式

    (3)误差

    (4)差商与导数的关系

    matlab代码如下:

    function

    4.三次Hermite插值

    其中:

    ,余项表达式:

    用Hermite进行插值时需要有确定的三个数据点以及中间点的一阶导数。

    例:给定

    求三次样条插值多项式
    ,及余项表达式。

    matlab代码:

    function

    b871371d4a6f4772a89aa990e066e024.png

    5.三次样条插值

    三次样条插值参考下面的博客:

    HappyWang:轨迹生成--三次样条插值zhuanlan.zhihu.com
    6b0e4e41df27e258cee7bbc74d7c6964.png

    三、常见的拟合方法

    HappyWang:回归预测(1)--线性回归和多项式拟合zhuanlan.zhihu.com
    7b1e3244958148217ba948bf66c039ce.png

    参考

    1. ^https://www.zhihu.com/question/24276013
    展开全文
  • 二元二次拟合 matlab函数

    千次阅读 2018-10-14 18:55:08
    二元二次拟合自变量有2个,因变量个,可以使用的有nlinfitregress,线性时用regress,非线性时用nlinfit。由于是二元二次模型,2个函数都可以用。 以regress为例, 假设因变量存在y向量中,自变量存在x1、x2向量...
  • 最近个令人好奇的事情是有人发现用个简单的模型就可以对双十一的销售...然而昨天个朋友告诉我他用2014年以来的amazon prime day的销售额数据做了类似的尝试,发现对结果取对数之后,只需要时间的线性和二次项...
  • 原标题:拟合R语言中的多项式回归让我们看个经济学的例子:假设你想购买一定数量q的特定产品。如果单价是p,那么你会支付总金额y。这是个线性关系的典型例子。总价格数量成正比。如下所示: 但购买出售,...
  • 如下图所示,第行是X,第列是Y,其余为Z,欲拟合Z(X,Y)的二次关系式。 matlab代码 注意,要将X Y 扩充至与Z同维!!!! %matlab clc;clear; x=[0. 1000. 1285.714286 1571.428571 1857.142857 2142....
  • 我们在做逻辑回归或是其他线性模型的时候,经常会遇到个模型衡量指标叫做 ,网上很多个普遍的解释是: 表达了2个变量间关系的解释程度百分比程度 / 你的你曲线对于模型variance的减少百分比用个例子来理解...
  • 1、最小二乘也可以拟合二次函数 我们都知道用最小二乘拟合线性函数没有问题,那么能不能拟合二次函数甚至更高次的函数呢?答案当然是可以的。下面我们就来试试用最小二乘来拟合抛物线形状的的图像。 对于二次函数来...
  • 变量之间关系可以分为两类:函数关系:反映了事务之间某种确定性关系相关关系:两个变量之间存在某种依存关系,但二者并不是一一对应的;...1)实际上完全没有关系的变量,在利用样本数据进行计算时也可能得到个...
  • 05插值和拟合 1.维插值 (1) 机床加工零件,试用分段线性和三样条两种插值方法计算。并求x=0处的曲线斜率13<=x<=15范围内y的最小值。 x0=[0 3 5 7 9 11 12 13 14 15]; y0=[0 1.2 1.7 2 2.1 2.0 1.8...
  • 根据这事实,提出了种基于RSS二次曲线拟合的AOA定位算法。该算法利用最大RSS附近的数据拟合二次曲线方程,通过曲线方程的最值点估测AOA。实验结果表明,该算法能够在稀疏抽样复杂环境中保持良好的定位精度;...
  • 【长见识】matlab的二次函数拟合

    万次阅读 2019-01-30 09:25:56
    看完文章,长点见识。...人为选定采用二次函数的方法拟合。 收集的数据如表: 那么就不难列出如下个方程: 价格=系数阵*数据阵 代码: c=data_new\price 其中系数阵就是不同下标的C,其中数据阵就是【V^2...
  • XGBoost(eXtreme Gradient Boosting)极致梯度提升,是种基于GBDT的算法或者说工程实现。 XGBoost的基本思想GBDT相同,但是做了一些优化,比如二阶导数使...本文先回顾GBDT、泰勒公式、正则、一元二次函数等X...
  • 包括:简单线性回归中拟合直线的两个参数 的推导(最小二乘法)简单线性回归中对 意义的一点个人理解从 推导 尽管我也很想整个太长不看版……然鹅简单线性回归中拟合直线的两个参数 的推导现在我们有组数据点,...
  • 一元二次方程的回顾启示学过初中数学都知道对于任何个实系数一元二次方程 ,通过配方可以得到 ,根据判别式 的符号,可以判断方程实根的个数,并且可以得到求根公式要么是 个不同的实根 ,要么是 个二重实根 ,...
  • 【Matlab学习手记】二次多项式曲面拟合

    万次阅读 多人点赞 2018-09-14 15:49:16
    二次多项式曲面公式 总共有6个系数。 绘制曲面图形时,一般给定xy的取值(维数组),然后对xy... 给定二次多项式模型,然后成图 x = 0.1 : 0.1 : 5; y = 0.1 : 0.1 : 5; [X, Y] = meshgrid(x, y); ...
  • Matlab--二次多项式曲面拟合

    千次阅读 2019-03-15 10:08:07
    二次多项式曲面公式 总共有6个系数。 绘制曲面图形时,一般给定xy的取值(维数组),然后对xy网格化成二维... 给定二次多项式模型,然后成图 x = 0.1 : 0.1 : 5;y = 0.1 : 0.1 : 5;[X, Y] = meshgr...
  • 在python中利用最小二乘拟合二次抛物线的方法 题目(第三章课后习题): 已知实验数据如下: Xi 19 25 31 38 44 Yi 19.0 32.3 49.0 73.3 97.8 用最小二乘法求形如y=axx+b*x+c的经验公式,并做曲线拟合、最小...
  • 拟合(无法得到较低的误差)拟合(训练误差远小于测试误差) 产生的原因: 模型复杂度训练数据 1.模型复杂度 2. 训练数据 一般来说训练数据随模型成正比例关系。 解决方法 : L2范数正则化 通过模型的计算...
  • 关于机器学习的偏差和方差与过拟合和欠拟合的关系 、偏差和方差定义 偏差是衡量个模型在训练数据集上拟合程度的 方差是衡量这个模型在不同数据集合(测试集合)上拟合程度的 、解释 如上图 低偏差低方差表示...
  • 引言前面讲了很多结构力学,今天来讲讲有关数据分析的内容,后面有机会将会...在科学研究工程计算中最常用的两种方法就是插值和拟合。估值函数总体来说,两种方法都是通过已有的离散点,在定义域中形成个估计函...
  • 作者|ANIRUDDHA BHANDARI编译|VK来源|Analytics Vidhya概述理解R方和调整R方的概念了解R方和调整R方之间的关键区别介绍当我开始我的数据科学之旅时,我探索的第个算法是线性回归。在理解了线性回归的概念算法的...
  • 近期客户提出需求,要在我们软件中实现一元二次函数的曲线拟合。这个内容之前没有接触过,有点摸不着边。 需求具体一点就是:给出组数据(x1,y1), (x2,y2), (x3,y3)....(xn,yn),求多项式 y = ax² + bx +c 中的...
  • 插值、拟合和逼近的区别据维基百科,科学和工程问题可以通过诸如采样、实验等方法获得若干离散的数据,根据这些数据,我们往往希望得到个连续的函数(也就是曲线)或者更加密集的离散方程与已知数据相吻合,这过程就...
  • 针对GPS高程异常拟合中观测数据存在粗差系数矩阵存在误差的情况,提出采用种新的RTLS迭代算法,同时构造基于标准化残差的IGGIII权函数.RTLS迭代算法顾及了系数矩阵中的常数列不存在误差的特性,仅考虑存在误差的列...
  • 拟合与过拟合

    2018-12-12 21:38:37
    左图表示size与prize关系的数据,中间的图就是出现欠拟合的模型,不能够很好地拟合数据,如果在中间的图的模型后面再加二次项,就可以很好地拟合图中的数据了,如右面的图所示。 解决方法: ...
  • 文章目录欠拟合一、什么是欠拟合、欠拟合出现原因三、解决欠拟合(高偏差)的方法过拟合一、什么是过拟合、过拟合出现原因三、...例如回归模型添加更多的高项,增加决策树的深度,增加神经网络的隐藏层数

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 496
精华内容 198
关键字:

一次拟合和二次拟合