每日算法 — 使用java实现逻辑回归：Sigmoid决策边界与梯度下降优化

引言

逻辑回归（Logistic Regression）是机器学习中最基础且应用最广泛的分类算法之一。尽管名字中包含”回归”，但它实际上是一种用于二分类问题的判别式模型。逻辑回归通过Sigmoid函数将线性组合映射到(0,1)概率区间，实现对样本类别的概率预测。由于其模型简单、可解释性强、训练高效，逻辑回归被广泛应用于信用评分、医疗诊断、广告点击预测等场景。本文将用Java从零实现逻辑回归，包括Sigmoid函数、交叉熵损失、梯度下降优化，并通过一个二维数据集可视化其决策边界。

算法原理

Sigmoid函数与概率预测

逻辑回归的假设函数为Sigmoid函数：

$$h_\theta(x) = \sigma(\theta^T x) = \frac{1}{1 + e^{-\theta^T x}}$$

其中 $\theta$ 为模型参数向量，$x$ 为特征向量（通常包含偏置项 $x_0 = 1$）。Sigmoid函数将任意实数映射到(0,1)区间，可解释为样本属于正类的概率。

决策边界

当 $h_\theta(x) \geq 0.5$ 时预测为正类，即 $\theta^T x \geq 0$。在二维空间中，决策边界为一条直线：

$$\theta_0 + \theta_1 x_1 + \theta_2 x_2 = 0$$

交叉熵损失函数

逻辑回归采用对数似然损失（交叉熵）：

$$J(\theta) = -\frac{1}{m}\sum_{i=1}^{m}\left[y^{(i)}\log h_\theta(x^{(i)}) + (1-y^{(i)})\log(1-h_\theta(x^{(i)}))\right]$$

梯度下降更新

损失函数对参数 $\theta_j$ 的偏导数为：

$$\frac{\partial J}{\partial \theta_j} = \frac{1}{m}\sum_{i=1}^{m}(h_\theta(x^{(i)}) – y^{(i)})x_j^{(i)}$$

参数更新规则：

$$\theta_j := \theta_j – \alpha \frac{\partial J}{\partial \theta_j}$$

Java实现

1. 数据点类

/**
 * 数据点：表示一个带有标签的样本
 */
public class DataPoint {
    public final double[] features; // 特征向量（不含偏置项）
    public final int label;         // 标签：0或1

    public DataPoint(double[] features, int label) {
        this.features = features.clone();
        this.label = label;
    }

    /** 获取带偏置项的特征向量 [1, x1, x2, ...] */
    public double[] getFeaturesWithBias() {
        double[] withBias = new double[features.length + 1];
        withBias[0] = 1.0; // 偏置项
        System.arraycopy(features, 0, withBias, 1, features.length);
        return withBias;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[");
        for (double f : features) sb.append(String.format("%.2f, ", f));
        sb.append("label=").append(label).append("]");
        return sb.toString();
    }
}

2. 逻辑回归模型

import java.util.Random;

/**
 * 逻辑回归分类器：Sigmoid决策边界与梯度下降优化
 */
public class LogisticRegression {
    private final double[] theta;      // 模型参数 [bias, w1, w2, ...]
    private final int numFeatures;     // 特征数量（不含偏置）
    private final double learningRate; // 学习率
    private final int maxIterations;   // 最大迭代次数
    private final double tolerance;    // 收敛阈值

    // 训练历史
    private double[] lossHistory;

    public LogisticRegression(int numFeatures, double learningRate, 
                               int maxIterations, double tolerance) {
        this.numFeatures = numFeatures;
        this.learningRate = learningRate;
        this.maxIterations = maxIterations;
        this.tolerance = tolerance;
        this.theta = new double[numFeatures + 1]; // +1 for bias
        this.lossHistory = new double[maxIterations];
    }

    /** Sigmoid函数 */
    public static double sigmoid(double z) {
        // 防止数值溢出
        if (z >= 0) {
            return 1.0 / (1.0 + Math.exp(-z));
        } else {
            double expZ = Math.exp(z);
            return expZ / (1.0 + expZ);
        }
    }

    /** 预测概率：P(y=1|x) */
    public double predictProbability(double[] features) {
        double z = theta[0]; // bias
        for (int i = 0; i < features.length; i++) {
            z += theta[i + 1] * features[i];
        }
        return sigmoid(z);
    }

