机器学习（二）

1. 线性回归：从确定性判别模型出发

线性模型是机器学习最基础的一类判别模型，其核心是建模输入特征与输出目标之间的线性关系。在确定性判别模型中，模型直接输出预测值：

y=fθ(x)=θ0+∑j=1dθjxj=θ⊤x y = f_\theta(x) = \theta_0 + \sum_{j=1}^{d} \theta_j x_j = \theta^\top x y=fθ(x)=θ0+j=1∑dθjxj=θ⊤x

其中 x=(1,x1,x2,...,xd)x = (1, x_1, x_2, \dots, x_d)x=(1,x1,x2,...,xd)，即把偏置项融入特征向量。线性模型不仅包含一维的直线拟合，也涵盖多项式回归等"广义线性模型"（只要关于参数 θ\thetaθ 线性即可），例如二次回归 f(x)=θ0+θ1x+θ2x2f(x) = \theta_0 + \theta_1 x + \theta_2 x^2f(x)=θ0+θ1x+θ2x2，以及多维特征的平面拟合。

学习目标：最小化训练集上的均方误差（MSE）：

J(θ)=12N∑i=1N(yi−fθ(xi))2 J(\theta) = \frac{1}{2N} \sum_{i=1}^{N} \bigl(y_i - f_\theta(x_i)\bigr)^2 J(θ)=2N1i=1∑N(yi−fθ(xi))2

损失函数采用平方误差，对大的预测误差给予更大惩罚，同时对小误差（可能源于观测噪声）容忍度较高，有助于提升泛化能力。

2. 梯度更新的三种形态

为了最小化目标函数 J(θ)J(\theta)J(θ)，通常采用梯度下降法迭代更新参数：

θnew←θold−η∂J(θ)∂θ \theta_{\text{new}} \leftarrow \theta_{\text{old}} - \eta \frac{\partial J(\theta)}{\partial \theta} θnew←θold−η∂θ∂J(θ)

根据一次迭代使用的样本数量不同，梯度下降分为三种方式：

2.1 批量梯度下降（Batch GD）

使用全部 NNN 个样本计算梯度，更新公式为：

θnew=θold+η1N∑i=1N(yi−fθ(xi))xi \theta_{\text{new}} = \theta_{\text{old}} + \eta \frac{1}{N} \sum_{i=1}^{N} \bigl(y_i - f_\theta(x_i)\bigr) x_i θnew=θold+ηN1i=1∑N(yi−fθ(xi))xi

优点：梯度估计稳定，收敛过程平滑。缺点：每步计算量较大，特别是海量数据时。

2.2 随机梯度下降（Stochastic GD）

每次仅随机抽取一个样本 (xi,yi)(x_i, y_i)(xi,yi) 进行更新：

θnew=θold+η(yi−fθ(xi))xi \theta_{\text{new}} = \theta_{\text{old}} + \eta \bigl(y_i - f_\theta(x_i)\bigr) x_i θnew=θold+η(yi−fθ(xi))xi

优点：更新速度快，可即时反映新数据。缺点：梯度方向存在较大随机震荡，收敛路径不稳定。

2.3 小批量梯度下降（Mini-batch GD）

将训练集划分为若干小批量（mini-batch），对每个小批量 Bk\mathcal{B}_kBk 执行一次批量更新：

J(k)(θ)=12Nk∑i∈Bk(yi−fθ(xi))2 J^{(k)}(\theta) = \frac{1}{2N_k} \sum_{i \in \mathcal{B}k} \bigl(y_i - f\theta(x_i)\bigr)^2 J(k)(θ)=2Nk1i∈Bk∑(yi−fθ(xi))2

θnew=θold−η∂J(k)(θ)∂θ \theta_{\text{new}} = \theta_{\text{old}} - \eta \frac{\partial J^{(k)}(\theta)}{\partial \theta} θnew=θold−η∂θ∂J(k)(θ)

