深度学习中的逻辑回归：从原理到Python实现

逻辑回归概述

逻辑回归是用于解决二分类问题的经典算法，尽管名称含"回归"，实为分类模型。其核心思想是通过线性组合加非线性变换，将输入特征映射到[0,1]区间，表示样本属于正类的概率：

$$z={\mathbf{w}}^T\mathbf{x}+b$$
$$\hat{y}=\sigma (z)=\frac{1}{1+e^{-z}}$$

其中$\sigma (z)$为sigmoid函数，其特性如下：

sigmoid函数

计算示例

逻辑回归损失函数

损失函数用域名衡量预测结构与真实值之间的误差。最简单的损失函数定义方式为平方差损失:
$$L(\hat{y},y)=\frac{1}{2}(\hat{y}-y{)}^2$$
而逻辑回归一般使用 ： $$L(\hat{y},y)=-(ylog\hat{y})-(1-y)log(1-\hat{y})$$
该式子的理解：

• 如何$y=1$，损失为$-log\hat{y}$，那么要想损失越小，$haty$的值必须越大，即越趋近于或者等于1
• 如果$y=0$，损失为$-log(1-\hat{y})$，那么要想损失越小，那么$\hat{y}$的值越小，即趋近于或者等于0

损失函数是在单个训练样本中定义的，它衡量了在单个训练样本上的表现。代价函数衡量的是在全体训练样本上的表现，即衡量参数$w$和$b$的效果，所以训练样本的损失平均值为：
$$J(w,b)=\frac{1}{m}{\Sigma }_{i=1}^{m}L({\hat{y}}^{(i)},y^{(i)})$$

梯度下降算法

梯度下降图示

可以看到，成本函数$J$是一个凸函数，包含多个局部最低。
通过最小化损失函数来优化参数$\mathbf{w}$和$b$：
$$\mathbf{w}:=\mathbf{w}-\alpha \frac{\partial J}{\partial \mathbf{w}}$$
$$b:=b-\alpha \frac{\partial J}{\partial b}$$

其中$\alpha$表示学习速率，即每次更新的$w$的步伐长度。当$w$大于最优解$w^{{}^{\prime }}$时，导数大于0，那么$w$就会向更小的方向更新。反之当$w$小于最优解$w^{{}^{\prime }}$时，导数小于0，那么$w$就会向更大的方向更新。迭代直到收敛。

向量化梯度计算

向量化梯度计算原理

在逻辑回归中，向量化梯度计算的核心思想是使用矩阵运算替代循环操作，大幅提升计算效率。其数学基础是：

给定：

• 特征矩阵 $X\in {\mathbb{R}}^{m\times n}$（m个样本，n个特征）
• 参数向量 $w\in {\mathbb{R}}^n$
• 偏置 $b\in \mathbb{R}$
• 预测值 $\hat{y}=\sigma (Xw+b)$
• 真实标签 $y\in {\mathbb{R}}^m$

梯度计算可向量化为：
$${\nabla }_{w}J=\frac{1}{m}{X}^T(\hat{y}-y)$$
$${\nabla }_{b}J=\frac{1}{m}\sum _{i=1}^m({\hat{y}}^{(i)}-y^{(i)})$$

优势对比：

方法	时间复杂度	代码简洁性	计算效率
循环迭代	$O(m\times n)$	低	低
向量化	$O(1)$ 矩阵运算	高	高（加速10-100倍）

伪代码实现

# 输入：特征矩阵X，标签y，参数w，偏置b，样本数m
# 输出：权重梯度dw，偏置梯度db前向传播：Z = X · w + b        # 矩阵乘法 (m×n)·(n×1) = (m×1)Y_hat = sigmoid(Z)   # 元素级sigmoid函数计算梯度：error = Y_hat - y    # 预测误差 (m×1)dw = (1/m) * (Xᵀ · error)  # (n×m)·(m×1) = (n×1)db = (1/m) * sum(error)    # 标量

简单示例说明

假设我们有3个样本和2个特征：

输入数据：