    /** 预测类别：0或1 */
    public int predict(double[] features) {
        return predictProbability(features) >= 0.5 ? 1 : 0;
    }

    /**
     * 训练模型：批量梯度下降
     * @param data 训练数据集
     */
    public void fit(DataPoint[] data) {
        int m = data.length;
        int n = numFeatures + 1; // 含偏置

        // 初始化参数（Xavier风格）
        Random rand = new Random(42);
        for (int j = 0; j < n; j++) {
            theta[j] = rand.nextGaussian() * 0.01;
        }

        System.out.println("开始训练逻辑回归模型...");
        System.out.println("样本数: " + m + ", 特征数: " + numFeatures);
        System.out.println("学习率: " + learningRate + ", 最大迭代: " + maxIterations);
        System.out.println();

        double prevLoss = Double.POSITIVE_INFINITY;

        for (int iter = 0; iter < maxIterations; iter++) {
            // 计算梯度
            double[] gradient = new double[n];
            double loss = 0;

            for (DataPoint point : data) {
                double[] x = point.getFeaturesWithBias();
                double prediction = sigmoid(dotProduct(theta, x));
                double error = prediction - point.label;

                // 累加梯度
                for (int j = 0; j < n; j++) {
                    gradient[j] += error * x[j];
                }

                // 计算损失（交叉熵）
                loss -= point.label * Math.log(prediction + 1e-10)
                       + (1 - point.label) * Math.log(1 - prediction + 1e-10);
            }

            // 平均梯度
            for (int j = 0; j < n; j++) {
                gradient[j] /= m;
            }
            loss /= m;
            lossHistory[iter] = loss;

            // 更新参数
            for (int j = 0; j < n; j++) {
                theta[j] -= learningRate * gradient[j];
            }

            // 打印进度
            if (iter % 100 == 0 || iter < 10) {
                double accuracy = computeAccuracy(data);
                System.out.printf("迭代 %4d | 损失: %.6f | 准确率: %.2f%%%n", 
                    iter, loss, accuracy * 100);
            }

            // 收敛判断
            if (Math.abs(prevLoss - loss) < tolerance) {
                System.out.println("\n模型在迭代 " + iter + " 处收敛");
                break;
            }
            prevLoss = loss;
        }
    }

    /** 向量点积 */
    private double dotProduct(double[] a, double[] b) {
        double sum = 0;
        for (int i = 0; i < a.length; i++) {
            sum += a[i] * b[i];
        }
        return sum;
    }

    /** 计算数据集准确率 */
    public double computeAccuracy(DataPoint[] data) {
        int correct = 0;
        for (DataPoint point : data) {
            if (predict(point.features) == point.label) {
                correct++;
            }
        }
        return (double) correct / data.length;
    }

    /** 打印模型参数 */
    public void printModel() {
        System.out.println("\n模型参数:");
        System.out.printf("  偏置(bias): %.4f%n", theta[0]);
        for (int i = 1; i < theta.length; i++) {
            System.out.printf("  权重 w%d: %.4f%n", i, theta[i]);
        }

        // 决策边界方程
        if (numFeatures == 2) {
            System.out.println("\n决策边界方程:");
            System.out.printf("  %.4f + %.4f*x1 + %.4f*x2 = 0%n", 
                theta[0], theta[1], theta[2]);
            System.out.printf("  即: x2 = %.4f*x1 + %.4f%n", 
                -theta[1] / theta[2], -theta[0] / theta[2]);
        }
    }

    /** 获取决策边界上的点（用于可视化） */
    public double[][] getDecisionBoundary(double xMin, double xMax, int points) {
        if (numFeatures != 2) return null;
        double[][] boundary = new double[points][2];
        for (int i = 0; i < points; i++) {
            double x1 = xMin + (xMax - xMin) * i / (points - 1);
            double x2 = -(theta[0] + theta[1] * x1) / theta[2];
            boundary[i][0] = x1;
            boundary[i][1] = x2;
        }
        return boundary;
    }

    public double[] getTheta() { return theta.clone(); }
}

3. 数据生成器

import java.util.Random;

/**
 * 数据集生成器：创建带标签的二维分类数据
 */
public class DatasetGenerator {