该方法兼具批量 GD 的稳定性和随机 GD 的快速更新能力，且易于并行计算，是实际应用中最常用的梯度更新方式。

学习率 η\etaη 的选择至关重要：过小收敛缓慢；过大可能导致损失上升甚至发散。实践中常通过监视每若干次迭代的损失值来调优。

import numpy as np

# 生成模拟数据: y = 3 * x1 + 2 * x2 + 1 + 噪声
np.random.seed(42)
N = 100
X_raw = np.random.randn(N, 2)
X = np.c_[np.ones(N), X_raw]                    # 添加截距列 x0=1
true_theta = np.array([1.0, 3.0, 2.0])          # 真实参数
y = X @ true_theta + 0.5 * np.random.randn(N)   # 带噪声的目标值

def compute_gradient(X, y, theta):
    """计算均方误差损失对参数的梯度"""
    error = y - X @ theta
    return -X.T @ error / len(y)

def batch_gradient_descent(X, y, lr=0.01, epochs=1000):
    """批量梯度下降：每一轮使用全部样本计算梯度并更新参数"""
    theta = np.zeros(X.shape[1])
    for epoch in range(epochs):
        grad = compute_gradient(X, y, theta)       # 全量梯度
        theta = theta - lr * grad
        if epoch % 200 == 0:
            loss = np.mean((y - X @ theta) ** 2)
            print(f"[批量GD] epoch {epoch:4d}, loss={loss:.6f}")
    return theta

def stochastic_gradient_descent(X, y, lr=0.01, epochs=5):
    """随机梯度下降：每轮遍历时随机打乱样本，逐样本更新参数"""
    theta = np.zeros(X.shape[1])
    n = len(y)
    for epoch in range(epochs):
        indices = np.random.permutation(n)
        for i in indices:
            xi = X[i:i+1]
            yi = y[i:i+1]
            grad = -xi.T @ (yi - xi @ theta)       # 单样本梯度
            theta = theta - lr * grad
        loss = np.mean((y - X @ theta) ** 2)
        print(f"[随机GD] epoch {epoch+1}/{epochs}, loss={loss:.6f}")
    return theta

def mini_batch_gradient_descent(X, y, lr=0.01, epochs=100, batch_size=16):
    """小批量梯度下降：每次使用 batch_size 个样本近似全梯度"""
    theta = np.zeros(X.shape[1])
    n = len(y)
    for epoch in range(epochs):
        indices = np.random.permutation(n)
        for start in range(0, n, batch_size):
            batch_idx = indices[start:start+batch_size]
            Xi = X[batch_idx]
            yi = y[batch_idx]
            grad = -Xi.T @ (yi - Xi @ theta) / len(batch_idx)
            theta = theta - lr * grad
        if epoch % 20 == 0:
            loss = np.mean((y - X @ theta) ** 2)
            print(f"[小批量GD] epoch {epoch:3d}, loss={loss:.6f}")
    return theta

# ------------------ 运行示例 ------------------
print("批量梯度下降：")
theta_bgd = batch_gradient_descent(X, y, lr=0.01)
print(f"求解参数：{theta_bgd}\n")

print("随机梯度下降：")
theta_sgd = stochastic_gradient_descent(X, y, lr=0.01, epochs=10)
print(f"求解参数：{theta_sgd}\n")

print("小批量梯度下降：")
theta_mbgd = mini_batch_gradient_descent(X, y, lr=0.01, epochs=100, batch_size=16)
print(f"求解参数：{theta_mbgd}")

可视化：三种梯度下降收敛过程对比

为了直观感受批量梯度下降、随机梯度下降与小批量梯度下降在收敛速度和稳定性上的差异，我们在训练过程中记录损失值，并使用 Matplotlib 绘制损失随迭代次数的变化曲线。

import numpy as np
import matplotlib.pyplot as plt

