用java实现使用高斯核的局部加权线性回归

首先大家了解一下局部加权线性回归，如下：

赋予预测点附近每一个点以一定的权值，在这上面基于最小均方差来进行普通的线性回归。这里面用“核”（与支持向量机相似）来对附近的点赋予最高的权重

公式如下：

相对于最小二乘回归加入了权重W

然后大家了解一下高斯核，如下：

即径向基函数 (Radial Basis Function 简称 RBF), 就是某种沿径向对称的标量函数。 通常定义为空间中任一点x到某一中心xc之间欧氏距离的单调函数, 可记作 k(||x-xc||), 其作用往往是局部的 , 即当x远离xc时函数取值很小。最常用的径向基函数是高斯核函数 ,形式为 k(||x-xc||)=exp{- ||x-xc||^2/(2*σ^2) } 其中xc为核函数中心,σ为函数的宽度参数 , 控制了函数的径向作用范围。

我们查阅资料了解到使用高斯核的局部加权线性回归的python代码如下：

def lwlr(testPoint,xArr,yArr,k=1.0):
    xMat = mat(xArr); yMat = mat(yArr).T
    m = shape(xMat)[0]
    weights = mat(eye((m)))
    for j in range(m):                      #next 2 lines create weights matrix
        diffMat = testPoint - xMat[j,:]     #
        weights[j,j] = exp(diffMat*diffMat.T/(-2.0*k**2))
    xTx = xMat.T * (weights * xMat)
    if linalg.det(xTx) == 0.0:
        print("This matrix is singular, cannot do inverse")
        return
    ws = xTx.I * (xMat.T * (weights * yMat))
    return testPoint * ws

代码量不多，我们用java实现如下：

	public static double lwlr(double[] testPoint,DenseMatrix64F xArr,double[] yArr,double k) {

		double[] weights = new double[xArr.numRows];

		for(int i=0;i<xArr.numRows;i++) {
			double [] diffMat = new double[xArr.numCols];
			double sum=0;
			for(int j=0;j<xArr.numCols;j++) {
				diffMat[j] = testPoint[j]-xArr.get(i,j);
				sum+=diffMat[j]*diffMat[j];
			}
			weights[i] = Math.exp(sum/(-2.0*k*k));
		}
		
		DenseMatrix64F xTx = new DenseMatrix64F(xArr.numCols,xArr.numCols);
		
		for(int i=0;i<xArr.numCols;i++) {
			for(int j=0;j<xArr.numCols;j++) {
				double tmp=0;
				for(int n=0;n<xArr.numRows;n++) {
					tmp+=weights[n]*xArr.get(n, j)*xArr.get(n,i);
				}
				xTx.set(i, j, tmp);
			}
		}
		
		CommonOps.invert(xTx);
		
		double[] tmp = new double[xArr.numCols];
		
		for(int i=0;i<xArr.numCols;i++) {
			tmp[i] = 0;
			for(int j=0;j<xArr.numRows;j++) {
				tmp[i] += xArr.get(j, i)*weights[j]*yArr[j];
			}
		}
		
		double[] ws = new double[xArr.numCols];
		
		for(int i=0;i<xArr.numCols;i++) {
			ws[i] = 0;
			for(int j=0;j<xArr.numCols;j++) {
				ws[i] += xTx.get(i, j)*tmp[j];
			}
		}
		
		double rs=0;
		
		for(int i=0;i<xArr.numCols;i++) {
			rs+=testPoint[i]*ws[i];
		}
	    
	    return rs;
		
	}

测试一下

		List<String> list = new ArrayList<String>();
        try{
            BufferedReader br = new BufferedReader(new FileReader("D:\\machinelearninginaction-master\\Ch08\\ex0.txt"));
            String s = null;
            while((s = br.readLine())!=null){
            	list.add(s);
            }
            br.close();    
        }catch(Exception e){
            e.printStackTrace();
        }
        
        DenseMatrix64F dataMatIn = new DenseMatrix64F(list.size(),2);
        double[] classLabels = new double[list.size()];
        
        for(int i=0;i<list.size();i++) {
        	
        	String[] items = list.get(i).split("	");
        	dataMatIn.set(i, 0, Double.parseDouble(items[0]));
        	dataMatIn.set(i,1, Double.parseDouble(items[1]));
        	classLabels[i] = Double.parseDouble(items[2]);
        }
        
        
        
        double yhat = lwlr(new double[] { dataMatIn.get(0, 0),dataMatIn.get(0, 1)},dataMatIn,classLabels, 1.0);
		
        System.out.println(yhat);

结果正确如下：