机器学习-多变量线性回归-详细示例版

本文会尽可能详细地解释目前其他网上教程所忽略的原理（重点放在补充他人未说清楚的，或者一带而过的），并给出Java版本的代码实现示例。

 

代价函数求偏导数的过程：

代价函数：

即对 求导（再求和），

其中  是求和过程中的标记，因此忽略掉，即：

其中

 

第一部分求导

关于  求导,先求导  部分，直接忽略掉与  无关的部分

 展开之后，与  有关的项是：

求导之后：

即
即

第二部分求导
关于 求导，得到

第三部分求导
求导为 0

 

三部分相加
偏导数为

 

所以多变量线性回归的批量梯度下降算法为:

 

线性回归Java版本代码

Linear Regression with Multiple Variables

/** 数据集 */
public class TrainingSet {

    public List<Data> dataList = new ArrayList<>();

    public void add(double y, double... x) {
        Data data = new Data();
        data.x = x;
        data.y = y;
        dataList.add(data);
    }

    public static class Data {
        public double[] x;
        public double y;
    }

}

/** 线性回归例子 */
public class LinearRegression {

    /** 添加模拟数据 */
    static void mock(TrainingSet ts, double x1, double x2) {
        // 模拟 y = θ0·x0 + θ1·x1 + θ2·x2
        // 其中 x0 永远为1
        final double θ0 = 3.2, θ1 = 1.5, θ2 = 0.3;
        final double x0 = 1;
        double y = θ0*x0 + θ1*x1 + θ2*x2;
        ts.add(y, x0, x1, x2);
    }

    public static void main(String[] args) {
        TrainingSet ts = new TrainingSet();
        //生成100组模拟数据
        for(int i = 0; i < 100; i++) {
            mock(ts, Math.random(), Math.random());
        }

        LinearRegression lr = new LinearRegression();
        lr.study(ts);
    }


    double[] θ;

    final double alpha = 0.001;

    /** 启动学习 */
    void study(TrainingSet ts) {
        initTheta(ts);
        double costMin = Double.MAX_VALUE;
        while(true) {
            double cost = calculateCost(ts);
            if(cost < costMin) {
                double[] delta = new double[θ.length];
                for(int i = 0; i < θ.length; i++) {
                    delta[i] = calculateDelta(ts, i);
                    System.out.println("delta"+i+" = " + D(delta[i]) + ", cost=" + D(cost) + ", θ"+i+"=" + D(θ[i]));
                }
                for(int i = 0; i < θ.length; i++) {
                    θ[i] = θ[i] - alpha * delta[i];
                }
                costMin = cost;
            } else {
                break;
            }
        }
        System.out.println("本轮学习得到的θ为：" + DA(θ));
    }

    /** 初始化theta */
    void initTheta(TrainingSet ts) {
        if (null == θ) {
            θ = new double[ts.dataList.get(0).x.length];
        }
    }

    /** 预测函数 */
    double hypothesis(double[] x) {
        //return θ[0] * x[0] + θ[1] * x[1] + θ[2] * x[2] + ...;
        double value = 0;
        for (int i = 0;  i < x.length; i++) {
            value += θ[i] * x[i];
        }
        return value;
    }

    /** 计算代价 */
    double calculateCost(TrainingSet ts) {
        // 代价函数 J(θ0,θ1...θn) = Σ[i=1~m](h(x_i) - y_i)² / 2m
        // m 代表 m组数据
        double variance = 0;
        for(TrainingSet.Data data : ts.dataList) {
            variance += Math.pow(hypothesis(data.x) - data.y, 2);
        }
        return variance / (2 * ts.dataList.size());
    }

    /** 计算代价函数的偏导数
     * @param i 对θi求偏导 */
    double calculateDelta(TrainingSet ts, int i) {
        double sum = 0;
        for (TrainingSet.Data data : ts.dataList) {
            sum += 2 * data.x[i] * ( hypothesis(data.x) - data.y );
        }
        return sum;
    }

    static DecimalFormat fmt = new DecimalFormat("#.#####");

    static String D(double val) {
        return fmt.format(val);
    }

    static String DA(double[] vals) {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < vals.length; i++) {
            sb.append("θ" + i + " = " + fmt.format(vals[i]) + " , ");
        }
        return sb.toString();
    }
}