    /**
     * 生成线性可分数据集
     * @param nPositive 正类样本数
     * @param nNegative 负类样本数
     * @param seed 随机种子
     * @return 数据集
     */
    public static DataPoint[] generateLinearData(int nPositive, int nNegative, long seed) {
        Random rand = new Random(seed);
        DataPoint[] data = new DataPoint[nPositive + nNegative];
        int idx = 0;

        // 正类样本：分布在直线 y = -x + 5 上方
        for (int i = 0; i < nPositive; i++) {
            double x1 = 1 + rand.nextDouble() * 8;
            double x2 = -x1 + 5 + 0.5 + rand.nextDouble() * 4;
            data[idx++] = new DataPoint(new double[]{x1, x2}, 1);
        }

        // 负类样本：分布在直线 y = -x + 5 下方
        for (int i = 0; i < nNegative; i++) {
            double x1 = 1 + rand.nextDouble() * 8;
            double x2 = -x1 + 5 - 0.5 - rand.nextDouble() * 4;
            data[idx++] = new DataPoint(new double[]{x1, x2}, 0);
        }

        // 随机打乱
        shuffle(data, rand);
        return data;
    }

    /**
     * 生成带噪声的非线性数据集（同心圆）
     */
    public static DataPoint[] generateCircleData(int nSamples, long seed) {
        Random rand = new Random(seed);
        DataPoint[] data = new DataPoint[nSamples];

        for (int i = 0; i < nSamples; i++) {
            double angle = rand.nextDouble() * 2 * Math.PI;
            if (i < nSamples / 2) {
                // 内圆（负类）
                double r = 1.5 + rand.nextGaussian() * 0.3;
                data[i] = new DataPoint(new double[]{
                    r * Math.cos(angle), r * Math.sin(angle)
                }, 0);
            } else {
                // 外圆（正类）
                double r = 4.0 + rand.nextGaussian() * 0.5;
                data[i] = new DataPoint(new double[]{
                    r * Math.cos(angle), r * Math.sin(angle)
                }, 1);
            }
        }

        shuffle(data, rand);
        return data;
    }

    /** Fisher-Yates洗牌算法 */
    private static void shuffle(DataPoint[] data, Random rand) {
        for (int i = data.length - 1; i > 0; i--) {
            int j = rand.nextInt(i + 1);
            DataPoint temp = data[i];
            data[i] = data[j];
            data[j] = temp;
        }
    }

    /** 划分训练集和测试集 */
    public static DataPoint[][] trainTestSplit(DataPoint[] data, double trainRatio, long seed) {
        Random rand = new Random(seed);
        DataPoint[] shuffled = data.clone();
        shuffle(shuffled, rand);

        int trainSize = (int) (data.length * trainRatio);
        DataPoint[] train = new DataPoint[trainSize];
        DataPoint[] test = new DataPoint[data.length - trainSize];

        System.arraycopy(shuffled, 0, train, 0, trainSize);
        System.arraycopy(shuffled, trainSize, test, 0, data.length - trainSize);

        return new DataPoint[][]{train, test};
    }
}

4. 主程序：分类演示

/**
 * 逻辑回归分类演示程序
 */
public class LogisticRegressionDemo {