# 复用之前的模拟数据
np.random.seed(42)
N = 100
X_raw = np.random.randn(N, 2)
X = np.c_[np.ones(N), X_raw]
true_theta = np.array([1.0, 3.0, 2.0])
y = X @ true_theta + 0.5 * np.random.randn(N)

def compute_gradient(X, y, theta):
    """计算均方误差损失对参数的梯度"""
    error = y - X @ theta
    return -X.T @ error / len(y)

def bgd_with_history(X, y, lr=0.01, epochs=1000):
    """批量梯度下降，记录每个 epoch 的损失"""
    theta = np.zeros(X.shape[1])
    loss_history = []
    for epoch in range(epochs):
        grad = compute_gradient(X, y, theta)
        theta = theta - lr * grad
        loss = np.mean((y - X @ theta) ** 2)
        loss_history.append(loss)
    return theta, loss_history

def sgd_with_history(X, y, lr=0.01, epochs=5):
    """随机梯度下降，记录每次参数更新后的损失"""
    theta = np.zeros(X.shape[1])
    n = len(y)
    loss_history = []
    for epoch in range(epochs):
        indices = np.random.permutation(n)
        for i in indices:
            xi = X[i:i+1]
            yi = y[i:i+1]
            grad = -xi.T @ (yi - xi @ theta)
            theta = theta - lr * grad
            loss = np.mean((y - X @ theta) ** 2)
            loss_history.append(loss)
    return theta, loss_history

def mini_bgd_with_history(X, y, lr=0.01, epochs=100, batch_size=16):
    """小批量梯度下降，每个 epoch 结束时记录一次损失"""
    theta = np.zeros(X.shape[1])
    n = len(y)
    loss_history = []
    for epoch in range(epochs):
        indices = np.random.permutation(n)
        for start in range(0, n, batch_size):
            batch_idx = indices[start:start+batch_size]
            Xi = X[batch_idx]
            yi = y[batch_idx]
            grad = -Xi.T @ (yi - Xi @ theta) / len(batch_idx)
            theta = theta - lr * grad
        loss = np.mean((y - X @ theta) ** 2)
        loss_history.append(loss)
    return theta, loss_history

# 训练并记录损失
_, loss_bgd = bgd_with_history(X, y, lr=0.01, epochs=1000)
_, loss_sgd = sgd_with_history(X, y, lr=0.01, epochs=5)
_, loss_mbgd = mini_bgd_with_history(X, y, lr=0.01, epochs=100, batch_size=16)

# 绘制损失曲线
plt.figure(figsize=(10, 5))
plt.plot(loss_bgd, label="批量梯度下降 (Batch GD)", alpha=0.8)
plt.plot(loss_sgd, label="随机梯度下降 (Stochastic GD)", alpha=0.8)
plt.plot(loss_mbgd, label="小批量梯度下降 (Mini-batch GD)", alpha=0.8)
plt.xlabel("迭代次数（SGD 为单样本更新次数）", fontsize=12)
plt.ylabel("均方误差损失", fontsize=12)
plt.title("三种梯度下降收敛过程对比", fontsize=14)
plt.legend()
plt.grid(True, linestyle="--", alpha=0.6)
plt.tight_layout()
plt.show()

结果解读：

• 批量梯度下降（蓝色曲线）：损失平滑下降，每步更新方向最准确，但每轮计算开销较大（需扫描全量数据）。
• 随机梯度下降（橙色曲线）：损失震荡剧烈，但更新频率极高（每个样本即更新一次），能快速降低损失，适合在线学习场景。
• 小批量梯度下降（绿色曲线）：损失下降趋势稳定且速度较快，每个 epoch 记录一次损失，兼顾了计算效率与收敛稳定性，是实际应用中最常用的方案。

通过该对比图可以直观理解：小批量梯度下降在收敛速度和稳定性之间取得了最佳平衡，这也是深度学习训练中几乎都采用 mini-batch 方式的原因。

3. 线性回归的矩阵形式与几何本质

