Java中的梯度下降

Question

我最近在 Coursera 开始了 AI 课程，我有一个与我的梯度下降算法实现相关的问题。

这是我当前的实现（实际上我只是将数学表达式“翻译”成 Java 代码）：

    public class GradientDescent {

    private static final double TOLERANCE = 1E-11;
    
    private double theta0;
    private double theta1;
    
    public double getTheta0() {
        return theta0;
    }
    
    public double getTheta1() {
        return theta1;
    }
    
    public GradientDescent(double theta0, double theta1) {
         this.theta0 = theta0;
         this.theta1 = theta1;
    }
    
    public double getHypothesisResult(double x){
        return theta0 + theta1*x;
    }
    
    private double getResult(double[][] trainingData, boolean enableFactor){
        double result = 0;
        for (int i = 0; i < trainingData.length; i++) {
            result = (getHypothesisResult(trainingData[i][0]) - trainingData[i][1]);
            if (enableFactor) result = result*trainingData[i][0]; 
        }
        return result;
    }
    
    public void train(double learningRate, double[][] trainingData){
        int iteration = 0;
        double delta0, delta1;
        do{
            iteration++;
            System.out.println("SUBS: " + (learningRate*((double) 1/trainingData.length))*getResult(trainingData, false));
            double temp0 = theta0 - learningRate*(((double) 1/trainingData.length)*getResult(trainingData, false));
            double temp1 = theta1 - learningRate*(((double) 1/trainingData.length)*getResult(trainingData, true));
            delta0 = theta0-temp0; delta1 = theta1-temp1;
            theta0 = temp0; theta1 = temp1;
        }while((Math.abs(delta0) + Math.abs(delta1)) > TOLERANCE);
        System.out.println(iteration);
    }
}

代码运行良好，但前提是我选择了一个很小的 ​​alpha，这里称为 learningRate。如果高于 0.00001，则发散。

您对如何优化实施有任何建议，或者对“Alpha-Issue”的解释和可能的解决方案吗？

更新：

这是主要的，包括一些示例输入：

private static final double[][] TDATA = {{200, 20000},{300, 41000},{900, 141000},{800, 41000},{400, 51000},{500, 61500}};

public static void main(String[] args) {
    GradientDescent gd = new GradientDescent(0,0);
    gd.train(0.00001, TDATA);
    System.out.println("THETA0: " + gd.getTheta0() + " - THETA1: " + gd.getTheta1());
    System.out.println("PREDICTION: " + gd.getHypothesisResult(300));
}

梯度下降的数学表达式如下：

Answer 1

为了解决这个问题，有必要用这个公式对数据进行归一化：(Xi-mu)/s。 Xi是当前训练集的值，mu是当前列的平均值，s是最大值减去当前列的最小值。这个公式将使训练数据大约在 -1 和 1 之间的范围内，这允许选择更高的学习率和梯度下降来更快地收敛。 但之后有必要对预测结果进行非规范化。

Answer 2

private double getResult(double[][] trainingData, boolean enableFactor){
double result = 0;
for (int i = 0; i < trainingData.length; i++) {
    result = (getHypothesisResult(trainingData[i][0]) - trainingData[i][1]);
    if (enableFactor) result = result*trainingData[i][0]; 
}
return result;

在这个函数中。结果变量覆盖每次迭代，旧值丢失。输入值时，仅计算数组中的最后一项。其余的都无所谓。

Answer 3

您应该使用 java.math.BigDecimal 进行算术运算。
double 在执行任何算术运算时都有其舍入问题。