逻辑回归详解：从数学原理到实际应用

文章目录

• • 一、逻辑回归的核心思想：从线性到概率
  • • [1. 线性回归的局限与突破](#1. 线性回归的局限与突破)
    • • Sigmoid函数特性（代码可视化）：
  • [2. 逻辑回归的预测公式](#2. 逻辑回归的预测公式)
  • 二、损失函数：如何学习最优参数？
  • • [1. 对数损失函数的数学定义](#1. 对数损失函数的数学定义)
    • • 损失函数解析：
    • [2. 代码中的损失函数体现](#2. 代码中的损失函数体现)
  • 三、参数优化：梯度下降法
  • • [1. 梯度计算与参数更新](#1. 梯度计算与参数更新)
    • [2. 代码中的优化器选择](#2. 代码中的优化器选择)
  • 四、多分类逻辑回归
  • • [1. 多分类原理](#1. 多分类原理)
    • [2. 代码实现](#2. 代码实现)
  • 五、正则化：防止过拟合
  • 六、总结：逻辑回归的核心逻辑

逻辑回归（Logistic Regression）是机器学习中经典的分类算法，尽管名称包含 "回归"，但本质是通过概率建模解决分类问题。本文将结合具体代码，从数学原理到实际应用，全面解析逻辑回归的工作机制。

一、逻辑回归的核心思想：从线性到概率

1. 线性回归的局限与突破

线性回归通过公式 y ^ = w T x + b \hat{y} = w^T x + b y^=wTx+b 预测连续值，但分类问题需要离散的类别输出（如0/1）。逻辑回归的解决方案是：用线性模型输出作为输入，通过Sigmoid函数转换为[0,1]区间的概率值。

Sigmoid函数的数学定义：
σ ( z ) = 1 1 + e − z \sigma(z) = \frac{1}{1+e^{-z}} σ(z)=1+e−z1

其中 z = w T x + b z = w^Tx + b z=wTx+b（线性回归输出）。

Sigmoid函数特性（代码可视化）：

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

z = np.linspace(-10, 10, 100)
plt.plot(z, sigmoid(z), 'b-')
plt.axhline(y=0.5, color='r', linestyle='--', label='阈值0.5')
plt.xlabel('z = w·x + b')
plt.ylabel('σ(z) 概率值')
plt.title('Sigmoid函数曲线')
plt.legend()
plt.show()

从图像可见，Sigmoid 函数将任意实数 z z z 映射到 (0,1)，完美适配概率的定义：

• 当 z → + ∞ z \to +\infty z→+∞ 时， σ ( z ) → 1 \sigma(z) \to 1 σ(z)→1（高概率属于正类）
• 当 z → − ∞ z \to -\infty z→−∞ 时， σ ( z ) → 0 \sigma(z) \to 0 σ(z)→0（高概率属于负类）
• 当 z = 0 z = 0 z=0 时， σ ( z ) = 0.5 \sigma(z) = 0.5 σ(z)=0.5（决策阈值）

2. 逻辑回归的预测公式

结合 Sigmoid 函数，逻辑回归的概率预测公式为：

p ^ = P ( y = 1 ∣ x ) = σ ( w T x + b ) = 1 1 + e − ( w T x + b ) \hat{p} = P(y=1|x) = \sigma(w^T x + b) = \frac{1}{1+e^{-(w^T x+b)}} p^=P(y=1∣x)=σ(wTx+b)=1+e−(wTx+b)1

分类决策规则：

• 若 p ^ ≥ 0.5 \hat{p} \geq 0.5 p^≥0.5，预测为正类（ y = 1 y = 1 y=1）
• 若 p ^ < 0.5 \hat{p} < 0.5 p^<0.5，预测为负类（ y = 0 y = 0 y=0）

二、损失函数：如何学习最优参数？

逻辑回归通过对数损失函数（Log Loss）学习参数 w w w 和 b b b，其设计思想是：让正确分类的样本概率尽可能高，错误分类的样本概率尽可能低。

1. 对数损失函数的数学定义

对于二分类问题（ y ∈ { 0 , 1 } y \in \{0, 1\} y∈{0,1}），单个样本的损失为：

L ( w , b ) = − [ y ⋅ log ⁡ ( p ^ ) + ( 1 − y ) ⋅ log ⁡ ( 1 − p ^ ) ] L(w, b) = -[y \cdot \log(\hat{p}) + (1 - y) \cdot \log(1 - \hat{p})] L(w,b)=−[y⋅log(p^)+(1−y)⋅log(1−p^)]

损失函数解析：

• 当 y = 1 y = 1 y=1 时，损失简化为 − log ⁡ ( p ^ ) -\log(\hat{p}) −log(p^)： p ^ \hat{p} p^ 越接近 1，损失越小
• 当 y = 0 y = 0 y=0 时，损失简化为 − log ⁡ ( 1 − p ^ ) -\log(1 - \hat{p}) −log(1−p^)： p ^ \hat{p} p^ 越接近 0，损失越小

所有样本的平均损失（成本函数）：

J ( w , b ) = − 1 n ∑ i = 1 n [ y i ⋅ log ⁡ ( p ^ i ) + ( 1 − y i ) ⋅ log ⁡ ( 1 − p ^ i ) ] J(w, b) = -\frac{1}{n} \sum_{i=1}^{n} [y_i \cdot \log(\hat{p}_i) + (1 - y_i) \cdot \log(1 - \hat{p}_i)] J(w,b)=−n1i=1∑n[yi⋅log(p^i)+(1−yi)⋅log(1−p^i)]

2. 代码中的损失函数体现

在sklearn的LogisticRegression中，损失函数已内置实现，无需手动编写。以下代码展示如何通过数据学习参数：

import numpy as np
from sklearn.linear_model import LogisticRegression

# 示例数据
X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])  # 特征
y = np.array([0, 0, 1, 1])                       # 标签

# 创建并训练逻辑回归模型
model = LogisticRegression()
model.fit(X, y)

# 输出学习到的参数
print("权重w:", model.coef_)  # 对应w1, w2
print("偏置b:", model.intercept_)  # 对应b

三、参数优化：梯度下降法

逻辑回归通过梯度下降法 最小化损失函数 J ( w , b ) J(w, b) J(w,b)，核心是沿损失函数的负梯度方向迭代更新参数。

1. 梯度计算与参数更新

损失函数对参数的偏导数（梯度）为：

• 对权重 w j w_j wj：

∂ J ∂ w j = 1 n ∑ i = 1 n ( p ^ i − y i ) ⋅ x i j \frac{\partial J}{\partial w_j} = \frac{1}{n} \sum_{i=1}^{n} (\hat{p}i - y_i) \cdot x{ij} ∂wj∂J=n1i=1∑n(p^i−yi)⋅xij

• 对偏置 b b b：

∂ J ∂ b = 1 n ∑ i = 1 n ( p ^ i − y i ) \frac{\partial J}{\partial b} = \frac{1}{n} \sum_{i=1}^{n} (\hat{p}_i - y_i) ∂b∂J=n1i=1∑n(p^i−yi)

参数更新公式（ α \alpha α 为学习率）：

w j = w j − α ⋅ ∂ J ∂ w j w_j = w_j - \alpha \cdot \frac{\partial J}{\partial w_j} wj=wj−α⋅∂wj∂J

b = b − α ⋅ ∂ J ∂ b b = b - \alpha \cdot \frac{\partial J}{\partial b} b=b−α⋅∂b∂J

2. 代码中的优化器选择

sklearn 的 LogisticRegression 提供多种求解器（优化算法），如：

• lbfgs：默认求解器，适合中小数据集
• saga：支持大规模数据和 L1 正则化

四、多分类逻辑回归

逻辑回归可通过一对多（One-vs-Rest）策略扩展到多分类问题（如示例代码中的 3 分类任务）。

1. 多分类原理

对于 K K K 个类别，训练 K K K 个二分类模型：

• 模型 1：区分 "类别 1" 和 "其他类别"
• 模型 2：区分 "类别 2" 和 "其他类别"
• ...
• 模型 K K K：区分 "类别 K K K" 和 "其他类别"

预测时选择概率最高的类别作为结果。

2. 代码实现

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

# 加载数据（前三列为特征，第四列为标签1/2/3）
data = np.loadtxt('datingTestSet2.txt', delimiter='\t')
X = data[:, :-1]  # 特征
y = data[:, -1]   # 标签

# 拆分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=1000
)

# 构建模型管道（标准化+逻辑回归）
clf_pipeline = Pipeline([
    ('scaler', StandardScaler()),  # 特征标准化（加速收敛）
    ('logistic', LogisticRegression(
        C=0.01,          # 正则化强度倒数（值越小正则化越强）
        max_iter=1000,   # 迭代次数
        multi_class='ovr'  # 多分类策略：一对多
    ))
])

# 训练与评估
clf_pipeline.fit(X_train, y_train)
print("三分类准确率:", clf_pipeline.score(X_test, y_test))

五、正则化：防止过拟合

逻辑回归通过正则化限制参数大小，避免模型过度复杂。sklearn中通过参数C控制正则化强度（C =1/λ ，λ为正则化系数）：

• C越小：正则化越强，参数更接近 0，防止过拟合
• C越大：正则化越弱，模型可能更复杂

# 对比不同C值的效果
for C in [0.01, 0.1, 1, 10]:
    model = Pipeline([
        ('scaler', StandardScaler()),
        ('logistic', LogisticRegression(C=C, max_iter=1000))
    ])
    model.fit(X_train, y_train)
    print(f"C={C}时的准确率:", model.score(X_test, y_test))

六、总结：逻辑回归的核心逻辑

1. 模型本质：用 Sigmoid 函数将线性输出转换为概率，实现分类
2. 决策边界 ：线性边界（ w T x + b = 0 w^T x + b = 0 wTx+b=0）
3. 学习机制：通过对数损失函数和梯度下降学习参数
4. 扩展能力：支持多分类（一对多策略）和正则化

逻辑回归因其简单、高效、可解释性强（参数w可表示特征重要性），成为工业界处理分类问题的基础工具，也是理解神经网络等复杂模型的入门钥匙。