将 NNN 个样本写成设计矩阵 X∈RN×dX \in \mathbb{R}^{N \times d}X∈RN×d，参数向量 θ∈Rd\theta \in \mathbb{R}^dθ∈Rd，标签向量 y∈RNy \in \mathbb{R}^Ny∈RN，则目标函数为：

J(θ)=12(y−Xθ)⊤(y−Xθ) J(\theta) = \frac{1}{2} (y - X\theta)^\top (y - X\theta) J(θ)=21(y−Xθ)⊤(y−Xθ)

对 θ\thetaθ 求梯度并令其为零，可得闭式解（Normal Equation）：

θ^=(X⊤X)−1X⊤y \hat{\theta} = (X^\top X)^{-1} X^\top y θ^=(X⊤X)−1X⊤y

预测值可写为 y^=Xθ^=Hy\hat{y} = X\hat{\theta} = H yy^=Xθ^=Hy，其中帽子矩阵 H=X(X⊤X)−1X⊤H = X(X^\top X)^{-1} X^\topH=X(X⊤X)−1X⊤ 将标签向量 yyy 投影到特征列张成的子空间，这使得线性回归具有清晰的几何解释：预测值是真实标签在特征空间中的正交投影。

当 X⊤XX^\top XX⊤X 为奇异矩阵（例如列向量线性相关）时，闭式解不可用。此时引入 L2 正则化：

J(θ)=12(y−Xθ)⊤(y−Xθ)+λ2∥θ∥22 J(\theta) = \frac{1}{2} (y - X\theta)^\top (y - X\theta) + \frac{\lambda}{2} \|\theta\|_2^2 J(θ)=21(y−Xθ)⊤(y−Xθ)+2λ∥θ∥22

其闭式解变为 θ^=(X⊤X+λI)−1X⊤y\hat{\theta} = (X^\top X + \lambda I)^{-1} X^\top yθ^=(X⊤X+λI)−1X⊤y，确保了数值稳定性和泛化性能。

4. 泛线性模型与核技巧

线性模型可通过特征映射 ϕ:Rd→Rh\phi: \mathbb{R}^d \to \mathbb{R}^hϕ:Rd→Rh 扩展为泛线性模型：

y=f(θ⊤ϕ(x)) y = f(\theta^\top \phi(x)) y=f(θ⊤ϕ(x))

令 Φ\PhiΦ 为映射后的设计矩阵，目标函数为 J(θ)=12(y−Φθ)⊤(y−Φθ)J(\theta) = \frac{1}{2} (y - \Phi\theta)^\top (y - \Phi\theta)J(θ)=21(y−Φθ)⊤(y−Φθ)。闭式解与正则化形式与前类似。

借助矩阵求逆引理，可导出核形式的解，不显式计算 Φ\PhiΦ，而仅依赖核矩阵 KKK，其元素为 K(xi,xj)=ϕ(xi)⊤ϕ(xj)K(x_i, x_j) = \phi(x_i)^\top \phi(x_j)K(xi,xj)=ϕ(xi)⊤ϕ(xj)：

y^=K(K+λIn)−1y \hat{y} = K (K + \lambda I_n)^{-1} y y^=K(K+λIn)−1y

这便是核岭回归 的基本形式，它使得线性方法能够捕获非线性关系，同时计算仅依赖于样本维数 nnn 而非特征维数 hhh。

5. 概率视角：最大似然估计与线性回归

从概率角度，可假设目标变量包含高斯噪声：

y=θ⊤x+ϵ,ϵ∼N(0,σ2) y = \theta^\top x + \epsilon, \quad \epsilon \sim \mathcal{N}(0, \sigma^2) y=θ⊤x+ϵ,ϵ∼N(0,σ2)

此时给定输入 xxx 的标签条件分布为：

