数据挖掘笔记-分类-回归算法-最小二乘法

开始学习回归算法，先看下最小乘法在回归算法里面的应用。相关概念理论如下：
最小二乘法
我们在研究两个变量(x, y)之间的相互关系时，通常可以得到一系列成对的数据(x1, y1、x2,
y2... xm , ym)；将这些数据描绘在x -y直角座标系中(如图1), 若发现这些点在一条直线附近，可以令这条直线方程如(式1-1)。 



Y计= a0 + a1 X
　　　　　　　　　　　　　　　　(式1-1) 

其中：a0、a1 是任意实数 

为建立这直线方程就要确定a0和a1，应用《最小二乘法原理》，将实测值Yi与利用(式1-1)计算值(Y计=　a0　+　a1　X)的离差(Yi　-　Y计)的平方和｀〔∑(Yi -
Y计)2〕最小做为“优化判据”。 

令: φ = ∑(Yi - Y计)2 　　　　　　　　　　　　　　(式1-2) 

把(式1-1)代入(式1-2)中得: 

φ = ∑(Yi - a0 - a1 Xi)2 　　　　　　　　　　　　
 (式1-3) 

当∑(Yi-Y计)平方最小时，可用函数 φ 对a0、a1求偏导数，令这两个偏导数等于零。 


　  　　　　　　　  (式1-4) 


　　　　　　　　 (式1-5) 　
亦即： 

m a0 + (∑Xi ) a1 = ∑Yi 　　　　　　　　　　　　 (式1-6) 

(∑Xi ) a0 + (∑Xi2 ) a1 = ∑(Xi,
Yi) 　　　　　　　　 (式1-7) 

得到的两个关于a0、 a1为未知数的两个方程组，解这两个方程组得出：

a0 = ∑Yi / m - a1 * ∑Xi / m                                 (式1-8)

a1 = [m∑(XiYi) - ∑Xi * ∑Yi] / [m∑(Xi^2) - (∑Xi)^2]　　(式1-9) 
其中m为样本容量

这时把a0、a1代入(式1-1)中, 此时的(式1-1)就是我们回归的元线性方程即：数学模型。 

在回归过程中，回归的关联式是不可能全部通过每个回归数据点(x1, y1、 x2, y2...xm,ym),为了判断关联式的好坏,可借助相关系数“R”，统计量“F”，剩余标准偏差“S”进行判断；“R”越趋近于
1 越好；“F”的绝对值越大越好；“S”越趋近于 0 越好。 其中：

R = [∑XiYi - m (∑Xi / m)(∑Yi / m)]/ SQR{[∑Xi2 -
m (∑Xi / m)2][∑Yi2 - m (∑Yi / m)2]}
　　　　　　　(式1-10) 

最小三乘法
促上述情况之外，我们在研究实际中两个变量(x, y)之间的相互关系时，对一系列成对的数据(x1,y1、x2,y2 ... xm,ym)；将这些数据描绘在x - y直角座标系(如图2)中,发现这些点在一条曲线附近，假设这条曲线的一元非线性方程如(式2-1)。



Y计 = a0 + a1 Xk 　　　　　　　　　　　(式2-1) 

其中：a0、a1、k是任意实数 

为建立曲线方程，就要确定a0 、a1和 k 值，应用《最小二乘法》同样的方法, 将实测值Yi与计算值 Y计（Y计　= a0 +
a1 Xik）的离差 (Yi - Y计)的平方和〔∑(Yi -
Y计)2〕为依据：

令: φ = ∑(Yi - Y计)2 　　　　　　　　　　(式2-2)

把(式2-1)代入(式2-2)中得：

φ = ∑(Yi - a0 - a1 Xik )2 　　　　　　(式2-3) 

用函数 φ 分别对a0、a1 和 k 求偏导数，令这三个偏导数等于零即：


　　　　　    (式2-4) 


　　　　　(式2-5) 


　　  (式2-6) 

得到三个关于a0、a1 和 k，为未知数的三元方程组，解方程组即可得到数学模型。 这里就不再详细陈述了。有兴趣的小伙伴可以自己算出相应的值。

最小三乘法和最小二乘法比较：

