目录
- 第一部分：基础理论
- 第一章：绪论------什么是优化
- 第二章：数学基础------凸性、对偶性与最优性条件
- 第三章：无约束优化基础
- 第二部分：梯度方法
- 第四章：梯度下降及其变体
- 第五章：随机梯度方法
- 第六章：自适应学习率方法
- 第三部分：高级优化方法
- 第七章：二阶方法
- 第八章：约束优化
- 第九章：非凸优化
- 第四部分：特定问题的优化
- 第十章：稀疏优化与正则化
- 第十一章：组合优化与近端方法
- 第十二章：分布式与大规模优化
- 第五部分：机器学习中的优化
- 第十三章：深度学习训练的优化
- 第十四章：优化与泛化
- 第十五章：优化在控制与信号处理中的应用
- 第十六章：完整可运行代码实现
- 附录
第一部分：基础理论
第一章：绪论------什么是优化
1.1 优化问题的一般形式
优化（optimization） 是在给定约束下，寻找使目标函数达到最小（或最大）值的决策变量。
一般形式：
minx∈Xf(x)\min_{x \in \mathcal{X}} f(x)x∈Xminf(x)
其中：
- x∈Rnx \in \mathbb{R}^nx∈Rn：决策变量（decision variable）
- f:Rn→Rf: \mathbb{R}^n \to \mathbb{R}f:Rn→R：目标函数（objective function）
- X⊆Rn\mathcal{X} \subseteq \mathbb{R}^nX⊆Rn：可行域（feasible set）
如果 X=Rn\mathcal{X} = \mathbb{R}^nX=Rn（无约束），则为无约束优化 ；否则为约束优化。
1.2 优化问题的分类
1.2.1 按目标函数性质
| 类型 | 特点 | 难度 |
|---|---|---|
| 线性 | f(x)=cTxf(x) = c^T xf(x)=cTx | 容易（多项式时间） |
| 二次 | f(x)=12xTQx+cTxf(x) = \frac{1}{2}x^T Q x + c^T xf(x)=21xTQx+cTx | 较容易 |
| 凸 | f(αx+(1−α)y)≤αf(x)+(1−α)f(y)f(\alpha x + (1-\alpha)y) \leq \alpha f(x) + (1-\alpha)f(y)f(αx+(1−α)y)≤αf(x)+(1−α)f(y) | 较容易（全局最优可求） |
| 非凸 | 不满足凸性 | 困难（可能只有局部最优） |
1.2.2 按约束类型
| 类型 | 约束形式 | 方法 |
|---|---|---|
| 无约束 | 无 | 梯度下降、牛顿法 |
| 等式约束 | h(x)=0h(x) = 0h(x)=0 | 拉格朗日乘子法 |
| 不等式约束 | g(x)≤0g(x) \leq 0g(x)≤0 | KKT 条件、内点法 |
| 整数约束 | x∈Znx \in \mathbb{Z}^nx∈Zn | 分支定界、动态规划 |
1.2.3 按变量性质
| 类型 | 变量 | 方法 |
|---|---|---|
| 连续优化 | x∈Rnx \in \mathbb{R}^nx∈Rn | 梯度方法、内点法 |
| 离散优化 | x∈Znx \in \mathbb{Z}^nx∈Zn | 分支定界、近似算法 |
| 混合整数 | 部分连续、部分整数 | 分支定界 + 松弛 |
1.3 优化的重要性
优化是现代科学和工程的核心工具：
- 机器学习：训练模型 = 最小化损失函数
- 控制论：LQR/MPC = 最优控制问题
- 信号处理 ：稀疏恢复 = ℓ1\ell_1ℓ1 最小化
- 运筹学：资源分配、调度 = 线性/整数规划
- 经济学：效用最大化、成本最小化
- 物理学：最小作用量原理
1.4 优化的历史脉络
| 年份 | 里程碑 | 贡献者 | 贡献 |
|---|---|---|---|
| 17世纪 | 微积分 | Newton, Leibniz | 极值的必要条件 |
| 18世纪 | 变分法 | Euler, Lagrange | 连续优化的数学框架 |
| 19世纪 | 线性规划 | Fourier, Kantorovich | 线性优化的单纯形法 |
| 1940s | 梯度下降 | Cauchy, Curry | 最基本的迭代方法 |
| 1950s | 凸分析 | Fenchel, Rockafellar | 凸优化的数学基础 |
| 1960s | 内点法 | Karmarkar | 多项式时间算法 |
| 1980s | 次梯度方法 | Shor, Polyak | 非光滑优化 |
| 1990s | 随机梯度 | Bottou, LeCun | 大规模机器学习优化 |
| 2010s | Adam, AdaGrad | Kingma, Duchi | 自适应学习率方法 |
| 2020s | 大模型训练 | 深度学习社区 | 分布式优化、混合精度 |
1.5 本文的组织
本文从优化的基本理论出发，逐步构建出现代优化方法的完整体系。我们特别关注：
- 凸性：为什么凸优化如此重要？
- 梯度方法：从梯度下降到 Adam 的演进
- 大规模优化：如何处理机器学习中的超大规模问题？
- 与控制和信号处理的联系：优化如何连接这些领域？
第二章：数学基础------凸性、对偶性与最优性条件
2.1 凸集
2.1.1 定义
集合 C⊆Rn\mathcal{C} \subseteq \mathbb{R}^nC⊆Rn 是凸集 ，如果对任意 x,y∈Cx, y \in \mathcal{C}x,y∈C 和 α∈0,1\alpha \in 0, 1α∈0,1：
αx+(1−α)y∈C\alpha x + (1-\alpha)y \in \mathcal{C}αx+(1−α)y∈C
几何意义：集合中任意两点的连线仍在集合内。
2.1.2 常见凸集
- 超平面 ：{x:aTx=b}\{x : a^T x = b\}{x:aTx=b}
- 半空间 ：{x:aTx≤b}\{x : a^T x \leq b\}{x:aTx≤b}
- 球 ：{x:∥x−x0∥≤r}\{x : \|x - x_0\| \leq r\}{x:∥x−x0∥≤r}
- 多面体：有限个半空间的交集
- 锥 ：{x:x=θy,θ≥0,y∈C}\{x : x = \theta y, \theta \geq 0, y \in \mathcal{C}\}{x:x=θy,θ≥0,y∈C}
2.1.3 凸集的运算
凸集在以下运算下保持凸性：
- 交集：⋂iCi\bigcap_i \mathcal{C}_i⋂iCi
- 仿射变换：AC+bA\mathcal{C} + bAC+b
- 透视变换
- 线性分式变换
2.2 凸函数
2.2.1 定义
函数 f:Rn→Rf: \mathbb{R}^n \to \mathbb{R}f:Rn→R 是凸函数 ，如果其定义域是凸集，且对任意 x,yx, yx,y 和 α∈0,1\alpha \in 0, 1α∈0,1：
f(αx+(1−α)y)≤αf(x)+(1−α)f(y)f(\alpha x + (1-\alpha)y) \leq \alpha f(x) + (1-\alpha)f(y)f(αx+(1−α)y)≤αf(x)+(1−α)f(y)
严格凸 ：上述不等式严格成立（x≠yx \neq yx=y, α∈(0,1)\alpha \in (0,1)α∈(0,1)）。
强凸 ：存在 μ>0\mu > 0μ>0 使得：
f(αx+(1−α)y)≤αf(x)+(1−α)f(y)−μ2α(1−α)∥x−y∥2f(\alpha x + (1-\alpha)y) \leq \alpha f(x) + (1-\alpha)f(y) - \frac{\mu}{2}\alpha(1-\alpha)\|x-y\|^2f(αx+(1−α)y)≤αf(x)+(1−α)f(y)−2μα(1−α)∥x−y∥2
2.2.2 凸函数的等价条件
对于可微函数，以下条件等价：
- fff 是凸函数
- f(y)≥f(x)+∇f(x)T(y−x)f(y) \geq f(x) + \nabla f(x)^T (y - x)f(y)≥f(x)+∇f(x)T(y−x)（一阶条件）
- ∇2f(x)⪰0\nabla^2 f(x) \succeq 0∇2f(x)⪰0（二阶条件，Hessian 半正定）
对于二阶可微函数，强凸 等价于 ∇2f(x)⪰μI\nabla^2 f(x) \succeq \mu I∇2f(x)⪰μI。
2.2.3 常见凸函数
| 函数 | 形式 | 凸性 |
|---|---|---|
| 线性 | aTx+ba^T x + baTx+b | 凸且凹 |
| 二次 | 12xTQx+cTx\frac{1}{2}x^T Q x + c^T x21xTQx+cTx（Q⪰0Q \succeq 0Q⪰0） | 凸 |
| 指数 | eaxe^{ax}eax | 凸 |
| 对数 | −logx-\log x−logx | 凸 |
| 范数 | ∣x∣|x|∣x∣ | 凸 |
| 最大值 | maxixi\max_i x_imaxixi | 凸 |
| 负熵 | xlogxx \log xxlogx | 凸 |
2.2.4 保凸运算
- 非负加权和：αf+βg\alpha f + \beta gαf+βg（α,β≥0\alpha, \beta \geq 0α,β≥0）
- 复合：g(f(x))g(f(x))g(f(x))（ggg 凸且非递减，fff 凸）
- 逐点最大：maxifi(x)\max_i f_i(x)maxifi(x)
- 透视：tf(x/t)t f(x/t)tf(x/t)
2.3 最优性条件
2.3.1 无约束优化
定理 2.1（一阶必要条件） ：如果 x∗x^*x∗ 是局部最小值且 fff 可微，则：
∇f(x∗)=0\nabla f(x^*) = 0∇f(x∗)=0
定理 2.2（二阶充分条件） ：如果 ∇f(x∗)=0\nabla f(x^*) = 0∇f(x∗)=0 且 ∇2f(x∗)≻0\nabla^2 f(x^*) \succ 0∇2f(x∗)≻0（正定），则 x∗x^*x∗ 是严格局部最小值。
2.3.2 约束优化------KKT 条件
考虑约束优化：
minf(x)s.t.gi(x)≤0, i=1,...,m,hj(x)=0, j=1,...,p\min f(x) \quad \text{s.t.} \quad g_i(x) \leq 0, \; i = 1,\dots,m, \quad h_j(x) = 0, \; j = 1,\dots,pminf(x)s.t.gi(x)≤0,i=1,...,m,hj(x)=0,j=1,...,p
KKT 条件（Karush-Kuhn-Tucker）：
- 原始可行性 ：gi(x∗)≤0g_i(x^*) \leq 0gi(x∗)≤0, hj(x∗)=0h_j(x^*) = 0hj(x∗)=0
- 对偶可行性 ：λi∗≥0\lambda_i^* \geq 0λi∗≥0
- 互补松弛 ：λi∗gi(x∗)=0\lambda_i^* g_i(x^*) = 0λi∗gi(x∗)=0
- 平稳性 ：∇f(x∗)+∑iλi∗∇gi(x∗)+∑jνj∗∇hj(x∗)=0\nabla f(x^*) + \sum_i \lambda_i^* \nabla g_i(x^*) + \sum_j \nu_j^* \nabla h_j(x^*) = 0∇f(x∗)+∑iλi∗∇gi(x∗)+∑jνj∗∇hj(x∗)=0
定理 2.3：对于凸优化问题，KKT 条件是最优性的充分必要条件。
2.4 对偶理论
2.4.1 拉格朗日对偶
拉格朗日函数：
L(x,λ,ν)=f(x)+∑iλigi(x)+∑jνjhj(x)L(x, \lambda, \nu) = f(x) + \sum_i \lambda_i g_i(x) + \sum_j \nu_j h_j(x)L(x,λ,ν)=f(x)+i∑λigi(x)+j∑νjhj(x)
对偶函数：
d(λ,ν)=infxL(x,λ,ν)d(\lambda, \nu) = \inf_x L(x, \lambda, \nu)d(λ,ν)=xinfL(x,λ,ν)
对偶问题：
maxλ≥0,νd(λ,ν)\max_{\lambda \geq 0, \nu} d(\lambda, \nu)λ≥0,νmaxd(λ,ν)
2.4.2 弱对偶与强对偶
弱对偶 ：d(λ∗,ν∗)≤f(x∗)d(\lambda^*, \nu^*) \leq f(x^*)d(λ∗,ν∗)≤f(x∗)（对偶值 ≤ 原始值）
强对偶 ：d(λ∗,ν∗)=f(x∗)d(\lambda^*, \nu^*) = f(x^*)d(λ∗,ν∗)=f(x∗)（对偶值 = 原始值）
Slater 条件 ：如果存在严格可行点（gi(x)<0g_i(x) < 0gi(x)<0），则凸优化问题满足强对偶。
2.4.3 对偶的几何解释
对偶问题可以理解为：在所有支撑原始问题的仿射下界中，找到最紧的那个。
第三章：无约束优化基础
3.1 优化算法的一般框架
大多数优化算法遵循迭代下降框架：
xk+1=xk+αkdkx_{k+1} = x_k + \alpha_k d_kxk+1=xk+αkdk
其中：
- dkd_kdk：搜索方向
- αk\alpha_kαk：步长（学习率）
不同的算法在选择 dkd_kdk 和 αk\alpha_kαk 的方式上有所不同。
3.2 收敛性分析
3.2.1 收敛速度
| 收敛类型 | 定义 | 例子 |
|---|---|---|
| 次线性 | ∣xk−x∗∣≤O(1/k)|x_k - x^*| \leq O(1/k)∣xk−x∗∣≤O(1/k) | 梯度下降（一般凸） |
| 线性 | ∣xk−x∗∣≤Cρk|x_k - x^*| \leq C\rho^k∣xk−x∗∣≤Cρk（ρ<1\rho < 1ρ<1） | 梯度下降（强凸） |
| 超线性 | limk→∞∣xk+1−x∗∣∣xk−x∗∣=0\lim_{k \to \infty} \frac{|x_{k+1} - x^*|}{|x_k - x^*|} = 0limk→∞∣xk−x∗∣∣xk+1−x∗∣=0 | 拟牛顿法 |
| 二次 | ∣xk+1−x∗∣≤C∣xk−x∗∣2|x_{k+1} - x^*| \leq C|x_k - x^*|^2∣xk+1−x∗∣≤C∣xk−x∗∣2 | 牛顿法（局部） |
3.2.2 条件数
条件数（condition number）衡量优化问题的"难度"：
κ=Lμ\kappa = \frac{L}{\mu}κ=μL
其中 LLL 是梯度 Lipschitz 常数，μ\muμ 是强凸系数。
- κ\kappaκ 大：问题"病态"，收敛慢
- κ\kappaκ 小：问题"良态"，收敛快
3.3 线搜索
3.3.1 精确线搜索
αk=argminα>0f(xk+αdk)\alpha_k = \arg\min_{\alpha > 0} f(x_k + \alpha d_k)αk=argα>0minf(xk+αdk)
3.3.2 Armijo 条件（回溯线搜索）
f(xk+αdk)≤f(xk)+c1α∇f(xk)Tdkf(x_k + \alpha d_k) \leq f(x_k) + c_1 \alpha \nabla f(x_k)^T d_kf(xk+αdk)≤f(xk)+c1α∇f(xk)Tdk
其中 c1∈(0,1)c_1 \in (0, 1)c1∈(0,1)（通常 c1=10−4c_1 = 10^{-4}c1=10−4）。
3.3.3 Wolfe 条件
充分下降条件 （Armijo）：
f(xk+αdk)≤f(xk)+c1α∇f(xk)Tdkf(x_k + \alpha d_k) \leq f(x_k) + c_1 \alpha \nabla f(x_k)^T d_kf(xk+αdk)≤f(xk)+c1α∇f(xk)Tdk
曲率条件 ：
∇f(xk+αdk)Tdk≥c2∇f(xk)Tdk\nabla f(x_k + \alpha d_k)^T d_k \geq c_2 \nabla f(x_k)^T d_k∇f(xk+αdk)Tdk≥c2∇f(xk)Tdk
其中 0<c1<c2<10 < c_1 < c_2 < 10<c1<c2<1。
3.4 最速下降法
3.4.1 搜索方向
最速下降方向：负梯度方向
dk=−∇f(xk)d_k = -\nabla f(x_k)dk=−∇f(xk)
这是在当前位置下降最快的方向。
3.4.2 收敛性
定理 3.1 ：对于 LLL-光滑的凸函数，最速下降法（精确线搜索）满足：
f(xk)−f(x∗)≤(L−μL+μ)2k(f(x0)−f(x∗))f(x_k) - f(x^*) \leq \left(\frac{L - \mu}{L + \mu}\right)^{2k} (f(x_0) - f(x^*))f(xk)−f(x∗)≤(L+μL−μ)2k(f(x0)−f(x∗))
收敛速度取决于条件数 κ=L/μ\kappa = L/\muκ=L/μ：
- κ\kappaκ 大 → 收敛慢（锯齿现象）
- κ\kappaκ 小 → 收敛快
3.4.3 锯齿现象
最速下降法在接近最优解时会出现"锯齿"------连续的搜索方向几乎正交，导致收敛变慢。
第二部分：梯度方法
第四章：梯度下降及其变体
4.1 梯度下降（GD）
4.1.1 算法
xk+1=xk−α∇f(xk)x_{k+1} = x_k - \alpha \nabla f(x_k)xk+1=xk−α∇f(xk)
其中 α>0\alpha > 0α>0 是学习率。
4.1.2 收敛性分析
定理 4.1（凸函数，固定步长） ：设 fff 是 LLL-光滑凸函数，步长 α≤1/L\alpha \leq 1/Lα≤1/L，则：
f(xk)−f(x∗)≤∥x0−x∗∥22αkf(x_k) - f(x^*) \leq \frac{\|x_0 - x^*\|^2}{2\alpha k}f(xk)−f(x∗)≤2αk∥x0−x∗∥2
收敛速度：O(1/k)O(1/k)O(1/k)
定理 4.2（强凸函数） ：设 fff 是 μ\muμ-强凸且 LLL-光滑的，步长 α=2/(L+μ)\alpha = 2/(L+\mu)α=2/(L+μ)，则：
f(xk)−f(x∗)≤L2(κ−1κ+1)2k∥x0−x∗∥2f(x_k) - f(x^*) \leq \frac{L}{2} \left(\frac{\kappa - 1}{\kappa + 1}\right)^{2k} \|x_0 - x^*\|^2f(xk)−f(x∗)≤2L(κ+1κ−1)2k∥x0−x∗∥2
收敛速度：线性（几何级数）
4.1.3 步长选择
- 固定步长 ：α=1/L\alpha = 1/Lα=1/L（需要知道 LLL）
- 递减步长 ：αk=1/k\alpha_k = 1/\sqrt{k}αk=1/k （凸）或 αk=1/k\alpha_k = 1/kαk=1/k（强凸）
- 线搜索：每步选择最优步长
4.2 动量方法
4.2.1 Polyak 动量（Heavy Ball）
vk=βvk−1+∇f(xk)v_k = \beta v_{k-1} + \nabla f(x_k)vk=βvk−1+∇f(xk)
xk+1=xk−αvkx_{k+1} = x_k - \alpha v_kxk+1=xk−αvk
其中 β∈[0,1)\beta \in [0, 1)β∈[0,1) 是动量系数。
物理直觉：想象一个球在山坡上滚动，动量帮助它冲过小的局部凹陷，保持向下的趋势。
4.2.2 Nesterov 加速梯度（NAG）
vk=βvk−1+∇f(xk−αβvk−1)v_k = \beta v_{k-1} + \nabla f(x_k - \alpha \beta v_{k-1})vk=βvk−1+∇f(xk−αβvk−1)
xk+1=xk−αvkx_{k+1} = x_k - \alpha v_kxk+1=xk−αvk
关键区别：NAG 在"预测位置"计算梯度，而不是在当前位置。
4.2.3 收敛性改进
定理 4.3（Nesterov 加速） ：对于 LLL-光滑凸函数，NAG 实现：
f(xk)−f(x∗)≤L∥x0−x∗∥22(k+1)2f(x_k) - f(x^*) \leq \frac{L \|x_0 - x^*\|^2}{2(k+1)^2}f(xk)−f(x∗)≤2(k+1)2L∥x0−x∗∥2
收敛速度从 O(1/k)O(1/k)O(1/k) 加速到 O(1/k2)O(1/k^2)O(1/k2)！
对于强凸函数，条件数为 κ\kappaκ 时：
- GD：O(κlog(1/ϵ))O(\kappa \log(1/\epsilon))O(κlog(1/ϵ)) 次迭代
- NAG：O(κlog(1/ϵ))O(\sqrt{\kappa} \log(1/\epsilon))O(κ log(1/ϵ)) 次迭代
4.3 共轭梯度法
4.3.1 动机
最速下降法的连续搜索方向正交，导致锯齿。共轭梯度法 选择相互共轭的方向：
diTQdj=0,i≠jd_i^T Q d_j = 0, \quad i \neq jdiTQdj=0,i=j
（对于二次函数 f(x)=12xTQx+cTxf(x) = \frac{1}{2}x^T Q x + c^T xf(x)=21xTQx+cTx）
4.3.2 算法
βk=∇f(xk)T∇f(xk)∇f(xk−1)T∇f(xk−1)\beta_k = \frac{\nabla f(x_k)^T \nabla f(x_k)}{\nabla f(x_{k-1})^T \nabla f(x_{k-1})}βk=∇f(xk−1)T∇f(xk−1)∇f(xk)T∇f(xk)
dk=−∇f(xk)+βkdk−1d_k = -\nabla f(x_k) + \beta_k d_{k-1}dk=−∇f(xk)+βkdk−1
αk=argminf(xk+αdk)\alpha_k = \arg\min f(x_k + \alpha d_k)αk=argminf(xk+αdk)
xk+1=xk+αkdkx_{k+1} = x_k + \alpha_k d_kxk+1=xk+αkdk
4.3.3 收敛性
对于 nnn 维二次函数，共轭梯度法最多 nnn 步收敛到精确解。
对于非二次函数，共轭梯度法通常比最速下降法快得多。
第五章：随机梯度方法
5.1 从批量到随机
5.1.1 有限和结构
机器学习中的优化问题通常是有限和形式：
minxf(x)=1N∑i=1Nfi(x)\min_x f(x) = \frac{1}{N} \sum_{i=1}^N f_i(x)xminf(x)=N1i=1∑Nfi(x)
其中 fi(x)f_i(x)fi(x) 是第 iii 个样本的损失。
批量梯度下降（GD）：
∇f(x)=1N∑i=1N∇fi(x)\nabla f(x) = \frac{1}{N} \sum_{i=1}^N \nabla f_i(x)∇f(x)=N1i=1∑N∇fi(x)
每步需要遍历所有 NNN 个样本------当 NNN 很大时（如百万级），这太昂贵了。
5.1.2 随机梯度下降（SGD）
xk+1=xk−αk∇fik(xk)x_{k+1} = x_k - \alpha_k \nabla f_{i_k}(x_k)xk+1=xk−αk∇fik(xk)
其中 iki_kik 是随机选择的样本索引。
关键性质 ：E∇fik(x)=∇f(x)\mathbb{E}\\nabla f_{i_k}(x) = \nabla f(x)E∇fik(x)=∇f(x)------随机梯度是真实梯度的无偏估计。
5.2 SGD 的收敛性
5.2.1 凸情况
定理 5.1 ：设 fff 是凸函数，步长 αk=O(1/k)\alpha_k = O(1/\sqrt{k})αk=O(1/k )，则 SGD 满足：
Ef(xˉk)−f(x∗)≤O(1k)\mathbb{E}f(\\bar{x}_k) - f(x^*) \leq O\left(\frac{1}{\sqrt{k}}\right)Ef(xˉk)−f(x∗)≤O(k 1)
其中 xˉk=1k∑t=1kxt\bar{x}k = \frac{1}{k}\sum{t=1}^k x_txˉk=k1∑t=1kxt 是迭代平均。
5.2.2 强凸情况
定理 5.2 ：设 fff 是 μ\muμ-强凸函数，步长 αk=O(1/(μk))\alpha_k = O(1/(\mu k))αk=O(1/(μk))，则：
Ef(xk)−f(x∗)≤O(1k)\mathbb{E}f(x_k) - f(x^*) \leq O\left(\frac{1}{k}\right)Ef(xk)−f(x∗)≤O(k1)
5.2.3 SGD vs GD
| 性质 | GD | SGD |
|---|---|---|
| 每步计算 | O(N)O(N)O(N) | O(1)O(1)O(1) |
| 收敛速度 | O(1/k)O(1/k)O(1/k) | O(1/k)O(1/\sqrt{k})O(1/k ) |
| 噪声 | 无 | 有 |
| 总计算量 | O(N/ϵ2)O(N/\epsilon^2)O(N/ϵ2) | O(1/ϵ2)O(1/\epsilon^2)O(1/ϵ2) |
当 NNN 很大时，SGD 的总计算量远小于 GD。
5.3 小批量 SGD
5.3.1 算法
xk+1=xk−αk1∣Bk∣∑i∈Bk∇fi(xk)x_{k+1} = x_k - \alpha_k \frac{1}{|B_k|} \sum_{i \in B_k} \nabla f_i(x_k)xk+1=xk−αk∣Bk∣1i∈Bk∑∇fi(xk)
其中 BkB_kBk 是大小为 bbb 的小批量（mini-batch）。
5.3.2 方差缩减
小批量梯度的方差：
Var1b∑i∈B∇fi(x)=1bVar∇fi(x)\text{Var}\left\\frac{1}{b}\\sum_{i \\in B} \\nabla f_i(x)\\right = \frac{1}{b} \text{Var}\\nabla f_i(x)Varb1i∈B∑∇fi(x)=b1Var∇fi(x)
批量越大，方差越小，但每步计算量也越大。
5.3.3 最优批量大小
存在一个临界批量大小 b∗b^*b∗，超过它增加批量带来的收益递减：
b∗≈L∥x0−x∗∥2σ2b^* \approx \frac{L \|x_0 - x^*\|^2}{\sigma^2}b∗≈σ2L∥x0−x∗∥2
其中 σ2\sigma^2σ2 是梯度方差。
5.4 方差缩减方法
5.4.1 SVRG（随机方差缩减梯度）
SVRG 维护一个"参考梯度" g~=∇f(x~)\tilde{g} = \nabla f(\tilde{x})g~=∇f(x~)，然后使用：
vk=∇fik(xk)−∇fik(x~)+g~v_k = \nabla f_{i_k}(x_k) - \nabla f_{i_k}(\tilde{x}) + \tilde{g}vk=∇fik(xk)−∇fik(x~)+g~
性质 ：Evk=∇f(xk)\mathbb{E}v_k = \nabla f(x_k)Evk=∇f(xk)（无偏），且方差随 xkx_kxk 接近 x~\tilde{x}x~ 而减小。
5.4.2 SAGA
SAGA 维护每个样本的最新梯度，用它们的平均值作为方差缩减的参考。
第六章：自适应学习率方法
6.1 为什么需要自适应学习率
固定学习率的问题：
- 所有参数使用相同的步长
- 不同参数的梯度尺度可能差异很大
- 需要手动调节学习率
自适应学习率方法为每个参数自动调整步长。
6.2 AdaGrad
6.2.1 算法
gk=∇f(xk)g_k = \nabla f(x_k)gk=∇f(xk)
Gk=Gk−1+gk⊙gkG_k = G_{k-1} + g_k \odot g_kGk=Gk−1+gk⊙gk
xk+1=xk−αGk+ϵ⊙gkx_{k+1} = x_k - \frac{\alpha}{\sqrt{G_k + \epsilon}} \odot g_kxk+1=xk−Gk+ϵ α⊙gk
其中 ⊙\odot⊙ 是逐元素乘法，ϵ\epsilonϵ 是防止除零的小常数。
6.2.2 特点
- 自适应：梯度历史大的参数，学习率自动减小
- 稀疏友好：不常更新的参数保持较大学习率
- 缺点 ：GkG_kGk 单调递增，学习率会单调递减到零
6.3 RMSProp
6.3.1 算法
gk=∇f(xk)g_k = \nabla f(x_k)gk=∇f(xk)
vk=βvk−1+(1−β)gk⊙gkv_k = \beta v_{k-1} + (1-\beta) g_k \odot g_kvk=βvk−1+(1−β)gk⊙gk
xk+1=xk−αvk+ϵ⊙gkx_{k+1} = x_k - \frac{\alpha}{\sqrt{v_k + \epsilon}} \odot g_kxk+1=xk−vk+ϵ α⊙gk
6.3.2 改进
使用指数移动平均代替累积和，解决了 AdaGrad 学习率单调递减的问题。
6.4 Adam
6.4.1 算法
Adam（Adaptive Moment Estimation） 结合了动量和自适应学习率：
gk=∇f(xk)g_k = \nabla f(x_k)gk=∇f(xk)
mk=β1mk−1+(1−β1)gk（一阶矩估计）m_k = \beta_1 m_{k-1} + (1-\beta_1) g_k \quad \text{（一阶矩估计）}mk=β1mk−1+(1−β1)gk（一阶矩估计）
vk=β2vk−1+(1−β2)gk2（二阶矩估计）v_k = \beta_2 v_{k-1} + (1-\beta_2) g_k^2 \quad \text{（二阶矩估计）}vk=β2vk−1+(1−β2)gk2（二阶矩估计）
偏差修正 ：
m^k=mk1−β1k,v^k=vk1−β2k\hat{m}_k = \frac{m_k}{1 - \beta_1^k}, \quad \hat{v}_k = \frac{v_k}{1 - \beta_2^k}m^k=1−β1kmk,v^k=1−β2kvk
更新 ：
xk+1=xk−αv^k+ϵm^kx_{k+1} = x_k - \frac{\alpha}{\sqrt{\hat{v}_k} + \epsilon} \hat{m}_kxk+1=xk−v^k +ϵαm^k
6.4.2 默认超参数
- α=0.001\alpha = 0.001α=0.001（学习率）
- β1=0.9\beta_1 = 0.9β1=0.9（一阶矩衰减率）
- β2=0.999\beta_2 = 0.999β2=0.999（二阶矩衰减率）
- ϵ=10−8\epsilon = 10^{-8}ϵ=10−8
6.4.3 Adam 的收敛性问题
问题：Adam 在某些情况下可能不收敛到最优解。
原因：自适应学习率可能导致某些参数的学习率过小。
解决方案：
- AMSGrad ：使用 vkv_kvk 的最大值代替指数移动平均
- AdamW：将权重衰减与梯度更新解耦
6.5 AdamW
6.5.1 L2 正则化 vs 权重衰减
L2 正则化 ：在损失函数中加入 λ2∥x∥2\frac{\lambda}{2}\|x\|^22λ∥x∥2
权重衰减：在更新中直接缩小参数
对于 SGD，两者等价。但对于自适应学习率方法（如 Adam），两者不等价！
6.5.2 AdamW 算法
xk+1=xk−α(m^kv^k+ϵ+λxk)x_{k+1} = x_k - \alpha \left(\frac{\hat{m}_k}{\sqrt{\hat{v}_k} + \epsilon} + \lambda x_k\right)xk+1=xk−α(v^k +ϵm^k+λxk)
关键改进 ：权重衰减项不除以 v^k\sqrt{\hat{v}_k}v^k 。
6.6 学习率调度
6.6.1 常见调度策略
| 策略 | 公式 | 特点 |
|---|---|---|
| 常数 | αk=α0\alpha_k = \alpha_0αk=α0 | 简单 |
| 阶梯衰减 | αk=α0⋅γ⌊k/s⌋\alpha_k = \alpha_0 \cdot \gamma^{\lfloor k/s \rfloor}αk=α0⋅γ⌊k/s⌋ | 每 sss 步乘以 γ\gammaγ |
| 余弦退火 | αk=αmin+α0−αmin2(1+cos(πk/T))\alpha_k = \alpha_{\min} + \frac{\alpha_0 - \alpha_{\min}}{2}(1 + \cos(\pi k/T))αk=αmin+2α0−αmin(1+cos(πk/T)) | 平滑衰减 |
| 线性预热 | αk=α0⋅k/w\alpha_k = \alpha_0 \cdot k/wαk=α0⋅k/w（k≤wk \leq wk≤w） | 训练初期 |
| 1-cycle | 先增后减 | 超级收敛 |
6.6.2 预热（Warm-up）
为什么需要预热？
- 训练初期，参数远离最优解，梯度很大且方差大
- 大学习率可能导致不稳定
- 先用小学习率稳定训练，再逐渐增大学习率
第三部分：高级优化方法
第七章：二阶方法
7.1 牛顿法
7.1.1 算法
xk+1=xk−∇2f(xk)−1∇f(xk)x_{k+1} = x_k - \\nabla\^2 f(x_k)^{-1} \nabla f(x_k)xk+1=xk−∇2f(xk)−1∇f(xk)
其中 ∇2f(xk)\nabla^2 f(x_k)∇2f(xk) 是 Hessian 矩阵。
7.1.2 收敛性
定理 7.1 ：在最优解附近，牛顿法具有二次收敛速度：
∥xk+1−x∗∥≤C∥xk−x∗∥2\|x_{k+1} - x^*\| \leq C \|x_k - x^*\|^2∥xk+1−x∗∥≤C∥xk−x∗∥2
7.1.3 优缺点
优点：
- 收敛速度快（二次）
- 对条件数不敏感
- 仿射不变性
缺点：
- 每步需要 O(n3)O(n^3)O(n3) 计算（矩阵求逆）
- 需要存储 Hessian（O(n2)O(n^2)O(n2) 空间）
- 非凸问题中 Hessian 可能不正定
7.2 拟牛顿法
7.2.1 基本思想
用低秩更新近似 Hessian（或其逆），避免直接计算和存储。
7.2.2 BFGS 算法
维护 Hessian 逆的近似 Bk≈∇2f(xk)−1B_k \approx \\nabla\^2 f(x_k)^{-1}Bk≈∇2f(xk)−1：
sk=xk+1−xks_k = x_{k+1} - x_ksk=xk+1−xk
yk=∇f(xk+1)−∇f(xk)y_k = \nabla f(x_{k+1}) - \nabla f(x_k)yk=∇f(xk+1)−∇f(xk)
Bk+1=(I−ρkskykT)Bk(I−ρkykskT)+ρkskskTB_{k+1} = (I - \rho_k s_k y_k^T) B_k (I - \rho_k y_k s_k^T) + \rho_k s_k s_k^TBk+1=(I−ρkskykT)Bk(I−ρkykskT)+ρkskskT
其中 ρk=1/(ykTsk)\rho_k = 1/(y_k^T s_k)ρk=1/(ykTsk)。
7.2.3 L-BFGS
L-BFGS（Limited-memory BFGS） 只存储最近 mmm 步的 sks_ksk 和 yky_kyk（mmm 通常 5-20），通过两遍循环递推计算搜索方向。
每步计算量：O(mn)O(mn)O(mn)（vs BFGS 的 O(n2)O(n^2)O(n2)）
7.3 自然梯度
7.3.1 动机
标准梯度在参数空间中是最速下降方向，但这个方向在概率分布空间中不一定最优。
7.3.2 Fisher 信息矩阵
Fisher 信息矩阵：
F=E∇logp(x∣θ)∇logp(x∣θ)TF = \mathbb{E}\\nabla \\log p(x\|\\theta) \\nabla \\log p(x\|\\theta)\^TF=E∇logp(x∣θ)∇logp(x∣θ)T
它衡量了参数变化对概率分布的影响。
7.3.3 自然梯度方向
dk=−F−1∇f(xk)d_k = -F^{-1} \nabla f(x_k)dk=−F−1∇f(xk)
性质 ：自然梯度是仿射不变的------对参数做线性变换不改变优化轨迹。
7.3.4 K-FAC
K-FAC（Kronecker-Factored Approximate Curvature） 将 Fisher 矩阵近似为 Kronecker 积：
F≈A⊗BF \approx A \otimes BF≈A⊗B
这使得求逆从 O(n3)O(n^3)O(n3) 降到 O(n3/2)O(n^{3/2})O(n3/2)。
第八章：约束优化
8.1 拉格朗日方法
8.1.1 等式约束
minf(x)s.t.h(x)=0\min f(x) \quad \text{s.t.} \quad h(x) = 0minf(x)s.t.h(x)=0
拉格朗日函数：
L(x,ν)=f(x)+νTh(x)L(x, \nu) = f(x) + \nu^T h(x)L(x,ν)=f(x)+νTh(x)
最优性条件：
∇xL=∇f(x)+Jh(x)Tν=0\nabla_x L = \nabla f(x) + J_h(x)^T \nu = 0∇xL=∇f(x)+Jh(x)Tν=0
∇νL=h(x)=0\nabla_\nu L = h(x) = 0∇νL=h(x)=0
8.1.2 不等式约束
minf(x)s.t.g(x)≤0\min f(x) \quad \text{s.t.} \quad g(x) \leq 0minf(x)s.t.g(x)≤0
KKT 条件：
∇f(x)+λ∇g(x)=0\nabla f(x) + \lambda \nabla g(x) = 0∇f(x)+λ∇g(x)=0
λ≥0,g(x)≤0,λg(x)=0\lambda \geq 0, \quad g(x) \leq 0, \quad \lambda g(x) = 0λ≥0,g(x)≤0,λg(x)=0
8.2 惩罚方法
8.2.1 二次惩罚
将约束优化转化为无约束优化：
minf(x)+ρ2∥h(x)∥2\min f(x) + \frac{\rho}{2} \|h(x)\|^2minf(x)+2ρ∥h(x)∥2
当 ρ→∞\rho \to \inftyρ→∞ 时，解收敛到原始问题的解。
8.2.2 增广拉格朗日法
结合拉格朗日方法和惩罚方法：
Lρ(x,ν)=f(x)+νTh(x)+ρ2∥h(x)∥2L_\rho(x, \nu) = f(x) + \nu^T h(x) + \frac{\rho}{2} \|h(x)\|^2Lρ(x,ν)=f(x)+νTh(x)+2ρ∥h(x)∥2
ADMM（交替方向乘子法） 是增广拉格朗日法的重要变体。
8.3 内点法
8.3.1 障碍函数
用障碍函数替代不等式约束：
minf(x)−1t∑ilog(−gi(x))\min f(x) - \frac{1}{t} \sum_i \log(-g_i(x))minf(x)−t1i∑log(−gi(x))
当 t→∞t \to \inftyt→∞ 时，障碍函数趋近于原始问题。
8.3.2 路径跟踪
从一个可行点出发，沿着"中心路径"（central path）逐步增大 ttt，跟踪最优解。
8.4 投影方法
8.4.1 投影梯度法
xk+1=ΠX(xk−α∇f(xk))x_{k+1} = \Pi_{\mathcal{X}}(x_k - \alpha \nabla f(x_k))xk+1=ΠX(xk−α∇f(xk))
其中 ΠX\Pi_{\mathcal{X}}ΠX 是到可行域 X\mathcal{X}X 的投影。
8.4.2 Frank-Wolfe 算法
当投影困难但线性优化容易时：
sk=argmins∈XsT∇f(xk)s_k = \arg\min_{s \in \mathcal{X}} s^T \nabla f(x_k)sk=args∈XminsT∇f(xk)
xk+1=xk+γk(sk−xk)x_{k+1} = x_k + \gamma_k (s_k - x_k)xk+1=xk+γk(sk−xk)
第九章：非凸优化
9.1 非凸优化的挑战
9.1.1 局部最小值
非凸函数可能有多个局部最小值，梯度下降只能保证收敛到局部最小值。
9.1.2 鞍点
鞍点是梯度为零但不是局部最小值的点：
∇f(x)=0,∇2f(x) 有正负特征值\nabla f(x) = 0, \quad \nabla^2 f(x) \text{ 有正负特征值}∇f(x)=0,∇2f(x) 有正负特征值
在高维空间中，鞍点比局部最小值更常见。
9.1.3 平坦区域
损失函数可能存在大面积的平坦区域，梯度很小，导致收敛极慢。
9.2 逃离鞍点
9.2.1 随机扰动
xk+1=xk−α∇f(xk)+ηkx_{k+1} = x_k - \alpha \nabla f(x_k) + \eta_kxk+1=xk−α∇f(xk)+ηk
其中 ηk\eta_kηk 是随机噪声。噪声帮助算法逃离鞍点。
9.2.2 负曲率方向
如果 Hessian 有负特征值，沿着对应的特征向量方向移动可以逃离鞍点。
9.3 深度学习中的非凸优化
9.3.1 损失景观
深度神经网络的损失函数具有复杂的非凸结构。但实践中，SGD 通常能找到好的解。
可能的解释：
- 高维空间中，鞍点比局部最小值更常见
- 好的局部最小值之间有"低损失通道"相连
- 过参数化使得损失景观更"平坦"
9.3.2 过参数化
当模型参数远多于训练样本时（过参数化），损失函数存在大量全局最小值。SGD 倾向于找到平坦的最小值------这与泛化能力相关。
第四部分：特定问题的优化
第十章：稀疏优化与正则化
10.1 稀疏优化问题
10.1.1 ℓ0\ell_0ℓ0 问题
minx∥x∥0s.t.Ax=b\min_x \|x\|_0 \quad \text{s.t.} \quad Ax = bxmin∥x∥0s.t.Ax=b
其中 ∥x∥0\|x\|_0∥x∥0 是非零元素个数。这是 NP-hard 问题。
10.1.2 ℓ1\ell_1ℓ1 松弛
minx∥x∥1s.t.Ax=b\min_x \|x\|_1 \quad \text{s.t.} \quad Ax = bxmin∥x∥1s.t.Ax=b
定理 10.1（Candès, Romberg, Tao, 2006） ：在 RIP 条件下，ℓ1\ell_1ℓ1 最小化与 ℓ0\ell_0ℓ0 最小化等价。
10.2 正则化方法
10.2.1 常见正则化
| 正则化 | 形式 | 效果 |
|---|---|---|
| ℓ1\ell_1ℓ1（Lasso） | λ∣x∣1\lambda |x|_1λ∣x∣1 | 稀疏性 |
| ℓ2\ell_2ℓ2（Ridge） | λ∣x∣22\lambda |x|_2^2λ∣x∣22 | 小权重 |
| Elastic Net | α∣x∣1+(1−α)∣x∣22\alpha |x|_1 + (1-\alpha) |x|_2^2α∣x∣1+(1−α)∣x∣22 | 稀疏 + 小权重 |
| 核范数 | λ∣X∣∗\lambda |X|_*λ∣X∣∗ | 低秩 |
| TV | λ∣∇x∣1\lambda |\nabla x|_1λ∣∇x∣1 | 分段常数 |
10.2.2 偏差-方差权衡
- 小 λ\lambdaλ：低偏差，高方差（过拟合）
- 大 λ\lambdaλ：高偏差，低方差（欠拟合）
- 最优 λ\lambdaλ：通过交叉验证选择
10.3 近端梯度法
10.3.1 近端算子
对于函数 g(x)g(x)g(x)，近端算子定义为：
proxg(v)=argminx{g(x)+12∥x−v∥2}\text{prox}_{g}(v) = \arg\min_x \left\{g(x) + \frac{1}{2}\|x - v\|^2\right\}proxg(v)=argxmin{g(x)+21∥x−v∥2}
10.3.2 常见近端算子
- ℓ1\ell_1ℓ1 范数（软阈值）：
proxλ∥⋅∥1(v)i=sign(vi)max(∣vi∣−λ,0)\\text{prox}_{\\lambda\\\|\\cdot\\\|_1}(v)_i = \text{sign}(v_i) \max(|v_i| - \lambda, 0)proxλ∥⋅∥1(v)i=sign(vi)max(∣vi∣−λ,0)
- ℓ2\ell_2ℓ2 范数（收缩）：
proxλ∥⋅∥2(v)=(1−λ∥v∥)+v\text{prox}_{\lambda\|\cdot\|2}(v) = \left(1 - \frac{\lambda}{\|v\|}\right)+ vproxλ∥⋅∥2(v)=(1−∥v∥λ)+v
10.3.3 ISTA（迭代软阈值算法）
xk+1=proxαλ∥⋅∥1(xk−α∇f(xk))x_{k+1} = \text{prox}_{\alpha\lambda\|\cdot\|_1}(x_k - \alpha \nabla f(x_k))xk+1=proxαλ∥⋅∥1(xk−α∇f(xk))
10.3.4 FISTA（快速 ISTA）
加入 Nesterov 动量：
yk=xk+tk−1−1tk(xk−xk−1)y_k = x_k + \frac{t_{k-1}-1}{t_k}(x_k - x_{k-1})yk=xk+tktk−1−1(xk−xk−1)
xk+1=proxαλ∥⋅∥1(yk−α∇f(yk))x_{k+1} = \text{prox}_{\alpha\lambda\|\cdot\|_1}(y_k - \alpha \nabla f(y_k))xk+1=proxαλ∥⋅∥1(yk−α∇f(yk))
tk+1=1+1+4tk22t_{k+1} = \frac{1 + \sqrt{1 + 4t_k^2}}{2}tk+1=21+1+4tk2
收敛速度从 O(1/k)O(1/k)O(1/k) 加速到 O(1/k2)O(1/k^2)O(1/k2)。
第十一章：组合优化与近端方法
11.1 组合优化
11.1.1 问题形式
minx∈Sf(x)\min_{x \in \mathcal{S}} f(x)x∈Sminf(x)
其中 S\mathcal{S}S 是离散集合（如 {0,1}n\{0,1\}^n{0,1}n）。
11.1.2 NP-hard 问题
许多组合优化问题是 NP-hard 的：
- 旅行商问题（TSP）
- 图着色
- 背包问题
- 整数规划
11.1.3 近似算法
对于 NP-hard 问题，寻找近似解：
松弛：将离散约束松弛为连续约束，求解后舍入。
近似比：近似算法的解与最优解的比值上界。
11.2 ADMM
11.2.1 问题形式
minx,zf(x)+g(z)s.t.Ax+Bz=c\min_{x,z} f(x) + g(z) \quad \text{s.t.} \quad Ax + Bz = cx,zminf(x)+g(z)s.t.Ax+Bz=c
11.2.2 ADMM 算法
xk+1=argminx{f(x)+ρ2∥Ax+Bzk−c+uk∥2}x_{k+1} = \arg\min_x \left\{f(x) + \frac{\rho}{2}\|Ax + Bz_k - c + u_k\|^2\right\}xk+1=argxmin{f(x)+2ρ∥Ax+Bzk−c+uk∥2}
zk+1=argminz{g(z)+ρ2∥Axk+1+Bz−c+uk∥2}z_{k+1} = \arg\min_z \left\{g(z) + \frac{\rho}{2}\|Ax_{k+1} + Bz - c + u_k\|^2\right\}zk+1=argzmin{g(z)+2ρ∥Axk+1+Bz−c+uk∥2}
uk+1=uk+Axk+1+Bzk+1−cu_{k+1} = u_k + Ax_{k+1} + Bz_{k+1} - cuk+1=uk+Axk+1+Bzk+1−c
11.2.3 收敛性
ADMM 在凸问题上收敛，但速度可能较慢（O(1/k)O(1/k)O(1/k)）。
第十二章：分布式与大规模优化
12.1 分布式优化的动机
12.1.1 数据规模
现代机器学习的数据集规模：
- ImageNet：128 万张图片
- Common Crawl：TB 级文本
- 推荐系统：十亿级样本
单机无法处理如此大规模的数据。
12.1.2 计算规模
大语言模型的参数量：
- GPT-3：1750 亿
- GPT-4：万亿级（传闻）
需要分布式训练才能在合理时间内完成。
12.2 数据并行
12.2.1 同步 SGD
每个 worker 计算本地梯度，然后同步平均：
gk=1W∑w=1Wgk(w)g_k = \frac{1}{W} \sum_{w=1}^W g_k^{(w)}gk=W1w=1∑Wgk(w)
xk+1=xk−αgkx_{k+1} = x_k - \alpha g_kxk+1=xk−αgk
问题：需要等待最慢的 worker（straggler 问题）。
12.2.2 异步 SGD
每个 worker 计算完梯度后立即更新，不等待其他 worker。
问题：梯度过时（stale gradient），可能导致不稳定。
12.2.3 梯度压缩
减少通信量：
- 梯度量化：用低精度表示梯度
- 梯度稀疏化：只传输大的梯度分量
- 误差反馈：累积量化误差
12.3 模型并行
12.3.1 张量并行
将矩阵运算分割到多个设备上。
12.3.2 流水线并行
将模型的不同层分配到不同设备上，形成流水线。
12.3.3 混合并行
结合数据并行和模型并行。
12.4 联邦学习
12.4.1 问题设置
多个客户端各自持有本地数据，协作训练全局模型，但不共享原始数据。
12.4.2 FedAvg 算法
- 服务器将全局模型广播给客户端
- 每个客户端在本地数据上训练若干轮
- 客户端将模型更新上传给服务器
- 服务器聚合更新
第五部分：机器学习中的优化
第十三章：深度学习训练的优化
13.1 深度学习优化的特殊性
13.1.1 高度非凸
深度神经网络的损失函数是高度非凸的，存在大量鞍点和局部最小值。
13.1.2 过参数化
参数量远大于样本量，损失函数存在大量全局最小值。
13.1.3 噪声梯度
小批量 SGD 引入的噪声实际上有助于泛化。
13.2 初始化策略
13.2.1 Xavier/Glorot 初始化
W∼N(0,2nin+nout)W \sim \mathcal{N}\left(0, \frac{2}{n_{\text{in}} + n_{\text{out}}}\right)W∼N(0,nin+nout2)
保持前向传播中激活值的方差稳定。
13.2.2 He 初始化
W∼N(0,2nin)W \sim \mathcal{N}\left(0, \frac{2}{n_{\text{in}}}\right)W∼N(0,nin2)
适用于 ReLU 激活函数。
13.2.3 正交初始化
WWW 是正交矩阵，保持梯度范数稳定。
13.3 梯度裁剪
13.3.1 问题
梯度爆炸导致训练不稳定。
13.3.2 方法
按范数裁剪：
g←{gif ∥g∥≤ττg∥g∥if ∥g∥>τg \leftarrow \begin{cases} g & \text{if } \|g\| \leq \tau \\ \tau \frac{g}{\|g\|} & \text{if } \|g\| > \tau \end{cases}g←{gτ∥g∥gif ∥g∥≤τif ∥g∥>τ
按值裁剪：
gi←clip(gi,−τ,τ)g_i \leftarrow \text{clip}(g_i, -\tau, \tau)gi←clip(gi,−τ,τ)
13.4 混合精度训练
13.4.1 基本思想
- 前向传播：FP16（快）
- 反向传播：FP16（快）
- 权重更新：FP32（精确）
13.4.2 损失缩放
将损失乘以一个大数，防止 FP16 下梯度下溢。
13.5 学习率预热与余弦退火
13.5.1 预热阶段
前 www 步线性增加学习率：
αk=αmax⋅kw,k≤w\alpha_k = \alpha_{\max} \cdot \frac{k}{w}, \quad k \leq wαk=αmax⋅wk,k≤w
13.5.2 余弦退火
αk=αmin+αmax−αmin2(1+cos(πkT))\alpha_k = \alpha_{\min} + \frac{\alpha_{\max} - \alpha_{\min}}{2}\left(1 + \cos\left(\frac{\pi k}{T}\right)\right)αk=αmin+2αmax−αmin(1+cos(Tπk))
第十四章：优化与泛化
14.1 优化景观与泛化
14.1.1 平坦最小值 vs 尖锐最小值
经验观察 ：SGD 倾向于找到平坦的最小值，这些最小值通常泛化更好。
直觉：平坦最小值对参数扰动不敏感，因此对测试数据的变化也不敏感。
14.1.2 隐式正则化
SGD 本身有隐式正则化效果------它倾向于找到某些特殊类型的解：
- 对于线性模型：最小范数解
- 对于深度网络：某种"简单"的解
14.2 批量大小与泛化
14.2.1 大批量训练的问题
大批量训练虽然加快收敛，但可能损害泛化。
原因：大批量减少了梯度噪声，可能丢失隐式正则化的效果。
14.2.2 解决方案
- 学习率缩放：大批量使用大学习率
- 预热：大批量训练需要更长的预热
- 噪声注入：人为增加梯度噪声
14.3 正则化与优化
14.3.1 权重衰减
权重衰减 = ℓ2\ell_2ℓ2 正则化（对于 SGD），控制模型复杂度。
14.3.2 Dropout
随机丢弃神经元，等价于某种形式的正则化。
14.3.3 数据增强
增加训练数据的多样性，等价于某种形式的正则化。
第十五章：优化在控制与信号处理中的应用
15.1 控制中的优化
15.1.1 LQR 作为优化问题
LQR 最小化：
J=∫0∞(xTQx+uTRu)dtJ = \int_0^{\infty} (x^T Q x + u^T R u) dtJ=∫0∞(xTQx+uTRu)dt
这是一个无限维的凸优化问题，通过动态规划求解。
15.1.2 MPC 作为优化问题
MPC 在每个时刻求解一个有限时域的优化问题：
min∑i=0N−1(xiTQxi+uiTRui)\min \sum_{i=0}^{N-1} (x_i^T Q x_i + u_i^T R u_i)mini=0∑N−1(xiTQxi+uiTRui)
这是一个二次规划问题。
15.1.3 系统辨识
从数据中学习系统模型 = 最小化预测误差：
minA,B∑k∥xk+1−Axk−Buk∥2\min_{A,B} \sum_k \|x_{k+1} - Ax_k - Bu_k\|^2A,Bmink∑∥xk+1−Axk−Buk∥2
这是一个最小二乘问题。
15.2 信号处理中的优化
15.2.1 稀疏恢复
minx∥x∥1s.t.y=Φx\min_x \|x\|_1 \quad \text{s.t.} \quad y = \Phi xxmin∥x∥1s.t.y=Φx
这是一个线性规划问题。
15.2.2 自适应滤波
LMS 最小化均方误差：
minwE∣d−wTx∣2\min_w \mathbb{E}\|d - w\^T x\|\^2wminE∣d−wTx∣2
这是一个随机梯度问题。
15.2.3 谱估计
AR 模型参数通过最小化预测误差得到：
mina∑n∣xn+∑kakxn−k∣2\min_a \sum_n |xn + \sum_k a_k xn-k|^2aminn∑∣xn+k∑akxn−k∣2
这是一个Yule-Walker方程问题。
15.3 SSM 训练中的优化
15.3.1 SSM 训练作为优化
SSM 的训练最小化预测损失：
minA,B,C,Δ∑tL(yt,y^t)\min_{A,B,C,\Delta} \sum_t \mathcal{L}(y_t, \hat{y}_t)A,B,C,Δmint∑L(yt,y^t)
这是一个非凸优化问题。
15.3.2 HiPPO 初始化
HiPPO 矩阵提供了 AAA 的"好的"初始点------这类似于控制论中的极点配置思想。
15.3.3 选择性机制的优化视角
Mamba 的选择性机制（输入依赖的参数）可以理解为在每个时刻求解一个"局部"优化问题。
第十六章：完整可运行代码实现
16.1 梯度下降方法比较
python
"""
梯度下降方法的完整比较。
包含: GD, Momentum, NAG, 共轭梯度。
"""
import numpy as np
def gradient_descent(f, grad_f, x0, alpha=0.01, max_iter=1000, tol=1e-6):
"""标准梯度下降。"""
x = x0.copy()
history = [x.copy()]
for k in range(max_iter):
g = grad_f(x)
x = x - alpha * g
history.append(x.copy())
if np.linalg.norm(g) < tol:
break
return x, history
def momentum_gd(f, grad_f, x0, alpha=0.01, beta=0.9, max_iter=1000, tol=1e-6):
"""Polyak 动量梯度下降。"""
x = x0.copy()
v = np.zeros_like(x)
history = [x.copy()]
for k in range(max_iter):
g = grad_f(x)
v = beta * v + g
x = x - alpha * v
history.append(x.copy())
if np.linalg.norm(g) < tol:
break
return x, history
def nesterov_gd(f, grad_f, x0, alpha=0.01, beta=0.9, max_iter=1000, tol=1e-6):
"""Nesterov 加速梯度下降。"""
x = x0.copy()
v = np.zeros_like(x)
history = [x.copy()]
for k in range(max_iter):
# 在"预测位置"计算梯度
g = grad_f(x - alpha * beta * v)
v = beta * v + g
x = x - alpha * v
history.append(x.copy())
if np.linalg.norm(g) < tol:
break
return x, history
def conjugate_gradient(f, grad_f, x0, max_iter=1000, tol=1e-6):
"""非线性共轭梯度法 (Fletcher-Reeves)。"""
x = x0.copy()
g = grad_f(x)
d = -g
history = [x.copy()]
for k in range(max_iter):
# 线搜索 (简单回溯)
alpha = line_search(f, grad_f, x, d)
x_new = x + alpha * d
g_new = grad_f(x_new)
# Fletcher-Reeves 公式
beta = np.dot(g_new, g_new) / (np.dot(g, g) + 1e-10)
d = -g_new + beta * d
x = x_new
g = g_new
history.append(x.copy())
if np.linalg.norm(g) < tol:
break
return x, history
def line_search(f, grad_f, x, d, alpha=1.0, c=1e-4, rho=0.5):
"""Armijo 回溯线搜索。"""
fx = f(x)
gd = np.dot(grad_f(x), d)
while f(x + alpha * d) > fx + c * alpha * gd:
alpha *= rho
if alpha < 1e-10:
break
return alpha
def demonstrate_optimization():
"""演示不同优化方法。"""
print("=" * 60)
print("梯度下降方法比较")
print("=" * 60)
# Rosenbrock 函数
# f(x,y) = (1-x)^2 + 100(y-x^2)^2
def f(x):
return (1 - x[0])**2 + 100 * (x[1] - x[0]**2)**2
def grad_f(x):
dfdx = -2*(1-x[0]) + 200*(x[1]-x[0]**2)*(-2*x[0])
dfdy = 200*(x[1]-x[0]**2)
return np.array([dfdx, dfdy])
x0 = np.array([-1.0, 1.0])
print(f"\nRosenbrock 函数: f(x,y) = (1-x)² + 100(y-x²)²")
print(f"最优解: (1, 1)")
print(f"初始点: {x0}")
# 不同方法
methods = {
'GD (α=0.001)': lambda: gradient_descent(f, grad_f(x0), x0, alpha=0.001, max_iter=10000),
'Momentum': lambda: momentum_gd(f, grad_f(x0), x0, alpha=0.001, max_iter=10000),
'NAG': lambda: nesterov_gd(f, grad_f(x0), x0, alpha=0.001, max_iter=10000),
}
for name, method in methods.items():
x_opt, history = method()
final_f = f(x_opt)
n_iter = len(history) - 1
print(f"\n {name}:")
print(f" 迭代次数: {n_iter}")
print(f" 最终解: ({x_opt[0]:.6f}, {x_opt[1]:.6f})")
print(f" 最终函数值: {final_f:.6f}")
if __name__ == "__main__":
demonstrate_optimization()16.2 Adam 优化器实现
python
"""
Adam 优化器的完整实现。
包含: Adam, AdamW, 学习率调度。
"""
import numpy as np
class Adam:
"""Adam 优化器。"""
def __init__(self, lr=0.001, beta1=0.9, beta2=0.999, eps=1e-8):
self.lr = lr
self.beta1 = beta1
self.beta2 = beta2
self.eps = eps
self.m = None # 一阶矩
self.v = None # 二阶矩
self.t = 0
def update(self, params, grads):
"""更新参数。"""
if self.m is None:
self.m = [np.zeros_like(p) for p in params]
self.v = [np.zeros_like(p) for p in params]
self.t += 1
for i in range(len(params)):
# 更新矩估计
self.m[i] = self.beta1 * self.m[i] + (1 - self.beta1) * grads[i]
self.v[i] = self.beta2 * self.v[i] + (1 - self.beta2) * grads[i]**2
# 偏差修正
m_hat = self.m[i] / (1 - self.beta1**self.t)
v_hat = self.v[i] / (1 - self.beta2**self.t)
# 更新参数
params[i] -= self.lr * m_hat / (np.sqrt(v_hat) + self.eps)
return params
class AdamW:
"""AdamW 优化器 (解耦权重衰减)。"""
def __init__(self, lr=0.001, beta1=0.9, beta2=0.999, eps=1e-8, weight_decay=0.01):
self.lr = lr
self.beta1 = beta1
self.beta2 = beta2
self.eps = eps
self.weight_decay = weight_decay
self.m = None
self.v = None
self.t = 0
def update(self, params, grads):
if self.m is None:
self.m = [np.zeros_like(p) for p in params]
self.v = [np.zeros_like(p) for p in params]
self.t += 1
for i in range(len(params)):
self.m[i] = self.beta1 * self.m[i] + (1 - self.beta1) * grads[i]
self.v[i] = self.beta2 * self.v[i] + (1 - self.beta2) * grads[i]**2
m_hat = self.m[i] / (1 - self.beta1**self.t)
v_hat = self.v[i] / (1 - self.beta2**self.t)
# 解耦权重衰减
params[i] -= self.lr * (m_hat / (np.sqrt(v_hat) + self.eps) +
self.weight_decay * params[i])
return params
class CosineAnnealingScheduler:
"""余弦退火学习率调度器。"""
def __init__(self, lr_max, lr_min, T):
self.lr_max = lr_max
self.lr_min = lr_min
self.T = T
def get_lr(self, t):
return self.lr_min + 0.5 * (self.lr_max - self.lr_min) * (1 + np.cos(np.pi * t / self.T))
def demonstrate_adam():
"""演示 Adam 优化器。"""
print("=" * 60)
print("Adam 优化器演示")
print("=" * 60)
np.random.seed(42)
# 简单的二次函数
# f(x) = 0.5 * x^T Q x + c^T x
n = 10
Q = np.random.randn(n, n)
Q = Q.T @ Q + np.eye(n) # 正定
c = np.random.randn(n)
def f(x):
return 0.5 * x @ Q @ x + c @ x
def grad_f(x):
return Q @ x + c
# 最优解
x_opt = -np.linalg.solve(Q, c)
f_opt = f(x_opt)
print(f"\n二次函数优化 (n={n}):")
print(f" 最优函数值: {f_opt:.6f}")
# 测试不同优化器
optimizers = {
'Adam (lr=0.01)': Adam(lr=0.01),
'Adam (lr=0.001)': Adam(lr=0.001),
'AdamW (lr=0.01, wd=0.01)': AdamW(lr=0.01, weight_decay=0.01),
}
for name, optimizer in optimizers.items():
x = np.random.randn(n)
history = [f(x)]
for _ in range(500):
grads = [grad_f(x)]
params = [x]
params = optimizer.update(params, grads)
x = params[0]
history.append(f(x))
final_f = history[-1]
print(f"\n {name}:")
print(f" 最终函数值: {final_f:.6f}")
print(f" 与最优的差距: {final_f - f_opt:.6f}")
if __name__ == "__main__":
demonstrate_adam()16.3 约束优化
python
"""
约束优化方法的完整实现。
包含: 拉格朗日乘子法, 惩罚法, 投影梯度法。
"""
import numpy as np
def lagrange_multiplier(Q, c, A, b):
"""等式约束二次规划的拉格朗日乘子法。
min 0.5 * x^T Q x + c^T x
s.t. A x = b
使用 KKT 条件求解。
"""
n = len(c)
m = len(b)
# KKT 系统
# [Q A^T] [x] [-c]
# [A 0 ] [λ] = [b ]
KKT = np.block([[Q, A.T], [A, np.zeros((m, m))]])
rhs = np.concatenate([-c, b])
sol = np.linalg.solve(KKT, rhs)
x = sol[:n]
lam = sol[n:]
return x, lam
def penalty_method(f, grad_f, h, grad_h, x0, rho_init=1.0, rho_factor=10.0,
max_outer=20, max_inner=100):
"""二次惩罚法。
min f(x) s.t. h(x) = 0
等价于 min f(x) + (rho/2) * ||h(x)||^2
"""
x = x0.copy()
rho = rho_init
history = [x.copy()]
for outer in range(max_outer):
# 内层优化 (梯度下降)
for inner in range(max_inner):
# 惩罚函数的梯度
h_val = h(x)
g = grad_f(x) + rho * h_val * grad_h(x)
# 简单梯度步
alpha = 0.01 / (1 + outer)
x = x - alpha * g
history.append(x.copy())
# 增加惩罚系数
rho *= rho_factor
# 检查约束满足程度
constraint_violation = np.abs(h(x))
if constraint_violation < 1e-6:
break
return x, history
def projected_gradient(f, grad_f, proj, x0, alpha=0.01, max_iter=1000):
"""投影梯度法。
min f(x) s.t. x in C
"""
x = x0.copy()
history = [x.copy()]
for k in range(max_iter):
g = grad_f(x)
x = proj(x - alpha * g)
history.append(x.copy())
return x, history
def demonstrate_constrained_optimization():
"""演示约束优化方法。"""
print("=" * 60)
print("约束优化演示")
print("=" * 60)
# 二次规划问题
# min 0.5 * (x1^2 + x2^2) - x1 - x2
# s.t. x1 + x2 = 1
Q = np.eye(2)
c = np.array([-1, -1])
A = np.array([[1, 1]])
b = np.array([1])
# 拉格朗日乘子法
x_lag, lam_lag = lagrange_multiplier(Q, c, A, b)
f_lag = 0.5 * x_lag @ Q @ x_lag + c @ x_lag
print(f"\n等式约束二次规划:")
print(f" min 0.5*(x1² + x2²) - x1 - x2")
print(f" s.t. x1 + x2 = 1")
print(f"\n 拉格朗日乘子法:")
print(f" 解: ({x_lag[0]:.4f}, {x_lag[1]:.4f})")
print(f" 函数值: {f_lag:.4f}")
print(f" 拉格朗日乘子: {lam_lag[0]:.4f}")
# 投影梯度法
# min 0.5 * (x1^2 + x2^2) - x1 - x2
# s.t. x >= 0 (非负约束)
def proj_nonneg(x):
return np.maximum(x, 0)
x0 = np.array([2.0, 2.0])
x_proj, history_proj = projected_gradient(
lambda x: 0.5*x@Q@x + c@x,
lambda x: Q@x + c,
proj_nonneg,
x0,
alpha=0.1,
max_iter=100
)
f_proj = 0.5 * x_proj @ Q @ x_proj + c @ x_proj
print(f"\n 投影梯度法 (非负约束):")
print(f" 解: ({x_proj[0]:.4f}, {x_proj[1]:.4f})")
print(f" 函数值: {f_proj:.4f}")
if __name__ == "__main__":
demonstrate_constrained_optimization()16.4 稀疏优化
python
"""
稀疏优化方法的完整实现。
包含: ISTA, FISTA, Lasso 回归。
"""
import numpy as np
def soft_threshold(x, threshold):
"""软阈值算子 (近端算子)。"""
return np.sign(x) * np.maximum(np.abs(x) - threshold, 0)
def ista(A, b, lam, x0=None, alpha=None, max_iter=1000, tol=1e-6):
"""ISTA (迭代软阈值算法)。
min 0.5 * ||Ax - b||^2 + lam * ||x||_1
"""
n = A.shape[1]
if x0 is None:
x0 = np.zeros(n)
if alpha is None:
# Lipschitz 常数的估计
L = np.linalg.norm(A, ord=2)**2
alpha = 1.0 / L
x = x0.copy()
history = [x.copy()]
for k in range(max_iter):
# 梯度步
grad = A.T @ (A @ x - b)
y = x - alpha * grad
# 近端步
x_new = soft_threshold(y, alpha * lam)
history.append(x_new.copy())
# 收敛检查
if np.linalg.norm(x_new - x) < tol:
break
x = x_new
return x, history
def fista(A, b, lam, x0=None, alpha=None, max_iter=1000, tol=1e-6):
"""FISTA (快速 ISTA)。
min 0.5 * ||Ax - b||^2 + lam * ||x||_1
"""
n = A.shape[1]
if x0 is None:
x0 = np.zeros(n)
if alpha is None:
L = np.linalg.norm(A, ord=2)**2
alpha = 1.0 / L
x = x0.copy()
y = x.copy()
t = 1.0
history = [x.copy()]
for k in range(max_iter):
# 梯度步
grad = A.T @ (A @ y - b)
z = y - alpha * grad
# 近端步
x_new = soft_threshold(z, alpha * lam)
# 动量更新
t_new = (1 + np.sqrt(1 + 4*t**2)) / 2
y = x_new + (t - 1) / t_new * (x_new - x)
t = t_new
history.append(x_new.copy())
if np.linalg.norm(x_new - x) < tol:
break
x = x_new
return x, history
def demonstrate_sparse_optimization():
"""演示稀疏优化方法。"""
print("=" * 60)
print("稀疏优化演示")
print("=" * 60)
np.random.seed(42)
# 生成稀疏信号
n = 100 # 信号维度
m = 50 # 测量数
k = 10 # 稀疏度
# 稀疏信号
x_true = np.zeros(n)
support = np.random.choice(n, k, replace=False)
x_true[support] = np.random.randn(k)
# 测量矩阵
A = np.random.randn(m, n) / np.sqrt(m)
# 观测
b = A @ x_true + np.random.randn(m) * 0.01
print(f"\n稀疏信号恢复:")
print(f" 信号维度: {n}")
print(f" 测量数: {m}")
print(f" 稀疏度: {k}")
# ISTA
lam = 0.1
x_ista, hist_ista = ista(A, b, lam, max_iter=500)
err_ista = np.linalg.norm(x_ista - x_true)
# FISTA
x_fista, hist_fista = fista(A, b, lam, max_iter=500)
err_fista = np.linalg.norm(x_fista - x_true)
print(f"\n ISTA:")
print(f" 恢复误差: {err_ista:.6f}")
print(f" 非零元素: {np.sum(np.abs(x_ista) > 1e-4)}")
print(f" 迭代次数: {len(hist_ista) - 1}")
print(f"\n FISTA:")
print(f" 恢复误差: {err_fista:.6f}")
print(f" 非零元素: {np.sum(np.abs(x_fista) > 1e-4)}")
print(f" 迭代次数: {len(hist_fista) - 1}")
return x_true, x_ista, x_fista
if __name__ == "__main__":
demonstrate_sparse_optimization()附录
A. 数学符号表
| 符号 | 含义 | 维度 |
|---|---|---|
| xxx | 决策变量 | Rn\mathbb{R}^nRn |
| f(x)f(x)f(x) | 目标函数 | R\mathbb{R}R |
| ∇f(x)\nabla f(x)∇f(x) | 梯度 | Rn\mathbb{R}^nRn |
| ∇2f(x)\nabla^2 f(x)∇2f(x) | Hessian 矩阵 | Rn×n\mathbb{R}^{n \times n}Rn×n |
| α\alphaα | 步长/学习率 | R>0\mathbb{R}_{>0}R>0 |
| β\betaβ | 动量系数 | [0,1)[0, 1)[0,1) |
| λ\lambdaλ | 正则化系数/拉格朗日乘子 | R≥0\mathbb{R}_{\geq 0}R≥0 |
| LLL | Lipschitz 常数 | R>0\mathbb{R}_{>0}R>0 |
| μ\muμ | 强凸系数 | R>0\mathbb{R}_{>0}R>0 |
| κ\kappaκ | 条件数 L/μL/\muL/μ | R>0\mathbb{R}_{>0}R>0 |
| X\mathcal{X}X | 可行域 | Rn\mathbb{R}^nRn 的子集 |
B. 关键公式速查
梯度下降 ：
xk+1=xk−α∇f(xk)x_{k+1} = x_k - \alpha \nabla f(x_k)xk+1=xk−α∇f(xk)
动量 ：
vk=βvk−1+∇f(xk)v_k = \beta v_{k-1} + \nabla f(x_k)vk=βvk−1+∇f(xk)
xk+1=xk−αvkx_{k+1} = x_k - \alpha v_kxk+1=xk−αvk
Adam ：
mk=β1mk−1+(1−β1)gkm_k = \beta_1 m_{k-1} + (1-\beta_1) g_kmk=β1mk−1+(1−β1)gk
vk=β2vk−1+(1−β2)gk2v_k = \beta_2 v_{k-1} + (1-\beta_2) g_k^2vk=β2vk−1+(1−β2)gk2
xk+1=xk−αv^k+ϵm^kx_{k+1} = x_k - \frac{\alpha}{\sqrt{\hat{v}_k} + \epsilon} \hat{m}_kxk+1=xk−v^k +ϵαm^k
KKT 条件 ：
∇f+∑λi∇gi+∑νj∇hj=0\nabla f + \sum \lambda_i \nabla g_i + \sum \nu_j \nabla h_j = 0∇f+∑λi∇gi+∑νj∇hj=0
gi≤0,λi≥0,λigi=0g_i \leq 0, \quad \lambda_i \geq 0, \quad \lambda_i g_i = 0gi≤0,λi≥0,λigi=0
软阈值 ：
proxλ∣⋅∣(v)i=sign(vi)max(∣vi∣−λ,0)\\text{prox}_{\\lambda\|\\cdot\|}(v)_i = \text{sign}(v_i) \max(|v_i| - \lambda, 0)proxλ∣⋅∣(v)i=sign(vi)max(∣vi∣−λ,0)
收敛速度：
- GD (凸)：O(1/k)O(1/k)O(1/k)
- GD (强凸)：O(κlog(1/ϵ))O(\kappa \log(1/\epsilon))O(κlog(1/ϵ))
- NAG (凸)：O(1/k2)O(1/k^2)O(1/k2)
- NAG (强凸)：O(κlog(1/ϵ))O(\sqrt{\kappa} \log(1/\epsilon))O(κ log(1/ϵ))
C. 参考文献
-
Boyd, S., & Vandenberghe, L. (2004). Convex Optimization. Cambridge University Press.
-
Nocedal, J., & Wright, S. J. (2006). Numerical Optimization (2nd ed.). Springer.
-
Bertsekas, D. P. (2016). Nonlinear Programming (3rd ed.). Athena Scientific.
-
Nesterov, Y. (2018). Lectures on Convex Optimization (2nd ed.). Springer.
-
Kingma, D. P., & Ba, J. (2015). Adam: A Method for Stochastic Optimization. ICLR 2015.
-
Loshchilov, I., & Hutter, F. (2019). Decoupled Weight Decay Regularization. ICLR 2019.
-
Candès, E. J., Romberg, J., & Tao, T. (2006). Robust Uncertainty Principles: Exact Signal Reconstruction from Highly Incomplete Frequency Information. IEEE TIT.
-
Beck, A., & Teboulle, M. (2009). A Fast Iterative Shrinkage-Thresholding Algorithm for Linear Inverse Problems. SIAM J. Imaging Sciences.
-
Parikh, N., & Boyd, S. (2014). Proximal Algorithms. Foundations and Trends in Optimization.
-
Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep Learning. MIT Press.
本文涵盖了优化理论从凸优化到深度学习训练的完整理论体系，并探讨了优化在控制论、信号处理和机器学习中的应用。代码均使用 NumPy 实现，可直接运行。