p(y∣x)=12πσ2exp⁡ ⁣(−(y−θ⊤x)22σ2) p(y|x) = \frac{1}{\sqrt{2\pi\sigma^2}} \exp\!\left(-\frac{(y - \theta^\top x)^2}{2\sigma^2}\right) p(y∣x)=2πσ2 1exp(−2σ2(y−θ⊤x)2)

对 NNN 个独立样本进行最大似然估计，等价于最小化平方误差和：

max⁡θ∏i=1Np(yi∣xi)  ⇔  min⁡θ∑i=1N(yi−θ⊤xi)2 \max_\theta \prod_{i=1}^{N} p(y_i|x_i) \;\Leftrightarrow\; \min_\theta \sum_{i=1}^{N} (y_i - \theta^\top x_i)^2 θmaxi=1∏Np(yi∣xi)⇔θmini=1∑N(yi−θ⊤xi)2

这从概率论证了最小二乘损失的合理性，并为引入正则化（如最大后验估计）提供了理论支撑。

6. 逻辑斯谛回归：从回归到分类

6.1 二分类逻辑斯谛回归

对于二分类问题（y∈{0,1}y \in \{0,1\}y∈{0,1}），我们模型化后验概率：

pθ(y=1∣x)=σ(θ⊤x)=11+e−θ⊤x p_\theta(y=1|x) = \sigma(\theta^\top x) = \frac{1}{1 + e^{-\theta^\top x}} pθ(y=1∣x)=σ(θ⊤x)=1+e−θ⊤x1

其中 σ(⋅)\sigma(\cdot)σ(⋅) 为 S 形函数。模型通过交叉熵损失进行训练：

L(y,x,pθ)=−ylog⁡σ(θ⊤x)−(1−y)log⁡(1−σ(θ⊤x)) \mathcal{L}(y, x, p_\theta) = -y \log \sigma(\theta^\top x) - (1-y) \log(1 - \sigma(\theta^\top x)) L(y,x,pθ)=−ylogσ(θ⊤x)−(1−y)log(1−σ(θ⊤x))

其梯度简洁：

∂L∂θ=(σ(θ⊤x)−y)x \frac{\partial \mathcal{L}}{\partial \theta} = \bigl(\sigma(\theta^\top x) - y\bigr) x ∂θ∂L=(σ(θ⊤x)−y)x

因此参数更新形式为：

θ←θ+η(y−σ(θ⊤x))x \theta \leftarrow \theta + \eta \bigl(y - \sigma(\theta^\top x)\bigr) x θ←θ+η(y−σ(θ⊤x))x

最终预测时，通常会设定一个阈值 hhh（如 0.5），将概率大于 hhh 的样本判为正类。

6.2 多分类逻辑斯谛回归（Softmax 回归）

对于 mmm 个类别，为每个类 cjc_jcj 学习一组参数 θj\theta_jθj，并用 softmax 函数计算概率：

pθ(y=cj∣x)=eθj⊤x∑k=1meθk⊤x p_\theta(y = c_j | x) = \frac{e^{\theta_j^\top x}}{\sum_{k=1}^{m} e^{\theta_k^\top x}} pθ(y=cj∣x)=∑k=1meθk⊤xeθj⊤x

给定真实类别 cjc_jcj 的单个样本，对数似然的梯度为：

∂log⁡pθ(y=cj∣x)∂θj=(1−pθ(y=cj∣x))x \frac{\partial \log p_\theta(y=c_j|x)}{\partial \theta_j} = \bigl(1 - p_\theta(y=c_j|x)\bigr) x ∂θj∂logpθ(y=cj∣x)=(1−pθ(y=cj∣x))x

参数更新形式与二分类高度一致，体现了逻辑斯谛回归的统一性。

二分类逻辑回归完整代码示例

下面使用 Python 从头实现二分类逻辑斯谛回归，包括 Sigmoid 函数、交叉熵损失、小批量梯度下降、预测与准确率评估。

import numpy as np