X = [[2, 3],   # 样本1[1, 4],   # 样本2[3, 1]]   # 样本3y = [1, 0, 1]   # 真实标签w = [0.5, -0.2] # 初始权重
b = 0.1         # 初始偏置

计算步骤：

1. 前向传播（向量化）：

   Z = X·w + b = [[2*0.5 + 3*(-0.2) + 0.1],[1*0.5 + 4*(-0.2) + 0.1],[3*0.5 + 1*(-0.2) + 0.1]]= [0.5, -0.2, 1.4]Y_hat = sigmoid(Z) ≈ [0.622, 0.450, 0.802]
   

2. 计算误差：

   error = Y_hat - y = [0.622-1, 0.450-0, 0.802-1]= [-0.378, 0.450, -0.198]
   

3. 向量化梯度计算：

   dw = (1/3) * Xᵀ · error= (1/3) * [[2, 1, 3],   # X转置[3, 4, 1]] ·  [[-0.378],[ 0.450],[-0.198]]= (1/3) * [[2*(-0.378) + 1*0.450 + 3*(-0.198)],[3*(-0.378) + 4*0.450 + 1*(-0.198)]]= (1/3) * [[-0.756 + 0.450 - 0.594],[-1.134 + 1.800 - 0.198]]= (1/3) * [[-0.900], [0.468]]≈ [[-0.300], [0.156]]db = (1/3) * sum(error)= (1/3) * (-0.378 + 0.450 - 0.198)= (1/3) * (-0.126)= -0.042
   

Python实现对比

循环实现（低效）

def compute_gradients_loop(X, y, w, b):m, n = X.shapedw = np.zeros(n)db = 0for i in range(m):z_i = np.dot(X[i], w) + ba_i = 1 / (1 + np.exp(-z_i))dz_i = a_i - y[i]for j in range(n):dw[j] += X[i, j] * dz_idb += dz_idw /= mdb /= mreturn dw, db

向量化实现（高效）

def compute_gradients_vectorized(X, y, w, b):m = X.shape[0]Z = np.dot(X, w) + bA = 1 / (1 + np.exp(-Z))dZ = A - ydw = (1/m) * np.dot(X.T, dZ)db = (1/m) * np.sum(dZ)return dw, db

性能对比测试

import time
import numpy as np# 生成大数据集 (10,000样本, 100特征)
X_large = np.random.randn(10000, 100)
y_large = np.random.randint(0, 2, 10000)
w_large = np.random.randn(100)
b_large = 0# 测试循环实现
start = time.time()
dw_loop, db_loop = compute_gradients_loop(X_large, y_large, w_large, b_large)
loop_time = time.time() - start# 测试向量化实现
start = time.time()
dw_vec, db_vec = compute_gradients_vectorized(X_large, y_large, w_large, b_large)
vec_time = time.time() - startprint(f"循环实现时间: {loop_time:.4f}秒")
print(f"向量化实现时间: {vec_time:.4f}秒")
print(f"加速比: {loop_time/vec_time:.1f}x")
print(f"梯度差异: {np.linalg.norm(dw_loop - dw_vec):.6f}")

典型输出：

输出示例

向量化背后的数学原理

1. 矩阵微分规则：
   $$\frac{\partial }{\partial w}(Xw)=X^T$$

2. 链式法则的向量形式：
   $${\nabla }_{w}J=\frac{\partial J}{\partial \hat{y}}\cdot \frac{\partial \hat{y}}{\partial z}\cdot \frac{\partial z}{\partial w}$$
   其中：

   • $\frac{\partial J}{\partial \hat{y}}=\frac{\hat{y}-y}{\hat{y}(1-\hat{y})}$
   • $\frac{\partial \hat{y}}{\partial z}=\hat{y}(1-\hat{y})$
   • $\frac{\partial z}{\partial w}=X^T$

   简化后：
   $${\nabla }_{w}J=X^T(\hat{y}-y)$$

3. 广播机制：

   # 标量b自动广播到向量运算中
   Z = X.dot(w) + b  # b被加到每个样本上
   

Python实现逻辑回归

完整代码

import numpy as np
import matplotlib.pyplot as pltclass LogisticRegression:def __init__(self, learning_rate=0.01, n_iters=1000):self.lr = learning_rateself.n_iters = n_itersself.weights = Noneself.bias = Nonedef _sigmoid(self, z):return 1 / (1 + np.exp(-z))def fit(self, X, y):n_samples, n_features = X.shapeself.weights = np.zeros(n_features)self.bias = 0# 梯度下降优化for _ in range(self.n_iters):# 前向传播linear_model = np.dot(X, self.weights) + self.biasy_pred = self._sigmoid(linear_model)# 反向传播（向量化计算梯度）dw = (1 / n_samples) * np.dot(X.T, (y_pred - y))db = (1 / n_samples) * np.sum(y_pred - y)# 参数更新self.weights -= self.lr * dwself.bias -= self.lr * dbdef predict_prob(self, X):linear_model = np.dot(X, self.weights) + self.biasreturn self._sigmoid(linear_model)def predict(self, X, threshold=0.5):return (self.predict_prob(X) >= threshold).astype(int)# 测试示例
if __name__ == "__main__":# 生成示例数据from sklearn.datasets import make_classificationX, y = make_classification(n_samples=100, n_features=2, n_redundant=0, n_informative=2, random_state=42)# 训练模型model = LogisticRegression(learning_rate=0.1, n_iters=1000)model.fit(X, y)predictions = model.predict(X)# 计算准确率accuracy = np.mean(predictions == y)print(f"Model accuracy: {accuracy:.4f}")# 可视化决策边界plt.figure(figsize=(10, 6))plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Paired, edgecolors='k')ax = plt.gca()xlim = ax.get_xlim()ylim = ax.get_ylim()# 创建网格以绘制决策边界xx, yy = np.meshgrid(np.linspace(xlim[0], xlim[1], 50),np.linspace(ylim[0], ylim[1], 50))Z = model.predict(np.c_[xx.ravel(), yy.ravel()])Z = Z.reshape(xx.shape)plt.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.Paired)plt.title("Logistic Regression Decision Boundary")plt.xlabel("Feature 1")plt.ylabel("Feature 2")plt.show()

• 输出示例

完整代码输出示例

代码结构详解

1. 导入必要的库

import numpy as np
import matplotlib.pyplot as plt

• numpy：用于高效的数值计算和矩阵运算
• matplotlib.pyplot：用于数据可视化，绘制决策边界

2. LogisticRegression类定义

2.1 初始化方法 __init__

def __init__(self, learning_rate=0.01, n_iters=1000):self.lr = learning_rateself.n_iters = n_itersself.weights = Noneself.bias = None

• learning_rate：学习率，控制梯度下降的步长
• n_iters：梯度下降的迭代次数
• weights：特征权重向量（待训练）
• bias：偏置项（待训练）

2.2 Sigmoid激活函数 _sigmoid

def _sigmoid(self, z):return 1 / (1 + np.exp(-z))

• 将线性输出转换为概率值（0-1之间）
• 公式：$\sigma (z)=\frac{1}{1+e^{-z}}$
• 函数曲线特性：
  • 当 $z\to \infty$ 时，$\sigma (z)\to 1$
  • 当 $z\to -\infty$ 时，$\sigma (z)\to 0$
  • 当 $z=0$ 时，$\sigma (z)=0.5$

2.3 训练方法 fit

def fit(self, X, y):n_samples, n_features = X.shapeself.weights = np.zeros(n_features)self.bias = 0

• 输入：
  • X：训练数据特征矩阵（形状：n_samples × n_features）
  • y：训练数据标签向量（形状：n_samples）
• 初始化：权重初始化为零向量，偏置初始化为0

    # 梯度下降优化for _ in range(self.n_iters):# 前向传播linear_model = np.dot(X, self.weights) + self.biasy_pred = self._sigmoid(linear_model)

• 前向传播：
  • 计算线性部分：$z=X\cdot w+b$
  • 应用sigmoid激活：$\hat{y}=\sigma (z)$

        # 反向传播（向量化计算梯度）dw = (1 / n_samples) * np.dot(X.T, (y_pred - y))db = (1 / n_samples) * np.sum(y_pred - y)

• 梯度计算（向量化实现）：
  • 权重梯度：$\frac{\partial J}{\partial w}=\frac{1}{m}{X}^T(\hat{y}-y)$
  • 偏置梯度：$\frac{\partial J}{\partial b}=\frac{1}{m}\sum (\hat{y}-y)$

        # 参数更新self.weights -= self.lr * dwself.bias -= self.lr * db

• 参数更新：使用梯度下降算法
  • $w:=w-\alpha \frac{\partial J}{\partial w}$
  • $b:=b-\alpha \frac{\partial J}{\partial b}$

2.4 预测方法

def predict_prob(self, X):linear_model = np.dot(X, self.weights) + self.biasreturn self._sigmoid(linear_model)

• 返回样本属于正类的概率（0-1之间）

def predict(self, X, threshold=0.5):return (self.predict_prob(X) >= threshold).astype(int)

• 根据阈值（默认0.5）将概率转换为类别预测
• 概率 ≥ threshold 预测为正类（1），否则为负类（0）

3. 测试与可视化

3.1 生成示例数据

from sklearn.datasets import make_classification
X, y = make_classification(n_samples=100, n_features=2, n_redundant=0, n_informative=2, random_state=42)

• 使用scikit-learn生成二分类数据集
• 100个样本，2个特征，无冗余特征
• random_state=42确保结果可复现

3.2 模型训练与评估

model = LogisticRegression(learning_rate=0.1, n_iters=1000)
model.fit(X, y)
predictions = model.predict(X)
accuracy = np.mean(predictions == y)
print(f"Model accuracy: {accuracy:.4f}")

• 创建模型实例（学习率0.1，迭代1000次）
• 训练模型
• 在训练集上预测并计算准确率

3.3 决策边界可视化

plt.figure(figsize=(10, 6))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Paired, edgecolors='k')

• 创建散点图，不同颜色表示不同类别

ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()# 创建网格点
xx, yy = np.meshgrid(np.linspace(xlim[0], xlim[1], 50),np.linspace(ylim[0], ylim[1], 50))

• 获取当前坐标轴范围
• 创建覆盖整个绘图区域的网格点

# 预测网格点的类别
Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)# 绘制决策边界
plt.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.Paired)

• 将网格点转换为特征矩阵进行预测
• 使用等高线填充绘制决策区域

plt.title("Logistic Regression Decision Boundary")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.show()

• 添加标题和轴标签
• 显示可视化结果

关键概念图解

1. 逻辑回归工作流程

2. 梯度下降优化过程

总结

逻辑回归作为深度学习的基础组件，具有以下特点：

• 通过sigmoid函数实现概率输出
• 使用交叉熵损失函数优化分类性能
• 依赖梯度下降进行参数更新
• 向量化实现显著提升计算效率