LLM大模型中的基础数学工具——非凸优化

最新推荐文章于 2025-04-25 22:37:54 发布

墨顿

最新推荐文章于 2025-04-25 22:37:54 发布

阅读量743

点赞数 11

文章标签：大模型深度学习非凸优化

本文链接：https://blog.csdn.net/pzccool/article/details/147388841

版权

Q30: 分析随机梯度下降（SGD）在鞍点处的逃离概率

随机梯度下降与鞍点是啥？

随机梯度下降（SGD）是深度学习中常用的优化算法，每次更新仅基于一个样本的梯度。鞍点是函数一阶导数为零，但非极值点的位置（类似马鞍中心）。在鞍点处，SGD 因梯度噪声有逃离可能。

逃离概率分析

鞍点处梯度为零，但 Hessian 矩阵特征值有正有负。SGD 更新公式为 $x_{t+1} = x_t - \eta g_t$ （ $g_t$ 含噪声）。噪声使梯度偏离零，向 Hessian 负特征值方向移动。逃离概率与学习率、噪声相关，大学习率下噪声影响强，逃离概率高。

在 LLM 中的使用

训练 LLM（如 GPT-4）时，参数达千亿级，损失函数曲面复杂，鞍点众多。SGD 的噪声机制助其逃离鞍点。例如，训练中某层参数陷入鞍点，SGD 利用样本梯度随机性，使更新方向偏离鞍点。如在文本生成任务中，若模型生成重复文本（可能因参数在鞍点附近），SGD 的逃离特性推动参数更新，改善生成效果。

代码示例（模拟鞍点附近 SGD 更新）：

import torch  
import numpy as np  

# 定义鞍点函数 f(x, y) = x² - y²  
def f(x, y):  
    return x ** 2 - y ** 2  

# 计算梯度  
def grad_f(x, y):  
    return torch.tensor([2 * x, -2 * y])  

# 模拟SGD在鞍点(0,0)附近的更新  
x, y = 0.1, 0.1  
eta = 0.1  
num_steps = 10  
for _ in range(num_steps):  
    # 加入噪声的梯度  
    gx, gy = grad_f(x, y) + torch.normal(0, 0.1, size=(2,))  
    x -= eta * gx  
    y -= eta * gy  
    print(f"x: {x.item():.4f}, y: {y.item():.4f}")

代码解释：定义鞍点函数，梯度含噪声模拟 SGD。即使初始在鞍点附近，噪声使梯度非零，参数更新逃离鞍点，类似 LLM 训练中 SGD 借助噪声逃离鞍点。

Q31: 证明 EM 算法的单调递增性质 $\log p(X|\theta_{t+1}) \geq \log p(X|\theta_t)$

EM 算法是啥？

EM 算法用于含隐变量的概率模型参数估计，分 E 步（计算隐变量后验期望）和 M 步（最大化期望似然）。单调递增性指每次迭代后，观测数据 X 的对数似然 $\log p(X|\theta)$ 不减少。

证明过程

E 步：计算 $Q(\theta, \theta_t) = E_Z[\log p(X, Z|\theta)|X, \theta_t]$ 。
M 步： $\theta_{t+1} = \arg\max_\theta Q(\theta, \theta_t)$ 。利用 Jensen 不等式， $\begin{aligned} \log p(X|\theta) &= \log \sum_Z p(X, Z|\theta) \geq E_Z[\log p(X, Z|\theta) - \log p(Z|X, \theta_t)] \\ &= Q(\theta, \theta_t) - H(Z|X, \theta_t) \end{aligned}$ 。M 步中 $\theta_{t+1}$ 最大化 $Q(\theta, \theta_t)$ ，故 $\log p(X|\theta_{t+1}) \geq \log p(X|\theta_t)$ 。

在 LLM 中的使用

LLM 处理半监督学习任务（如用少量标注文本和大量未标注文本微调）时，EM 算法可估计隐变量（未标注文本的潜在标签）。例如，训练 BERT 进行情感分类，E 步推测未标注文本的情感标签分布，M 步更新模型参数最大化似然。每次迭代后，模型对标注数据的对数似然提升，如从影评数据中学习，使情感分类更准确。

代码示例（简单高斯混合模型 EM 算法）：

import numpy as np  

# 模拟数据（两个高斯分布混合）  
data = np.concatenate([np.random.normal(0, 1, 100), np.random.normal(3, 1, 100)])  

