非参数学习算法之局部加权回归

    前面的线性回归（Linear Regression）是参数学习算法，我们需要拟合出Theta i， 如果特征值出现的太少，如只用一个theta， 可能会出现underfitting（欠拟合），如果特征值选择的过多，会几乎相连每一个点，导致函数不能反映其余数据的真实预测，这就是overfitting（过度拟合）。

    比如，房屋价格的预测，它的中心思想是在对参数进行求解的过程中，每个样本对当前参数值的影响是有不一样的权重的。比如上节中我们的回归方程为（这个地方用矩阵的方法来表示Ɵ表示参数，i表示第i个样本，h为在Ɵ参数下的预测值）：

 

我们的目标是让

 

最小，然后求出来Ɵ，再代入h中就可以得到回归方程了。

 

但是如果类似以下的样本，他们的对应图如下：

如果用之前的方法，图中线为求出的回归方程，那么在x的取值和真实差别很大，这个情况叫做欠拟合(overfitting)。那么我们怎么办呢？我们的主要思想就是只对x的附近的一些样本进行选择，根据这些样本得到x附近这些样本所推倒出来的回归方程，那么此时我们得到的回归方程就比较拟合样本数据，得到的效果图如下：

我们解的思路如下，加入一个加权因子：

重新构造新的j(x)

    Exp是以e为低的指数，这个时候可以知道如果x距离样本很远的时候w(i)=0，否则为1，当我们预测一个值的时候就需要我们重新来计算当前的参数Ɵ的值，然后构造回归方程，计算当前的预测值。

    这就是局部加权回归LWR！

C++实现代码如下：

#include<iostream>  
using namespace std;  
  
const int Number = 6;  
const int Dimesion = 3;  
const float learningRate=0.001;       
const float errorThr=1; //variance threshold  
const int MAX=1000;     //Max times of iteration  
  
typedef struct Data{  
    float vectorComponent[Dimesion];  
}vectorData;  
  
vectorData x[Number] = {  
   /* {1,1,4}, 
    {1,2,5}, 
    {1,5,1}, 
    {1,4,2},*/  
    {1,1,1},  
    {1,1,3},  
    {1,1,2},  
    {1,2,3},  
    {1,2,1},  
    {1,2,2},  
};  
float y[Number]={2,10,5,13,5,8};  
//lwr(局部线性回归)  
float weightValue(vectorData xi,vectorData x){  
    float weight = 0.0;  
    for(int i=0;i<Dimesion;i++){  
        weight+=pow(xi.vectorComponent[i]-x.vectorComponent[i],2);  
    }  
    float tempWeight = exp(-(weight/(2*36)));  
    if(tempWeight<0.02)  
        tempWeight = 0.0;  
    return tempWeight;  
}  
  
float multiPly(vectorData x1,vectorData x2){  
    float temp = 0.0;  
    for(int i=0;i<Dimesion;i++){  
        temp += x1.vectorComponent[i]*x2.vectorComponent[i];  
    }  
    return temp;  
}  
  
vectorData addVectorData(vectorData x1,vectorData x2){  
    vectorData temp;  
    for(int i=0;i<Dimesion;i++)  
        temp.vectorComponent[i] = x1.vectorComponent[i]+x2.vectorComponent[i];  
    return temp;  
}  
  
vectorData minusVectorData(vectorData x1,vectorData x2){  
    vectorData temp;  
    for(int i=0;i<Dimesion;i++)  
        temp.vectorComponent[i] = x1.vectorComponent[i]-x2.vectorComponent[i];  
    return temp;  
}  
  
vectorData numberMultiVectorData(float para,vectorData x1){  
    vectorData temp;  
    for(int i=0;i<Dimesion;i++)  
        temp.vectorComponent[i] = x1.vectorComponent[i]*para;  
    return temp;  
}  
float costFunction(vectorData parameter[],vectorData inputData[],float inputResultData[],vectorData object){  
    float costValue = 0.0;  
    float tempValue = 0.0;  
    float weightedValue = 0.0;  
    for(int i=0;i<Number;i++){  
        tempValue = 0.0;  
          
        //consider all the parameters although most of them is zero  
        for(int j=0;j<Number;j++)  
            tempValue += multiPly(parameter[j],inputData[i]);  
        costValue += weightValue(inputData[i],object)*pow((inputResultData[i]-tempValue),2);      
    }  
  
    return (costValue/2*4);  
}  
  
  
int LocallyWeightedAgression(vectorData parameter[],vectorData inputData[],float resultData[],vectorData objectVector){  
    float tempValue = 0.0;  
    float errorCost = 0.0;  
    float weightedValue = 0.0;  
    errorCost=costFunction(parameter,inputData,resultData,objectVector);  
    if(errorCost<errorThr)  
        return 1;  
    for(int iteration=0;iteration<MAX;iteration++){  
  
        //stochastic  
        for(int i=0;i<Number;i++){  
            //calculate the h(x)  
            weightedValue = weightValue(inputData[i],objectVector);  
            tempValue=0.0;  
            for(int j=0;j<Number;j++)  
                tempValue+=multiPly(parameter[j],inputData[i]);  
            //update the parameter by stochastic(随机梯度下降)  
            printf("the next parameter is ");  
            for(int ii=0;ii<Number;ii++){  
                parameter[ii] = addVectorData(parameter[ii],numberMultiVectorData(weightedValue*learningRate*(resultData[i]-tempValue),inputData[i]));  
                if(multiPly(parameter[ii],parameter[ii])!=0){  
                    for(int jj=0;jj<Dimesion;jj++){  
                        printf("%f ",parameter[ii].vectorComponent[jj]);  
                    }  
                }  
            }  
            printf("\n");  
            errorCost=costFunction(parameter,inputData,resultData,objectVector);  
            printf("error cost is %f\n",errorCost);  
            if(errorCost<errorThr)  
                break;  
        }//end stochastic one time  
  
    }//end when the iteration becomes MAX   
  
    //calculate the object vector  
    float resultValue = 0.0;  
    for(int i=0;i<Number;i++){  
        resultValue += weightValue(inputData[i],objectVector)*multiPly(parameter[i],objectVector);  
    }  
    printf("result value is %f \n",resultValue);  
    return 1;  
}  
  
int testLWA(){  
    vectorData objectData = {1,1.5,1.5};  
    vectorData localParameter[Number] = {0.0};  
    LocallyWeightedAgression(localParameter,x,y,objectData);  
    return 1;  
}  
int main(){  
  //  DescendAlgorithm(parameter,x,y);  
//  system("pause");  
    //clearParameter(parameter);  
    //Stochastic(parameter,x,y);  
    //float ForTestData[] = {1,10,20};  
    //testData(ForTestData);  
    testLWA();  
    system("pause");  
    return 1;  
}