1．“最小三乘法”利用计算幂值，使回归模型函数曲线以不同曲率弯曲，来更好的拟和不同曲率的曲线。它省去了“最小二乘法”中繁琐的建机理模型和线性化处理，使回归模型与数据拟和更好。

2．对多维非线性数据回归，不用“偏最小二乘法”的每个因素逐一与目标函数回归建模，再把所有模型捆绑成最终模型的方法，而是所有因素与目标函数，同时一次回归成数学模型，在回归时，它不但考虑因素对目标函数的贡献，还把因素之间的影响考虑进去，这样的模型要比用“偏最小二乘法”回归的模型准确。
3．“最小二乘法”数据回归一因素数据只有一元 “X”， “最小三乘法” 数据回归一因素数据可有若干个元

“Xk1”、“Xk2” 、… “Xkn” 如(式3-2)， 利用这一特性，可使回归模型拟和数据更准确。 
Y计 = a0 + a1 Xk1 + a2 Xk2 +...+ an X kn            　　     (式3-2)

选择回归参数注意问题 

1、当一因素数据中有 0 值时， 此因素数据不可作除数和取对数；可把此维数据加上一个数，使它大于零。 

2、当一因素数据中有负数都有时，此因素数据不可做回归计算；可把此维数据乘上一个负数，使它大于零。

3、某因素数据取幂时，不可太大和太小，否则回归计算机会中断溢出；有时回归出的模型，不能逆运算。

下面是用Java语言简单实现的最小二乘法算法：

public class LeastSquaresBuilder {

//初始化数据
private List<Point> initializeData() {
List<Point> points = new ArrayList<Point>();
points.add(new Point(1, 110));
points.add(new Point(2, 120));
points.add(new Point(3, 130));
points.add(new Point(4, 140));
points.add(new Point(5, 150));
points.add(new Point(6, 160));
points.add(new Point(7, 170));
points.add(new Point(8, 180));
points.add(new Point(9, 190));
return points;
}

/**
* Y = a0 + a1 * X
* a0 = ∑Yi / m - a1 * ∑Xi / m
* a1 = [m∑(XiYi) - ∑Xi * ∑Yi] / [m∑(Xi^2) - (∑Xi)^2]
* 计算a0、a1
*/
private double[] calculate(List<Point> points) {
double[] xParameters = extract(points, "X");
double[] yParameters = extract(points, "Y");
double m = points.size();
double xSum = sum(xParameters, false);
double ySum = sum(yParameters, false);
double xySum = sum(xParameters, yParameters);
double xxSum = sum(xParameters, true);
double p1 = m * xySum - xSum * ySum;
double p2 = m * xxSum - Math.pow(xSum, 2);
double a1 =  p1 / p2;
double a0 = ySum / m - a1 * xSum / m;
System.out.println("Y = " + a0 + " + " + a1 + " * X");
return new double[]{a0 , a1};
}

//预测X的值Y
private double predict(double[] a0_a1, double x) {
if (a0_a1.length != 2) {
throw new RuntimeException("error");
}
return a0_a1[0] + a0_a1[1] * x;
}

//计算∑(Xi) 或则 ∑(Xi^2)
private double sum(double[] parameters, boolean isSquare) {
double result = 0.0;
for (double parameter : parameters) {
result += isSquare ? Math.pow(parameter, 2) : parameter;
}
return result;
}

//计算∑(XiYi)
private double sum(double[] xParameters, double[] yParameters) {
double result = 0.0;
for (int i = 0, len = xParameters.length; i < len; i++) {
result += xParameters[i] * yParameters[i];
}
return result;
}

//抽取某一维度点集合
private double[] extract(List<Point> points, String type) {
double[] result = new double[points.size()];
int index = 0;
for (Point point : points) {
if ("X".equals(type)) {
result[index++] = point.getX();
} else if ("Y".equals(type)) {
result[index++] = point.getY();
}
}
return result;
}

public void build() {
List<Point> points = initializeData();
double[] a0_a1 = calculate(points);
double x = 10;
double result = predict(a0_a1, x);
System.out.println("predict " + x + " result: " + result);
}

public static void main(String[] args) {
LeastSquaresBuilder builder = new LeastSquaresBuilder();
builder.build();
}
}

代码托管:https://github.com/fighting-one-piece/repository-datamining.git