# 初始化参数  
mu = np.array([1, 2])  
pi = np.array([0.5, 0.5])  
sigma = np.array([1, 1])  

# EM算法迭代  
for _ in range(10):  
    # E步：计算后验概率  
    respons = np.zeros((data.shape[0], 2))  
    for k in range(2):  
        respons[:, k] = pi[k] * (1 / (sigma[k] * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((data - mu[k]) / sigma[k]) ** 2)  
    respons /= respons.sum(axis=1, keepdims=True)  

    # M步：更新参数  
    Nk = respons.sum(axis=0)  
    mu = (respons.T @ data) / Nk  
    sigma = np.sqrt((respons * (data - mu.reshape(1, -1)) ** 2).sum(axis=0) / Nk)  
    pi = Nk / data.shape[0]  

    # 计算对数似然  
    ll = 0  
    for k in range(2):  
        ll += np.sum(respons[:, k] * (np.log(pi[k]) - 0.5 * np.log(2 * np.pi * sigma[k] ** 2) - 0.5 * ((data - mu[k]) / sigma[k]) ** 2))  
    print(f"对数似然: {ll}")

代码解释：模拟高斯混合模型，EM 算法迭代更新参数，对数似然单调递增。类似地，LLM 在半监督学习中利用 EM 提升参数估计，增强对未标注数据的利用。

Q32: 推导牛顿法 $x_{t+1} = x_t - H^{-1} \nabla f(x_t)$ 的局部二次收敛率

牛顿法是啥？

牛顿法利用函数二阶导数（Hessian 矩阵 H），更新公式为 $x_{t+1} = x_t - H^{-1} \nabla f(x_t)$ 。局部二次收敛指在极小值点附近，误差 $e_t = x_t - x^*$ 满足 $e_{t+1} \approx C e_t^2$ ，收敛极快。

推导过程

在极小值点 $x^*$ 附近泰勒展开 $\nabla f(x_t) = H(x^*)(x_t - x^*) + o(|x_t - x^*|)$ ，因 $\nabla f(x^*) = 0$ 。代入牛顿法公式： $x_{t+1} - x^* = x_t - x^* - H^{-1}(x_t) H(x^*)(x_t - x^*) + o(|x_t - x^*|)$ 若 $H(x_t) \approx H(x^*)$ ，则 $e_{t+1} \approx H^{-1}(x^*) H(x^*) e_t - e_t + o(|e_t|)$ ，局部上 $e_{t+1} \approx C e_t^2$ ，得证二次收敛。

在 LLM 中的使用

LLM 微调小模型（如 BERT - base 微调至特定领域分类任务）时，参数较少，牛顿法可快速收敛。例如，医疗文本分类微调，损失函数局部近似凸，牛顿法利用二阶信息，比 SGD 更快优化。但大模型因 Hessian 计算复杂少用，此例展示小模型场景。

代码示例（简单函数牛顿法）：

import torch  

# 定义函数 f(x) = x² - 4x + 4  
def f(x):  
    return x ** 2 - 4 * x + 4  

# 计算梯度和Hessian  
def grad_f(x):  
    return torch.tensor(2 * x - 4)  
def hessian_f(x):  
    return torch.tensor(2)  

# 牛顿法迭代  
x = torch.tensor(5.0)  
for _ in range(3):  
    x -= grad_f(x) / hessian_f(x)  
    print(f"x: {x.item()}")

代码解释：函数极小值点 $x = 2$ ，牛顿法迭代中 $x_{t+1} = x_t - \nabla f(x_t)/H(x_t)$ ，快速收敛到 2，体现二次收敛，类似小模型微调中牛顿法的高效。

Q33: 验证拟牛顿法（BFGS）的对称秩一更新（SR1）公式

拟牛顿法与 SR1 公式是啥？

拟牛顿法用近似矩阵 $B_t$ 代替 Hessian，BFGS 是典型方法。SR1 更新公式为 $B_{t+1} = B_t + \frac{(y_t - B_t s_t)(y_t - B_t s_t)^T}{(y_t - B_t s_t)^T s_t}$ ，其中 $s_t = x_{t+1} - x_t$ ， $y_t = \nabla f(x_{t+1}) - \nabla f(x_t)$ ，确保 $B_{t+1}$ 对称且满足拟牛顿条件 $B_{t+1} s_t = y_t$ 。

验证过程

对称性： $B_{t+1}^T = B_t^T + \frac{(y_t - B_t s_t)(y_t - B_t s_t)^T}{(y_t - B_t s_t)^T s_t} = B_{t+1}$ （ $B_t$ 对称）。
拟牛顿条件：代入公式 $B_{t+1} s_t = B_t s_t + \frac{(y_t - B_t s_t)(y_t - B_t s_t)^T s_t}{(y_t - B_t s_t)^T s_t} = y_t$ 。

在 LLM 中的使用

LLM 优化注意力机制参数时，拟牛顿法（如 BFGS）比 SGD 快。例如，优化 Transformer 中 Q、K、V 矩阵参数，SR1 更新近似 Hessian。如训练文本生成模型，SR1 保证更新对称且符合拟牛顿条件，加速收敛，使生成文本更连贯。

代码示例（简单函数 BFGS - SR1 更新）：

import torch  

# 定义函数 f(x) = x²  
def f(x):  
    return x ** 2  

# 计算梯度  
def grad_f(x):  
    return torch.tensor(2 * x)  

# 初始化  
x0 = torch.tensor(5.0)  
x1 = x0 - 0.1 * grad_f(x0)  
s = x1 - x0  
y = grad_f(x1) - grad_f(x0)  
B = torch.tensor(2.0)  # 初始B近似Hessian  

# SR1更新  
numerator = (y - B * s).unsqueeze(0).T @ (y - B * s).unsqueeze(0)  
denominator = (y - B * s).T @ s  
B_sr1 = B + numerator / denominator  
print(f"更新后B: {B_sr1.item()}")

代码解释：定义函数 $f(x) = x^2$ ，模拟一次更新，计算 s、y，用 SR1 更新 B，验证其对称及拟牛顿条件，展示 LLM 优化中近似 Hessian 的作用。

Q34: 分析随机优化中的方差缩减技术（如 SVRG）的收敛条件

方差缩减技术与 SVRG 是啥？

SGD 方差大，收敛慢。SVRG 引入全局梯度估计减少方差，每次迭代计算当前样本梯度与全局梯度估计的差。

收敛条件分析

学习率： $\eta_t$ 满足 $\sum \eta_t = \infty$ ， $\sum \eta_t^2 < \infty$ （如 $\eta_t = \eta / \sqrt{t}$ ）。
函数光滑性： $f(x)$ 是 L - Lipschitz 光滑，梯度方差有界。
全局梯度更新：定期更新（如每 m 步），m 适中避免方差积累。

在 LLM 中的使用

训练 LLM（如 T5）处理海量数据时，SVRG 减少方差。例如，每 100 步更新全局梯度，在文本生成任务中，SVRG 使参数更新更稳定。如生成新闻摘要，SVRG 降低训练震荡，加快收敛，提升摘要质量和生成效率。

代码示例（SVRG 简单模拟）：

import torch  
import numpy as np  

# 模拟数据和模型  
data = np.random.randn(1000, 1)  
labels = 2 * data + np.random.randn(1000, 1)  
w = torch.tensor(0.0, requires_grad=True)  
eta = 0.01  
m = 100  # 全局梯度更新间隔  

# 全局梯度初始化  
grad_global = torch.tensor(0.0)  

for epoch in range(3):  
    perm = np.random.permutation(1000)  
    for i in range(0, 1000, m):  
        # 更新全局梯度  
        grad_global = 0  
        for j in range(i, min(i + m, 1000)):  
            x = torch.tensor(data[perm[j]], requires_grad=True)  
            y = torch.tensor(labels[perm[j]])  
            pred = w * x  
            loss = (pred - y) ** 2  
            loss.backward()  
            grad_global += x.grad / m  
            x.grad.zero_()  

        # SVRG更新  
        for j in range(i, min(i + m, 1000)):  
            x = torch.tensor(data[perm[j]], requires_grad=True)  
            y = torch.tensor(labels[perm[j]])  
            pred = w * x  
            loss = (pred - y) ** 2  
            loss.backward()  
            grad_local = x.grad  
            w.data -= eta * (grad_local - grad_global + grad_global)  # 简化形式  
            x.grad.zero_()  

    print(f"权重w: {w.item()}")

代码解释：模拟 SVRG 训练线性模型，每 m 步更新全局梯度，减少方差。类似地，LLM 训练中 SVRG 稳定优化，如在处理长文本时，使模型更快学习到语义表示。