    public static void main(String[] args) {
        System.out.println("=== 逻辑回归分类器演示 ===");
        System.out.println();

        // 实验1：线性可分数据
        System.out.println("【实验1】线性可分数据集");
        System.out.println("-".repeat(50));

        DataPoint[] linearData = DatasetGenerator.generateLinearData(150, 150, 42);
        DataPoint[][] split = DatasetGenerator.trainTestSplit(linearData, 0.8, 123);
        DataPoint[] trainData = split[0];
        DataPoint[] testData = split[1];

        System.out.println("训练集大小: " + trainData.length);
        System.out.println("测试集大小: " + testData.length);

        // 训练模型
        LogisticRegression model = new LogisticRegression(
            2,      // 2个特征
            0.1,    // 学习率
            1000,   // 最大迭代
            1e-7    // 收敛阈值
        );
        model.fit(trainData);

        // 评估
        double trainAcc = model.computeAccuracy(trainData);
        double testAcc = model.computeAccuracy(testData);
        System.out.printf("\n训练集准确率: %.2f%%%n", trainAcc * 100);
        System.out.printf("测试集准确率: %.2f%%%n", testAcc * 100);
        model.printModel();

        // 打印决策边界上的点
        System.out.println("\n决策边界采样点:");
        double[][] boundary = model.getDecisionBoundary(0, 10, 5);
        for (double[] p : boundary) {
            System.out.printf("  (%.2f, %.2f)%n", p[0], p[1]);
        }

        // 实验2：带噪声数据
        System.out.println("\n" + "=".repeat(50));
        System.out.println("【实验2】带噪声的线性数据");
        System.out.println("-".repeat(50));

        DataPoint[] noisyData = DatasetGenerator.generateLinearData(200, 200, 99);
        // 添加一些噪声点
        Random rand = new Random(77);
        for (int i = 0; i < 20; i++) {
            int idx = rand.nextInt(noisyData.length);
            noisyData[idx] = new DataPoint(new double[]{
                rand.nextDouble() * 10,
                rand.nextDouble() * 10
            }, rand.nextBoolean() ? 1 : 0);
        }

        split = DatasetGenerator.trainTestSplit(noisyData, 0.8, 456);
        trainData = split[0];
        testData = split[1];

        LogisticRegression noisyModel = new LogisticRegression(2, 0.05, 1500, 1e-7);
        noisyModel.fit(trainData);

        System.out.printf("\n训练集准确率: %.2f%%%n", noisyModel.computeAccuracy(trainData) * 100);
        System.out.printf("测试集准确率: %.2f%%%n", noisyModel.computeAccuracy(testData) * 100);

        // 实验3：预测新样本
        System.out.println("\n" + "=".repeat(50));
        System.out.println("【实验3】新样本预测演示");
        System.out.println("-".repeat(50));

        double[][] newSamples = {
            {2.0, 6.0},   // 应该在正类区域
            {7.0, 1.0},   // 应该在负类区域
            {5.0, 3.0},   // 靠近决策边界
            {1.0, 8.0},   // 应该在正类区域
            {8.0, 0.5},   // 应该在负类区域
        };

        System.out.println("使用实验1训练好的模型进行预测:");
        System.out.printf("%-15s %-15s %-12s %-12s%n", "特征x1", "特征x2", "预测概率", "预测类别");
        System.out.println("-".repeat(60));

        for (double[] sample : newSamples) {
            double prob = model.predictProbability(sample);
            int pred = model.predict(sample);
            System.out.printf("%-15.2f %-15.2f %-12.4f %-12d%n", 
                sample[0], sample[1], prob, pred);
        }

        System.out.println("\n逻辑回归通过Sigmoid函数输出类别概率，");
        System.out.println("其决策边界是特征空间的线性超平面，");
        System.out.println("具有计算高效、可解释性强的显著优势。");
    }
}

5. 带L2正则化的增强版

/**
 * 带L2正则化的逻辑回归：防止过拟合
 */
public class RegularizedLogisticRegression extends LogisticRegression {
    private final double lambda; // 正则化强度

    public RegularizedLogisticRegression(int numFeatures, double learningRate,
                                          int maxIterations, double tolerance,
                                          double lambda) {
        super(numFeatures, learningRate, maxIterations, tolerance);
        this.lambda = lambda;
    }

    /**
     * 带L2正则化的训练
     * 损失函数：J = 交叉熵 + (lambda/2m) * sum(theta_j^2)
     */
    @Override
    public void fit(DataPoint[] data) {
        // 获取父类参数（通过反射或重新实现）
        // 为简洁起见，此处展示正则化梯度计算的核心逻辑
        System.out.println("使用L2正则化训练 (lambda=" + lambda + ")");

        // 核心正则化梯度：对非偏置项添加 (lambda/m) * theta_j
        // 这会驱使参数向0收缩，降低模型复杂度
        super.fit(data); // 实际应重写完整训练逻辑
    }
}

复杂度分析

其中 $m$ 为样本数，$n$ 为特征数（含偏置）。逻辑回归的计算效率极高，是工业界首选的基线分类模型。

总结

本文实现了逻辑回归的完整流程，核心要点包括：

• Sigmoid函数将线性预测映射为概率值，其S形曲线天然适合二分类场景
• 交叉熵损失衡量预测概率分布与真实分布的差异，是分类问题的标准损失函数
• 梯度下降通过迭代优化参数，使损失函数沿负梯度方向收敛到局部最小值
• 决策边界是特征空间中的线性超平面，模型可解释性直接体现在参数权重上

逻辑回归虽然模型简单，但因其训练高效、结果可解释、不易过拟合，在实际业务中仍有不可替代的价值。当特征与对数几率呈线性关系时，逻辑回归往往是最优选择。