# ---------- 1. 生成模拟二分类数据 ----------
np.random.seed(42)
n_samples = 200
n_features = 2

# 生成两个类别的样本，便于线性可分
X_pos = np.random.randn(n_samples // 2, n_features) + np.array([2.0, 2.0])  # 正类
X_neg = np.random.randn(n_samples // 2, n_features) + np.array([-2.0, -2.0]) # 负类
X_raw = np.vstack([X_pos, X_neg])
y = np.hstack([np.ones(n_samples // 2), np.zeros(n_samples // 2)])

# 添加截距列 x0=1
X = np.c_[np.ones(n_samples), X_raw]

# ---------- 2. Sigmoid 函数 ----------
def sigmoid(z):
    """将线性输出映射到 (0,1) 概率区间"""
    # 为避免数值溢出，对输入做裁剪
    z = np.clip(z, -500, 500)
    return 1.0 / (1.0 + np.exp(-z))

# ---------- 3. 交叉熵损失 ----------
def compute_loss(X, y, theta):
    h = sigmoid(X @ theta)          # 预测概率
    epsilon = 1e-8                  # 防止 log(0)
    loss = -np.mean(y * np.log(h + epsilon) + (1 - y) * np.log(1 - h + epsilon))
    return loss

# ---------- 4. 梯度计算 ----------
def compute_gradient_logistic(X, y, theta):
    h = sigmoid(X @ theta)
    error = h - y                   # 损失对输入加权和的误差
    grad = X.T @ error / len(y)    # 参数梯度
    return grad

# ---------- 5. 小批量梯度下降训练 ----------
def logistic_regression_train(X, y, lr=0.1, epochs=500, batch_size=32):
    """使用 mini-batch 梯度下降训练二分类逻辑斯谛回归"""
    theta = np.zeros(X.shape[1])
    n = len(y)
    loss_history = []

    for epoch in range(epochs):
        indices = np.random.permutation(n)
        for start in range(0, n, batch_size):
            batch_idx = indices[start:start+batch_size]
            Xi = X[batch_idx]
            yi = y[batch_idx]
            grad = compute_gradient_logistic(Xi, yi, theta)
            theta = theta - lr * grad

        # 每个 epoch 记录一次全量损失
        if epoch % 50 == 0:
            loss = compute_loss(X, y, theta)
            loss_history.append(loss)
            print(f"epoch {epoch:4d}, loss={loss:.6f}")

    return theta, loss_history

# ---------- 6. 预测与评估 ----------
def predict(X, theta, threshold=0.5):
    """根据概率输出和阈值进行预测"""
    prob = sigmoid(X @ theta)
    return (prob >= threshold).astype(int)

# ---------- 7. 执行训练与评估 ----------
theta, loss_hist = logistic_regression_train(X, y, lr=0.1, epochs=500, batch_size=32)

y_pred = predict(X, theta)
accuracy = np.mean(y_pred == y)

print(f"\n训练完成，参数 theta = {theta}")
print(f"训练集准确率 = {accuracy:.4f}")

# 简单打印混淆矩阵元素
TP = np.sum((y_pred == 1) & (y == 1))
TN = np.sum((y_pred == 0) & (y == 0))
FP = np.sum((y_pred == 1) & (y == 0))
FN = np.sum((y_pred == 0) & (y == 1))
print(f"TP={TP}, TN={TN}, FP={FP}, FN={FN}")

代码关键点说明：

• 数据生成：手动构建近似线性可分的二维数据，确保模型能较好收敛。
• Sigmoid 实现 ：通过 np.clip 防止指数运算溢出。
• 交叉熵损失 ：计算全量损失时加入微小常数 epsilon 防止 log(0)。
• 梯度下降：采用小批量（mini-batch）策略，兼顾收敛速度与稳定性；每个 epoch 记录一次损失用于监控。
• 预测：以 0.5 为阈值将概率转为类别标签。
• 评估：计算准确率并输出 TP/TN/FP/FN，帮助理解模型性能。

运行示例可观察到损失稳步下降，最终准确率接近或达到 1.0，验证二分类逻辑斯谛回归的有效性。

7. 分类任务的评估指标

不同指标从不同侧面衡量分类模型表现，需根据业务场景选取：

• 混淆矩阵：将预测结果分为 TP、FP、FN、TN 四类。
• 准确率（Accuracy） ：(TP+TN)/Total(TP+TN) / \text{Total}(TP+TN)/Total，适合类别均衡场景。
• 精确率（Precision） ：TP/(TP+FP)TP / (TP+FP)TP/(TP+FP)，关注"预测为正的样本中有多少是真的"。
• 召回率（Recall） ：TP/(TP+FN)TP / (TP+FN)TP/(TP+FN)，关注"真正的正样本有多少被召回"。
• F1 分数 ：精确率与召回率的调和平均，综合二者：F1=2×Precision×RecallPrecision+Recall\displaystyle F1 = \frac{2 \times \text{Precision} \times \text{Recall}}{\text{Precision} + \text{Recall}}F1=Precision+Recall2×Precision×Recall。
• AUC（ROC 曲线下面积）：反映模型对正负样本的排序能力，取值 0.5（随机）至 1（完美），是衡量排序质量的核心指标。

通过调整概率阈值可在精确率和召回率之间进行权衡：阈值升高则精确率上升、召回率下降；反之亦然。

8. 实践案例：CTR 预估中的逻辑斯谛回归

以在线广告点击率（CTR）预估为例，典型流程包括：

1. 特征工程：将用户属性、广告属性、上下文信息等转化为高维稀疏的 one-hot 向量（维度可达百万甚至十亿级）。
2. 数据划分：按时间顺序划分训练/验证/测试集，例如 8:1:1，并对训练数据做随机洗牌。
3. 模型训练 ：使用带 L2 正则化的逻辑斯谛回归：
   L=−ylog⁡σ(θ⊤x)−(1−y)log⁡(1−σ(θ⊤x))+λ2∥θ∥22 \mathcal{L} = -y\log\sigma(\theta^\top x) - (1-y)\log(1-\sigma(\theta^\top x)) + \frac{\lambda}{2}\|\theta\|_2^2 L=−ylogσ(θ⊤x)−(1−y)log(1−σ(θ⊤x))+2λ∥θ∥22
   由于特征高维稀疏，参数更新时仅需更新非零特征对应的权重，计算高效。
4. 性能对比：在 Criteo 和 iPinYou 等数据集上的实验表明，逻辑斯谛回归在 AUC 和 Log Loss 上略低于 FM 和 DNN，但其优点在于实现标准化、解释性强、训练和推断效率高、易于大规模扩展。

对于某些强调可解释性和实时性的业务场景，线性模型依然是强有力的基线。

9. 知识脉络总结

本文围绕线性模型，从回归到分类，从代数到概率，从理论到实践，构建了一幅完整的知识图谱：

• 基础模型：线性回归 → 均方误差损失 → 梯度下降优化（批量、随机、小批量）
• 矩阵表示：设计矩阵与闭式解 → 正则化 → 几何解释（投影）
• 扩展能力：特征映射 → 泛线性模型 → 核方法
• 概率化：高斯噪声假设 → 最大似然 → 说明最小二乘
• 分类迁移：Sigmoid → 逻辑斯谛回归 → 交叉熵 → 梯度推导
• 多类拓展：Softmax → 多分类交叉熵 → 统一参数更新形式
• 评估体系：混淆矩阵、Precision、Recall、F1、AUC
• 实战落地：one-hot 高维特征、L2 正则化逻辑斯谛回归、大数据集上的高效训练与对比评估

这条脉络由浅入深，从确定性模型到概率模型，从回归到分类，从闭式解到大规模迭代优化，系统地展示了线性模型的理论基础、数学工具与工业实践。