fyerfyer's Blog

nearest-neighbor-alg

Sun, 28 Sep 2025 08:49:16 GMT

Boosting 算法

Sun, 28 Sep 2025 08:48:57 GMT

Boosting 算法

1. AdaBoost 简介

AdaBoost (Adaptive Boosting) 是一种用于分类或回归的集成方法。它具有如下的特点：

它通过不断关注之前被错分的样本来提升模型的拟合能力，从而降低偏差。这一点与随机森林等主要减少方差的集成方法不同。
与 Bagging 类似，它也对训练样本进行加权，但权重在每次迭代中都会动态调整。
每个弱学习器训练时样本的权重都是不同的。
增加被错误分类的训练点的权重：这是 AdaBoost 的核心机制。如果一个样本被当前的学习器搞错了，那么在训练下一个学习器时，这个样本的权重就会变大，让下一个学习器更加关注这个难点。
在最终做决策时，表现好的（错误率低的）学习器有更大的发言权。

它的核心流程如下：

训练 $T$ 个分类器：AdaBoost 依次训练出一系列的弱分类器 $G_1, G_2, ..., G_T$ 。（这里的 $T$ 通常代表 "Trees"，因为决策树是 AdaBoost 最常用的弱学习器）。
动态调整样本权重：训练第 $t$ 个分类器 $G_t$ 时，训练样本 $X_i$ 的权重取决于它被前面 $t-1$ 个分类器 $G_1, ..., G_{t-1}$ 错分了多少次。如果一个样本 $X_i$ 被一个非常准确的弱学习器错分了，它的权重会增加得更多；反之则会减少。
训练弱学习器 $G_t$ ： $G_t$ 的训练目标是，在当前样本权重分布下，尽可能地把样本（尤其是权重大的样本）分类正确。

最终我们获得强分类器 $M(z)$ 是所有弱学习器的加权线性组合。对于一个测试点 $z$ ，最终的预测结果由 $M(z) = \sum \beta _t G_t(z)$ 的符号决定，其中 $G_t(z)$ 的输出是 +1 或 -1， $β_t$ 是第 $t$ 个弱学习器的权重（投票权）。 $M(z)$ 是一个连续值，最终的分类结果是 $\text{sign}(M(z))$ 。

我们经常使用决策树来作为弱分类器的理由如下：

可靠地减少偏差：Boosting 能稳定地降低偏差。使用“不纯”的短决策树（即只有一层分裂的决策树，或深度很浅的树）可以防止过拟合，从而控制方差。同时短决策树的训练和预测都非常快。
无需超参数搜索：与 SVM、神经网络等需要精细调参的模型相比，AdaBoost+决策树几乎是“开箱即用”的，效果通常都很好。UC Berkeley 的 Leo Breiman 称之为“世界上最好的现成（off-the-shelf）分类器”。
隐式特征选择：AdaBoost+短决策树是一种特征选择的形式。如果一个特征对提升整体预测能力贡献不大，它可能根本不会被任何一个短决策树选中。
非线性边界更有效：对于线性分类器，Boosting 效果不佳，因为需要很多次迭代才能拟合复杂的非线性边界。而决策树本身就是非线性的，Boosting 可以更快地减少其偏差。

2. 损失函数与公式推导

AdaBoost 使用了一个特殊的指数损失函数：

L(\lambda,\hat{\lambda}) \;=\; e^{-\lambda\hat{\lambda}} \;=\; \begin{cases} e^{-\hat{\lambda}}, & \lambda=+1,\\[6pt] e^{\hat{\lambda}}, & \lambda=-1. \end{cases}

其中： $\lambda$ 是真实标签 (+1 或 -1)， $\hat{\lambda}$ 是元学习器的连续输出值 $M(X_i)$ 。

于是总风险可以表示为：

\text{Risk} = \frac{1}{n} \sum_{i=1}^{n} L(M(X_i), y_i) = \frac{1}{n} \sum_{i=1}^{n} e^{-y_i M(X_i)}

将模型展开并分离第 $T$ 轮，有：

\begin{aligned} \text{Risk} &= \frac{1}{n} \sum_{i=1}^{n} e^{-y_i \sum_{t=1}^{T} \beta_t G_t(X_i)} \\ &= \frac{1}{n} \sum_{i=1}^{n} \prod_{t=1}^{T} e^{-\beta_t y_i G_t(X_i)} \\ &= \frac{1}{n} \sum_{i=1}^{n} \left( \prod_{t=1}^{T-1} e^{-\beta_t y_i G_t(X_i)} \right) e^{-\beta_T y_i G_T(X_i)} \end{aligned}

我们定义第 $T$ 轮开始时的样本权重 $w_i^{(T)}$ ：

w_i^{(T)} = \prod_{t=1}^{T-1} e^{-\beta_t y_i G_t(X_i)}

于是总风险可以写成关于第T轮的形式：

\begin{aligned} \text{Risk}_T &= \sum_{i=1}^{n} w_i^{(T)} e^{-\beta_T y_i G_T(X_i)} \\ &= \sum_{y_i = G_T(X_i)} w_i^{(T)} e^{-\beta_T} + \sum_{y_i \neq G_T(X_i)} w_i^{(T)} e^{\beta_T} \\ &= e^{-\beta_T} \sum_{i=1}^{n} w_i^{(T)} + (e^{\beta_T} - e^{-\beta_T}) \sum_{y_i \neq G_T(X_i)} w_i^{(T)} \end{aligned}

由这个式子，我们讨论两个问题：

$G_T$ 的选择：可以看出最优的弱分类器 $G_T$ 的选择依据如下：

G_T = \underset{G}{\arg\min} \sum_{i=1}^{n} w_i^{(T)} \mathbb{I}(y_i \neq G(X_i))

这正是我们训练弱分类器的目标：我们希望让被错分的点的权重之和最小。

权重的递归定义：可以得到如下的样本权重更新规则：

w_i^{(T+1)} = w_i^{(T)} e^{-\beta_T y_i G_T(X_i)} = \begin{cases} w_i^{(T)} e^{-\beta_T}, & \text{if } y_i = G_T(X_i) \quad (\text{correct}) \\ w_i^{(T)} e^{\beta_T}, & \text{if } y_i \neq G_T(X_i) \quad (\text{incorrect}) \end{cases}

然后我们推导分类器权重 $\beta_T$ 的选择。令风险函数为 $J(\beta_T)$ ：

J(\beta_T) = \sum_{y_i = G_T(X_i)} w_i^{(T)} e^{-\beta_T} + \sum_{y_i \neq G_T(X_i)} w_i^{(T)} e^{\beta_T}

对 $\beta_T$ 求偏导并令其为零：

\begin{aligned} \frac{\partial J(\beta_T)}{\partial \beta_T} &= -\sum_{y_i = G_T(X_i)} w_i^{(T)} e^{-\beta_T} + \sum_{y_i \neq G_T(X_i)} w_i^{(T)} e^{\beta_T} = 0 \\ e^{\beta_T} \sum_{y_i \neq G_T(X_i)} w_i^{(T)} &= e^{-\beta_T} \sum_{y_i = G_T(X_i)} w_i^{(T)} \\ e^{2\beta_T} &= \frac{\sum_{y_i = G_T(X_i)} w_i^{(T)}}{\sum_{y_i \neq G_T(X_i)} w_i^{(T)}} \\ e^{2\beta_T} &= \frac{\sum_{i=1}^n w_i^{(T)} - \sum_{y_i \neq G_T(X_i)} w_i^{(T)}}{\sum_{y_i \neq G_T(X_i)} w_i^{(T)}} \\ e^{2\beta_T} &= \frac{1 - \frac{\sum_{y_i \neq G_T(X_i)} w_i^{(T)}}{\sum_{i=1}^n w_i^{(T)}}}{\frac{\sum_{y_i \neq G_T(X_i)} w_i^{(T)}}{\sum_{i=1}^n w_i^{(T)}}} \\ \end{aligned}

我们定义加权错误率 $\text{err}_T$ ：

\text{err}_T = \frac{\sum_{y_i \neq G_T(X_i)} w_i^{(T)}}{\sum_{i=1}^{n} w_i^{(T)}}

则：

\begin{aligned} e^{2\beta_T} &= \frac{1 - \text{err}_T}{\text{err}_T} \\ 2\beta_T &= \ln\left(\frac{1 - \text{err}_T}{\text{err}_T}\right) \\ \beta_T &= \frac{1}{2} \ln\left(\frac{1 - \text{err}_T}{\text{err}_T}\right) \end{aligned}

如果 $err_T = 0$ (完美分类)， $\beta_T = \infty$ (获得无限大的投票权)。
如果 $err_T = 0.5$ (相当于随机猜测)， $\beta_T = 0$ (没有投票权)。
如果 $err_T > 0.5$ (比随机猜还差)， $\beta_T$ 会是负数。这意味着这个学习器“坏到恰到好处”，我们可以把它预测的结果反过来用，它就变成了一个好的学习器。

于是，AdaBoost 经过整理后的完整流程如下：

初始化权重：所有训练样本的权重 $w_i$ 初始化为 $\frac{1}{n}$ 。
循环 $T$ $T$ 次，对于第 $t$ $t$ 次：
1. 使用当前的权重 $w_i$ 训练一个弱学习器 $G_t$ 。
2. 计算 $G_t$ 的加权错误率 $err_t$ ，并根据 $err_t$ 计算该学习器的投票权重 $\beta_t$ 。
3. 更新所有样本的权重 $w_i$ ：错分的样本权重乘以 $e^{(\beta_t)}$ ，正确的样本权重乘以 $e^{(-\beta _t)}$ 。（然后通常会进行归一化，使所有权重之和为1）。
返回最终模型：元学习器 $h(z) = \text{sign}(\sum _{t=1} ^T β_t G_t(z))$ 。

需要说明：指数损失函数对噪声和异常值非常敏感，一个离群点可能会获得极大的权重，从而影响后续学习器的训练。如果数据质量不高，可以考虑使用其他更鲁棒的损失函数。

伪逆与神经网络生成方法优化

Sun, 28 Sep 2025 03:55:22 GMT

伪逆与神经网络生成方法优化

1. 伪逆

$a.$ 定义

伪逆是一个矩阵的广义逆。常规的逆矩阵 $X^{-1}$ 只对可逆的方阵存在。而伪逆 $X^{+}$ 对任何形状的矩阵都存在。

如果一个 $n \times d$ 的矩阵 $X$ 的紧凑 SVD 分解是 $X = UDV^T$ ，那么它的摩尔-彭若斯伪逆 (Moore-Penrose Pseudoinverse) $X^{+}$ 定义为：

X^{T} = VD^{-1}U^T

这是一个 $d \times n$ 的矩阵。

我们对 $X$ 的 SVD 分解取转置：

X^T = (UDV^T)^T=VDU^T

可以看出， $X^{+}$ 就像是 $X$ 的转置 $X^T$ ，但把其中的奇异值 $\delta_i$ 换成了它们的倒数 $\frac{1}{\delta_i}$ 。

$b.$ 重要性质

$XX^{+}=UU^T,\quad X^{+}X=VV^T$

将 $X$ 和 $X^{+}$ 的定义式代入即得。下面我们来分析这个性质。

首先我们先明确正交投影矩阵的两个判断标准：

对称性 (Symmetry): $P = P^T$ 。
幂等性 (Idempotence)： $P^2=P$ 。

先简单阐释这两个标准的来源。幂等性的理解较为简单：我们希望不管投影多少次、投影的结果都是不变的，也就是说不论我们为 $X$ 施加多少次投影变换 $P$ ，结果都是一致的。

然后是对称性。这是对垂直投影的要求：我们希望连接 $X$ 的顶端和其影子 $p$ 的顶端的那条“光线” $e = x - p$ ，必须与“地面” $S$ 完全垂直，也就是与 $S$ 中任意一个向量 $s$ 垂直，也即：

s^T(x - Px) = 0

下面我们来证明当 $P=P^T$ 时，这个式子成立。注意到 $s$ 在 $S$ 上、本身即是一个投影，由 $P$ 的幂等性：

\begin{aligned} s^{T}(x - P x) &= s^{T}x - s^{T}P x,\\[6pt] \Rightarrow\quad s^{T}x &= (P s)^{T}x \qquad\text{(since }s = P s\text{)},\\[6pt] &= s^{T}P^{T}x \qquad\text{(transpose property)},\\[6pt] &= s^{T}P x \qquad\text{(since }P^{T}=P\text{)},\\[6pt] \Rightarrow\quad s^{T}(x - P x) &= s^{T}x - s^{T}P x = s^{T}P x - s^{T}P x = 0. \end{aligned}

而 $U$ 和 $V$ 显然满足这两条性质，因此它们是正交投影矩阵。

而对于 $U$ ，它的列向量张成了 $X$ 的整个列空间，对于任意向量 $z$ ，变换 $UU^T$ 为：

(UU^T)z=U(U^Tz)=U(U\cdot z)

这正是向量投影的定义： $UU^T$ 将输入 $X$ 投影到它的列空间中。同理， $VV^T$ 将输入 $X$ 投影到它的行空间中。从而， $XX^{+}$ 与 $X^{+}X$ 也具有这样的性质。

这一性质说明了 $X$ 和 $X^{+}$ 并非在整个空间上互为逆矩阵，它们只在 $X$ 的行空间和列空间这两个“有效区域”之间才表现出完美的互逆关系。对于任何超出这两个区域的向量分量，这个求逆过程都会伴随着一次投影，也就是一次不可逆的信息损失。这正是伪逆与真正的逆 $A^{-1}$ 的根本区别。

同时这也说明： $XX^{+}$ 在 $X$ 的列空间上是单位映射 (identity map)。也就是说，对于任何在 $X$ 列空间中的向量 $z$ ，有 $XX^{+}z = z$ 。

如果 $X$ 是行满秩 ( $r = n$ )， $X^{+}$ 是一个右逆 ( $XX^{+} = I$ )。
如果 $X$ 是列满秩 ( $r = d$ )， $X^{+}$ 是一个左逆 ( $X^{+}X = I$ )。
如果 $X$ 是一个可逆的方阵 ( $r = n = d$ )，那么 $X^{+} = X^{-1}$ 。这说明伪逆是常规逆的推广。

我们只证明第一条。首先代入 SVD：

\begin{aligned} X^{+}X &= (V\Sigma^{+}U^{T})(U\Sigma V^{T})\\[6pt] &= V\Sigma^{+}(U^{T}U)\Sigma V^{T} \\[6pt] &= V\Sigma^{+}\Sigma V^{T} \end{aligned}

由于 $X$ 是行满秩，计算对角矩阵 $\Sigma$ 得：

\begin{aligned} \Sigma^{+}\Sigma &= \mathrm{diag}\!\left(\frac{1}{\sigma_1},\dots,\frac{1}{\sigma_d}\right) \,\mathrm{diag}(\sigma_1,\dots,\sigma_d)\\[6pt] &= I_d \end{aligned}

于是：

\begin{aligned} X^{+}X &= V I_d V^{T}\\[6pt] &= V V^{T} \end{aligned}

由于 $V$ 为 $d \times d$ 正交矩阵，于是：

\begin{aligned} X^{+}X &= I_d \end{aligned}

$X^{+}$ 和 $X^T$ 具有相同的四个基本子空间（行空间、列空间、零空间、左零空间）。这意味着 $X^{+}$ 的行空间就是 $X$ 的列空间， $X^{+}$ 的列空间就是 $X$ 的行空间。

这个结论的证明非常简单，只需要知道：

$X$ 的列空间 $C(X)$ 由 $U$ 的前 $r$ 个列向量 $[u_1, ..., u_r]$ 张成。
$X$ 的行空间 $C(X^T)$ 由 $V$ 的前 $r$ 个列向量 $[v_1, ..., v_r]$ 张成。
$X$ 的零空间 $N(X)$ 由 $V$ 的后 $d-r$ 个列向量 $[v_{r+1}, ..., v_d]$ 张成。
$X$ 的左零空间 $N(X^T)$ 由 $U$ 的后 $n-r$ 个列向量 $[u_{r+1}, ..., u_n]$ 张成。

$c.$ 几何直观

矩阵 $X$ 可以看作一个线性函数，它将它的行空间中的向量一一对应地映射到它的列空间中：

$v_1$ , $v_2$ 是行空间的一组基（右奇异向量）。
$u_1$ , $u_2$ 是列空间的一组基（左奇异向量）。
$X$ 把 $v_i$ 映射为 $\delta_iu_i$ (方向不变，长度缩放 $\delta_i$ 倍)。
$X^{+}$ 把 $u_i$ 映射回 $(1/\delta_i)v_i$ (方向不变，长度缩放 $1/\delta_i$ 倍)。
当我们用 $X$ 作用于一个行空间中的向量，再用 $X^{+}$ 作用于结果时，可以得到原始的向量：

X^{+}(Xv) = v

这就是前面性质中说的“单位映射”。

$d.$ 在正规方程中的应用

伪逆最重要的应用场景之一就是求解最小二乘中的正规方程：

X^TXw = X^Ty

容易证明：无论 $X^TX$ 是否可逆， $w=X^{+}y$ 永远是方程的一个解。

同时，当正规方程有无穷多解时（ $X^TX$ 不可逆的情况）， $w = X^{+}y$ 是所有解中范数最小的那一个。在机器学习中，一个范数更小的解通常意味着模型更简单，更不容易过拟合，因此这个是一个最稳定的解。

2. 防止过拟合的方法整理

$a.$ 数据增强

当无法获取更多真实数据时，数据增强是一种极其有效的替代方案。例如，对于一张猫的图片，我们可以通过水平翻转、缩放、平移等操作，告诉模型：“你要学会识别的是猫的本质特征，而不是它在图片中的具体位置、方向、光照或颜色。”

数据增强有下面两种思路：

切线传播 (Tangent Propagation) - 基于模型的正则：这是一种更复杂、更“数学化”的方法。它不是直接生成新图片，而是在模型的误差函数中添加一个正则化项。这个正则化项会惩罚“当输入发生微小变换时，模型输出发生剧烈变化”的情况。例如，如果输入图片被平移了0.1个像素，这个正则化项就会阻止模型输出的类别概率发生大的跳变。
- 它的缺点是实现复杂，需要额外的计算开销，并且通常只能处理非常微小的变换。
数据集增强 (Data Set Augmentation) - 基于数据的扩充：这是我们通常所说的数据增强。它直接在训练前或训练中生成新的、经过变换的图像，来扩充数据集。它的实现相对简单，效果非常好，应用广泛。
- 对于随机梯度下降等在线学习算法: 可以在每次将数据点送入模型之前，对其进行一次随机变换。这样，在多轮训练（epochs）中，模型每次看到的同一个原始样本都是略有不同的版本，非常高效。
- 对于批量方法: 可以将每个数据点复制多次，对每个副本独立进行变换，然后用这个扩充后的、更大的数据集进行训练。

通过对误差函数进行泰勒展开来分析微小变换带来的影响，可以从理论上证明：数据增强在效果上等价于向误差函数中添加了一个正则化项，这个等效的正则化项惩罚的是 “网络输出相对于变换的梯度”。

其他方法都比较常见，这里略过。

3. 双下降

生成：ChatGPT 5，整理：fyerfyer

在深度学习的早期发展阶段，研究者普遍秉持一种“控制模型规模”的谨慎态度。这种观念源于两方面的担忧：

神经网络在训练过程中可能会陷入所谓“坏的局部最小值”，从而导致训练误差长期停留在较高水平。
若模型包含过多参数，便极易出现严重的过拟合现象，进而破坏泛化性能。

因此，彼时的主流理论认为：模型应当尽可能保持简洁，以避免损害模型在新数据上的表现。这一思路与统计学中的经典“偏差—方差权衡”高度一致：随着模型复杂度的增加，偏差会下降，但方差随之上升。二者之间的平衡被视为模型选择的核心。

这一理论的具体推导参见前面的 "对机器学习方法的统计证明" 笔记。

然而，伴随计算能力的显著提升与大规模实践经验的积累，人们逐渐意识到，这种担忧在现实场景中并不完全成立。首先，所谓“坏的局部最小值”并非实质性障碍。通常情况下，若模型无法进一步降低训练误差，其根本原因往往不是因陷入恶性最优点，而在于模型容量不足。换言之，约束过严才是性能受限的主要因素。

由此得出的对策十分直接：通过增加网络的宽度或深度来扩展容量。当网络规模足够庞大时，它几乎总能在训练集上达到接近零的误差，即实现对所有训练样本的插值（interpolation）。在这一状态下，模型能够逐点“记忆”数据，从而在训练过程上取得完美的拟合。

在这样的背景下，一个关键问题随之出现：如果模型在训练集上已经能够完全拟合数据，依据传统偏差-方差理论，它在测试集上的表现应当非常糟糕。然而，现代实证研究却揭示出一种显著偏离理论预期的曲线形态。

按照经典理论，若将模型复杂度作为横轴、测试误差作为纵轴绘制曲线，其走势应呈现一个“U”型：当复杂度从低水平逐步提升时，模型能够更好地捕捉真实的规律，偏差下降，测试误差随之降低；但在复杂度超过某一最佳区间后，模型逐步吸收数据中的噪声，方差显著增加，测试误差随之升高。然而，现代实验表明，当模型规模进一步扩大时，测试误差并非持续上升，而是出现再次下降的趋势。曲线表现为：先下降、后上升，再度下降，这一新现象即被称为“双下降”（Double Descent）：

更具体而言，在模型复杂度逐渐增加的过程中，首先会出现与经典理论一致的阶段：测试误差下降至某一最低点；随后，在复杂度到达所谓的插值阈值（interpolation threshold）时，误差剧烈攀升，形成峰值。此时模型的参数容量刚好足以拟合所有训练点，包括其中的噪声数据或错误标注。由于缺乏更大的空间来调整其内部表示，模型被迫生成一条极不光滑的函数曲线以满足所有约束，其结果是泛化能力显著下降。

然而，在进一步增加模型容量、进入过参数化（over-parameterized）区域之后，情况出现根本改变。此时，能够实现零训练误差的解已不再唯一，而是存在于一个庞大且连续的解空间中。优化算法（例如随机梯度下降）在这些候选解中并非完全无差别地选择，而是由于其隐式偏差，倾向于选择更为“平滑”或“简洁”的解，如权重范数较小的函数形式。因而，冗余参数为模型提供了巨大的“自由度”，从而使得它既能在样本点处精确拟合，又能在整体函数形态上保持近似的平滑与简洁。这一机制有效缓解了由噪声拟合带来的泛化问题。

尤为重要的是，双下降并非神经网络的特例，而是在诸如决策树、带随机特征的线性回归等多种模型中均可观测到的普遍现象。这表明，双下降并不仅是某类神经模型的独有产物，而极有可能是一条更为基本的机器学习原理：它揭示了在高度过参数化情境中，模型复杂性、训练拟合能力与泛化性能之间的一种全新关系。

无监督学习

Sat, 27 Sep 2025 11:04:18 GMT

无监督学习

与前面的训练不同，无监督学习只有样本点而没有标签。它的核心目标是在没有外部指导的情况下，发现数据本身固有的结构、模式或关系。

1. 主成分分析

$a.$ 概述

主成分分析 (Principal Components Analysis, PCA) 的目标是：在一个 $d$ 维的数据空间中，找到 $k$ 个新的坐标轴（方向），这些新的坐标轴能够捕捉到数据中最大部分的变异性（variation）。换句话说，就是找到最能“概括”数据分布的方向。

PCA 可以降低模型的维度，从而降低计算成本。同时维度特征的减少也可以减少过拟合，让模型更关注核心特征，从而提高泛化能力。

这类似于特征选择，但 PCA 找到的新特征是原始特征的线性组合，而不是简单地从原始特征中挑选。

$b.$ 算法

假设我们的数据是一个 $n\times d$ 的矩阵 $X$ 。

首先，我们对数据进行数据中心化：我们计算所有样本的平均值，然后让每个样本点都减去这个平均值。这样，现在的数据表示的是相对于平均值的偏差。

然后我们引入投影 (Projection) 的概念，向量 $x$ 在方向向量 $w$ 上的投影为 $\tilde{x}=(x\cdot w)w$ 。PCA 的目标就是找到最好的投影方向 $w$ ，使得数据在该方向上的分布最为分散（也即方差最大）。下面我们进行推导。

我们将整个数据矩阵投影到 $w$ 上：

\tilde{X}=Xw

因为 $X$ 的均值为 0 (因为已经中心化了)，则 $\tilde{X}$ 的均值也为 0，因此我们需要最大化的方差为：

\sigma^2=\frac{1}{n}(Xw)^T(Xw)=\frac{1}{n}w^TX^TXw

我们令 $S=X^TX$ ，则问题转变为最大化 $w^TSw$ 。这是一个在数学和物理中非常经典的问题。线性代数中有一个著名的定理（Rayleigh Quotient）告诉我们：对于一个对称矩阵 $S$ ，表达式 $w^TSw$ 的最大值，会在 $w$ 是该矩阵最大特征值 $λ_{max}$ 所对应的特征向量时取到，并且最大值本身就是 $λ_{max}$ 。

因此，数据的第一主成分就是 $X^TX$ 的最大特征向量，第二主成分为次大的特征向量，以此类推。

我们可以根据累积方差贡献率来决定选择多少个主成分，如选择 $k$ 个主成分，使得它们能解释总方差的 95%。

在得到这些主成分后，我们将原始数据点投影到这些主成分上，得到新的 $k$ 维坐标 $x \cdot v_i$ ，主成分分析就完成了。

2. 奇异值分解

$a.$ PCA 算法的问题

在 PCA 中，我们需要计算矩阵 $X^TX$ ，这个计算的时间复杂度是 $\Theta(nd^2)$ 。当特征维度 $d$ 很大时，这个计算量非常巨大。

同时，计算出的 $X^T X$ 矩阵可能是一个“病态矩阵”：矩阵的条件数（最大特征值与最小特征值之比）非常大。对于这样的矩阵，计算其特征向量时，微小的计算误差都可能被急剧放大，导致最终结果不准确。而我们计算主成分的方法 $X^TX$ 会进一步放大这个误差：

\kappa\!\left(X^{T}X\right) \;=\; \left[\kappa(X)\right]^{2}

为了解决这个问题，可以用 SVD 来寻找 PCA 所需的主成分。

$b.$ 数学推导

由于要获取特征值，我们对 $X^TX$ 进行特征分解。对于一个方阵 $A$ ，它的特征值分解被定义为：

A = P \Lambda P^{-1}

其中：

$P$ 是一个矩阵，它的列向量是 $A$ 的特征向量。 $\Lambda$ 是一个对角矩阵，它的对角线元素是 A 对应的特征值。

这里的推导可以参见“特征值分解”一章的笔记。

于是我们先得到了标准的分解形式，之后我们会将推导出的式子和这个进行比对：

X^T X = P \Lambda P^T

现在我们使用奇异值分解 (SVD)：任何一个 $n x d$ 维的矩阵 $X$ 都可以被分解为三个矩阵的乘积：

X = U D V^T

其中U 是一个 $m \times m$ 的正交矩阵， $D$ 是一个 $m \times n$ 的对角矩阵， $V^T$ 是一个 $n \times n$ 的正交矩阵 $V$ 的转置。

一个额外的补充： $U$ 的列向量构成了 $X$ 的列空间的一组标准正交基； $V$ 的行向量构成了 $X$ 的行空间的一组标准正交基。而 $D$ 则定义了到这些新的空间的缩放。

关于 SVD 分解的详细讲解可以参照我之前的笔记。

将 SVD 分解的结果代入：

\begin{aligned} X^{T}X &= (U\,D\,V^{T})^{T}\,(U\,D\,V^{T})\\[6pt] &= \bigl(V\,D^{T}\,U^{T}\bigr)\,\bigl(U\,D\,V^{T}\bigr) \end{aligned}

因为 $U$ 是标准正交的， $U^T U = I$ ，则：

X^T X = V (D^T D) V^T

这正是前面标准的特征值分解形式，其中：

$V$ 是 $X^T X$ 的特征向量矩阵。
$D^T D$ 是 $X^T X$ 的特征值对角矩阵，其对角线上的元素就是 $\delta_i^2$ 。

SVD 分解相对于 PCA 更稳定：奇异值的比率 $\delta_{max} / \delta_{min}$ 通常远小于特征值的比率 $\delta_{max}^2 / \delta_{min}^2$ 。在数值计算中，处理差异没那么悬殊的数字会更稳定、更精确。

$c.$ 主坐标

推导完使用 SVD 的 PCA 后，我们再来看看将 $X$ 沿主坐标投影会发生什么。由前面的分解：

\begin{aligned} X\,V &= (UDV^{T})\,V\\[6pt] &= UD(V^{T}V)\\[6pt] &= UD \end{aligned}

可以看到，矩阵 $UD$ 的第 $i$ 行，直接给出了原始数据点 $X_i$ 的主坐标。

$d.$ 紧凑 SVD

在实际应用中，很多奇异值可能是0（或者非常接近0）。这些奇异值为0的成分对于重构矩阵 $X$ 没有任何贡献。因此，我们可以把它们丢掉，这就引出了紧凑SVD。

假设矩阵 $X$ 的秩为 $r$ ，这意味着它只有 $r$ 个非零的奇异值，我们可以做如下的紧凑 SVD：

X = U_r(n×r) D_r(r×r) V_r^T(r×d)

这样可以节省存储与运算空间。

3. 聚类

$a.$ 概述

聚类是一种无监督学习方法，它的目标是将数据集中的样本划分成若干个簇（cluster）：同一个簇内的数据点彼此之间非常相似，而不同簇之间的数据点则差异很大。

聚类主要有如下的应用场景：

探索数据特征，寻找隐藏的模式或群体，在网络结构中寻找社群。
构建事物的分类体系。
进行数据压缩，将数据中的很多点都使用所属簇的中心点来表达。

$b.$ k-means

k-means 的目标是将 $n$ 个数据点划分到 $k$ 个互不相交的簇中。我们定义：

$X_i$ : 第 $i$ 个数据点。
$y_i$ : 数据点 $X_i$ 所属的簇的标签。
$\mu_i$ : 第 $i$ 个簇的均值或中心点 (mean/centroid)，为该簇内所有数据点的算术平均值。
$n_i$ : 第 $i$ 个簇中数据点的数量。

算法的目标是找到一个最优的簇分配方案 $y$ ，使得所有数据点到其所属簇中心点的平方距离之和 (Sum of Squared Errors, SSE) 最小：

\begin{aligned} \min_{\{\mu_i\}_{i=1}^{k}} \;&=\; \sum_{i=1}^{k}\sum_{X_j\in C_i}\left\|X_j-\mu_i\right\|^{2} \end{aligned}

这是一个 NP-hard 问题，如果想找到全局最优解，理论上需要尝试所有可能的划分方式，时间复杂度高达 $O(n^k)$ 。为此， k-means 采用了一种启发式策略：我们交替进行下面的步骤：

更新均值：固定 $y_i$ 计算每个簇的中心点 $\mu_i$ 。
更新分配：固定每个簇的中心点 $\mu_i$ $μ_{i}$ ，将每个数据点 $X_j$ $X_{j}$ 重新分配给离它最近的那个簇中心点 $\mu_i$ 所代表的簇。
- 如果出现距离相等的情况，并且其中一个选项是保持上一次迭代的分配不变，那么就选择保持不变，这有助于算法稳定。

算法在这两个步骤之间不断迭代，直到步骤二不再改变任何数据点的簇分配时，算法收敛并停止。

在 k-means 算法中，初始中心点的选择对最终结果影响很大。常见的初始化方法有：

Forgy 方法: 随机从数据集中选择 $k$ 个点作为初始的簇中心点 $\mu_i$ ，然后直接开始更新分配。
随机划分: 将每个数据点随机分配到一个簇，然后开始更新均值。
k-means++: 这是目前最推荐的方法。它也随机选择初始点，但带有一定的策略：下一个初始中心点的选择会优先考虑那些离已选中心点较远的点。这使得初始中心点能更均匀地散布在数据空间中，从而更容易找到一个好的局部最优解。

下面是 k-means++ 的完整实现，唯一比较麻烦的地方是二阶范数的计算：

def kmeans_pp_nn(X, center_index_0, k, j):
    n_samples, n_features = X.shape
    centers_indices = [center_index_0]

    for _ in range(1, k):
        current_center = X[centers_indices]
        D = -2 * X @ current_center.T + (X ** 2).sum(axis=1)[:, None] + (current_center ** 2).sum(axis=1)
        # Compute the distances of all remaining points to all selected centers
        distances = np.min(D, axis=1)

        # Sort the list of data points (in decreasing order) by the minimum such distance
        sorted_indices = np.argsort(distances)[::-1]

        # Choose the jth element of the list in this sorted order as the next center
        next_center_index = sorted_indices[j]
        centers_indices.append(next_center_index)

    return centers_indices

$c.$ 层次聚类

$i.$ 聚类思想

与k-means将数据划分成k个独立的簇不同，层次聚类会创建一个树状的结构（通常是二叉树），这棵树被称为树状图 (Dendrogram)。在这棵树中，每一个子树都代表一个簇：

层次聚类主要有两种方法：

自底向上 (Bottom-up)，也称为凝聚式聚类 (agglomerative clustering)：开始时，每个数据点都自成一簇。然后，算法会重复地将最相似（距离最近）的两个簇合并成一个新簇。这个过程不断重复，直到所有数据点都合并到同一个根簇中。
自顶向下 (Top-down)，也称为分裂式聚类 (divisive clustering)：开始时，所有数据点都在一个大簇中。然后，算法重复地将一个簇分裂成两个最不相似的子簇。这个过程不断重复，直到每个点都自成一簇，或者达到了预设的簇数量。
- 当输入是点集时，凝聚式聚类用得远比分裂式聚类多。但当输入是图时，分裂式聚类（如图分割算法）更常见。

$b.$ 划分方法

对于凝聚式聚类，关键问题是如何衡量两个簇 $A$ 和 $B$ 之间的距离 $d(A, B)$ 。这由连接方法 (Linkage) 来定义。有如下的连接方法：

完全连接 (complete linkage) 将距离定义为两个簇中最远的两个点之间的距离。只有当 $A$ $A$ 中所有点都和 $B$ $B$ 中所有点靠得足够近时，这两个簇的距离才近。
- 它倾向于产生最平衡的簇。因为它要求一个簇中所有点都和另一个簇中所有点离得近才能合并。当一个簇变大时，它内部最远的点会离其他簇很远，因此大簇更难继续“生长”。

d(A, B) = \max \lbrace d(w, x) : w \in A, x \in B \rbrace

单一连接 (single linkage)将距离定义为两个簇中最近的两个点之间的距离。只要 $A$ $A$ 中有一个点和 $B$ $B$ 中有一个点离得近，这两个簇的距离就近。
- 这种连接方式对异常值非常敏感。两个簇只要有一对点离得近，就可能被合并，这容易导致“链式效应”：即一个簇通过一系列中间点不断地“吞并”远处的点，形成一个长链状、不紧凑的簇。这也会导致树的不平衡。

d(A, B) = min{d(w, x) : w ∈ A, x ∈ B}

平均连接 (average linkage) 将距离定义为两个簇中所有点对之间距离的平均值。它综合考虑了所有点的信息：
- 它是一种介于单一连接和完全连接之间的折中方案，表现通常比较稳健。

d(A, B) = (1 / |A||B|) * Σ(w∈A) Σ(x∈B) d(w, x)

中心点连接 (centroid linkage) 将距离定义为两个簇的中心点之间的距离。：

d(A, B) = d(µA, µB)

完全、单一、平均连接方法适用于任何距离函数 $d(w, x)$ ，但中心点连接只有在使用欧几里得距离时才有明确的物理意义，因为“中心点”的概念通常是基于欧氏空间中的均值来计算的。

对于凝聚式层次聚类，我们通常使用贪心凝聚算法，流程如下：

将每个点初始化为一个簇。
重复以下步骤，直到只剩一个簇：
- 在当前所有的簇中，找到距离 $d(A, B)$ 最小的那一对簇。
- 将这两个簇合并成一个新簇。

注意，到目前为止我们研究的所有聚类算法都是不稳定的：从数据集中删除或微调少数几个样本点，有时可能会导致聚类结果发生巨大变化。

卷积神经网络

Fri, 26 Sep 2025 05:56:29 GMT

卷积神经网络

1. 概述

$a.$ 基本概念

卷积神经网络 (Convolutional Neural Networks) 的灵感来源于图像处理中的“边缘检测器”：

局部性 (Locality)：一个边缘检测器每次只观察图像的一小部分区域。
平移不变性 (Translation Invariance)：无论在图像的哪个位置，边缘检测的计算方式都是相同的。
可学习性 (Learnable)：这是CNNs最核心的创新——我们不再手动设计这些边缘检测器，而是让网络通过数据自己“学习”出这些检测器的最佳参数。

基于这些内容，CNN 被设计如下：

局部连接性 (Local Connectivity)：隐藏层中的一个单元（神经元）不再连接到前一层的所有单元（即整个图像），而是仅仅连接到一个小的局部区域，这个区域被称为“感受野”（receptive field）。这极大地减少了连接数量，从而显著提升了训练和分类的速度。
权重共享 (Shared Weights)：一组隐藏单元共享同一套权重参数。这套共享的权重被称为滤波器 (filter)，也叫卷积核 (kernel) 或掩码 (mask)。这个卷积核会像一个滑动的窗口，在整个图像的每一个局部区域（patch）上进行相同的运算。当一个卷积核滑过整个图像后，会生成一张激活图 (activation map)。激活图上的每一个值，都代表了该卷积核在图像对应位置的“激活”程度（即特征的匹配程度）。

现实中的 CNN 的结构通常会更复杂一些，添加了如下的组件：

多滤波器：一个卷积层通常会学习多个不同的滤波器。每个滤波器负责检测一种特定的特征（如一个滤波器学习检测水平边缘，另一个学习检测垂直边缘，还有一个可能学习检测绿色斑点等）。每个滤波器都会生成一张独立的激活图。
通道 (Channel)：一张激活图就是一个通道。因此，如果一个卷积层有 C_out 个滤波器，它的输出就会有 C_out 个通道。
多输入通道：同样，输入数据也可以是多通道的。最典型的例子就是彩色图像，它天然就包含红(R)、绿(G)、蓝(B)三个通道。

CNN 的权重共享设计具有如下的优势：

参数数量急剧下降，使得模型更轻量。
有效的正则化：因为一个权重被用于图像的很多不同位置，它不太可能为了拟合某个局部的噪声而变得异常大，从而提高了模型的泛化能力。
特征学习的效率：如果一个滤波器在图像的某个部分学会了检测“边缘”这个特征，它就能自动地在图像的所有其他部分检测边缘，因为它被应用到了每一个位置。CNNs正是利用了图像、音频等数据中这种普遍存在的重复结构。

$b.$ 一个实际的例子

Yann LeCun的LeNet-5是一个成功的 CNN 案例，它拥有6个隐藏层的深度网络，交替使用了：

卷积层 (Convolutional Layers)：用于特征提取。
池化/子采样层 (Pooling/Subsampling Layers)：用于降低图像尺寸，进一步减少参数并提供一定程度的平移不变性。
全连接层 (Fully-connected Layers)：在网络末端，用于根据提取到的高级特征进行最终的分类。

2. CNN 相关参数计算

我们考虑一个卷积层 $l$ ，首先定义如下的变量：

$C^{(l-1)}$ : 第 $l-1$ 层（即当前层的输入）的通道数 channels in。
$C^{(l)}$ : 第 $l$ 层（即当前层）的输出通道数 channels out。这个数量也等于当前层所拥有的滤波器数量。
$M$ : 卷积核的边长（假设为 $M x M$ 的方形卷积核）。
$J \times K$ : 输入图像或输入特征图的尺寸。

则：

每个滤波器的权重数量： $C^{(l-1)} × M × M$
整个卷积层的权重数量： $C^{(l-1)} × C^{(l)} × M × M$ ：即“每个卷积核的权重数量”乘以“卷积核的总数”。
输出单元的数量： $C^{(l)} × (J − M + 1) × (K − M + 1)$ ：即“卷积核数量”乘以“特征图尺寸”。

3. 信息压缩与下采样

在像 LeNet-5 这样的网络末端，我们需要将庞大的图像信息最终压缩到只有10个输出单元（对应10个数字类别）。经验表明，最好的方法是通过一系列层来逐步、缓慢地压缩信息，而不是将一个非常大的隐藏层直接连接到小小的输出层。

$a.$ 池化

池化 (Pooling) 的核心思想是用一个值来概括一个小邻域内的信息，从而降低特征图的尺寸。有最大池化和平均池化两种形式。

最大池化在一个小的窗口内，只取其中的最大值作为输出。

最大池化保留了每个小区域内最显著的特征。这相当于在问：“在这个小区域里，我最想找的那个特征出现了吗？它的响应强度有多大？”

平均池化与最大池化类似，但它不是取最大值，而是计算窗口内所有数值的平均值作为输出。

池化操作是固定的（取最大或取平均），因此它没有任何需要通过训练学习的参数。这使得它计算开销很小。但在训练时，梯度仍然需要通过池化层进行反向传播。对于最大池化，梯度只会传给那个被选为最大值的单元。

$b.$ 步幅卷积

步幅卷积 (Strided Convolution) 是另一种实现下采样的方法，它将下采样和卷积操作合二为一：它让卷积核每次移动超过1个像素（如步长为2）。

$c.$ 全连接层

在经过多轮的“卷积 $\rightarrow$ 激活 $\rightarrow$ 池化/步幅卷积”操作后，我们得到了一组高度抽象的特征图。在网络的最后阶段，我们需要根据这些特征进行分类。这一步即由全连接层来完成：

展平 (Flatten)：全连接层的第一步是将最后一个卷积/池化层输出的多维特征图（如尺寸为 7x7x512）“压平”或“展平”，变成一个一维的长向量（长度为 77512 = 25088）。
连接与分类：这个长向量随后被送入一个或多个标准的全连接层（也叫密集层，Dense Layer）。
Softmax激活函数：在最后的分类层，通常使用 Softmax 激活函数。它的作用是将输出层的数值转换成一个概率分布，每个数值代表输入图像属于某个特定类别的概率（所有概率值相加为1）。

为了提升CNN的性能和训练稳定性，通常还会加入批归一化层和 Dropout 层。

Homework6 Code Part1

Thu, 25 Sep 2025 15:07:15 GMT

Homework 6 Part1

由于 Homework 6 的笔记内容有些多，我把它拆分成三部分了。

Part1 的内容是从零实现 Neural Nets 的相关组件。

1. 总体架构

作业初始代码的总体架构如下：

models.py：神经网络模型实现：负责整个网络的前向传播、反向传播和训练循环
layers.py：网络层实现：实现全连接层、二维卷积层、一维批量归一化层的前向传播和反向传播方法。
activations.py：多种激活函数实现。
optimizers.py：多种优化器实现。
schedulers.py：学习率调度器实现。
losses.py：损失函数实现。
datasets.py：数据集管理实现：实现了对数据集的批处理、数据预处理（归一化、标准化）
weights.py：权重初始化策略实现。

下面具体讲解作业要求实现的代码和我自己写的一些辅助的代码文件。

2. 全连接层 `FullyConnected`

$a.$ `forward` 方法

全连接层的 forward 方法实现较简单，只需要计算下面的结果：

\psi^{[l]}\!\left(h^{[l-1]} W^{[l]} + b^{[l]}\right)

并将计算过程中的值存入缓存即可：

def forward(self, X: np.ndarray) -> np.ndarray:
    """Forward pass: multiply by a weight matrix, add a bias, apply activation.
    Also, store all necessary intermediate results in the `cache` dictionary
    to be able to compute the backward pass.
    """
    # initialize layer parameters if they have not been initialized
    if self.n_in is None:
        self._init_parameters(X.shape)

    W = self.parameters.get('W')
    b = self.parameters.get('b')
    Z = X @ W + b 

    # perform an affine transformation and activation
    Y = self.activation(Z)

    # store information necessary for backprop in `self.cache`
    self.cache['X'] = X
    self.cache['Z'] = Z 
    return Y

$b.$ `backward` 方法

在 backward 方法中，我们取出之前缓存的值，然后从后往前计算梯度，最终得到损失函数相对 $X$ 的梯度：

\begin{aligned} \frac{\partial L}{\partial Z} &= \phi'(Z)\odot\frac{\partial L}{\partial Y},\\ \frac{\partial L}{\partial W} &= X^{T}\,\frac{\partial L}{\partial Z},\\ \frac{\partial L}{\partial b} &= \sum_{i=1}^{m}\frac{\partial L}{\partial Z^{(i)}},\\ \frac{\partial L}{\partial X} &= \frac{\partial L}{\partial Z}\,W^{T}. \end{aligned}

这里注意 $b$ 的梯度计算：我们是通过在 axis=0 求和来计算 $b$ 的梯度的，因为 $b$ 在 forward 过程中被加到了 axis=1 的维度上，因此我们沿着除这个维度外的方向求和。

还有一个简单的判断方法： $\frac{\partial L}{\partial b}= \sum_{i=1}^{m}\frac{\partial L}{\partial Z^{(i)}}$ 这个式子是沿着 axis=1 的方向进行求和的（数据形状为 $(n,m)$ ）。

def backward(self, dLdY: np.ndarray) -> np.ndarray:
    """Backward pass for fully connected layer.
    Compute the gradients of the loss with respect to:
        1. the weights of this layer (mutate the `gradients` dictionary)
        2. the bias of this layer (mutate the `gradients` dictionary)
        3. the input of this layer (return this)
    """
    # unpack the cache
    X = self.cache.get('X')
    Z = self.cache.get('Z')
    W = self.parameters.get('W')
        
    # compute the gradients of the loss w.r.t. all parameters as well as the
    # input of the layer
    dLdZ = self.activation.backward(Z, dLdY)
    dLdW = X.T @ dLdZ
    dLdb = np.sum(dLdZ, axis=0, keepdims=True)
    dLdX = dLdZ @  W.T 

    # store the gradients in `self.gradients`
    # the gradient for self.parameters["W"] should be stored in
    # self.gradients["W"], etc.
    self.gradients['W'] = dLdW
    self.gradients['b'] = dLdb

    return dLdX

3. 批量归一化层 `BatchNorm1D`

$a.$ 原理概述

在批归一化层中，我们试着对网络中间的隐藏层 (hidden unit) 进行归一化处理。但是对于隐藏层，它的输出值是随着网络参数在训练过程中不断变化的，我们无法预先知道这些激活值的均值和方差。因此，批量归一化层被提出来了。

BN 本质上是在网络中增加了一个新的“层”，这个层会对前一层输出的激活值 $h$ 进行处理，然后将处理后的结果 $z$ 作为下一层的输入。这个处理过程在每次训练迭代（即每个小批量/minibatch）中动态进行。

首先，BN 会计算 minibatch 的统计数据。假设这些小批量数据包含 $B$ 个样本，通过隐藏层产生了 $B$ 个激活向量 $h$ 。BN 计算得出这些数据的均值 $\mu$ 和方差 $\sigma^2$ ：

\begin{aligned} \tilde{\mu}_i &= \frac{1}{B}\sum_{j=1}^{B} h_i^{(j)},\\ \tilde{\sigma}_i^2 &= \frac{1}{B}\sum_{j=1}^{B}\left(h_i^{(j)} - \tilde{\mu}_i\right)^2. \end{aligned}

利用上面计算出来的方差，BN 对当前 minibatch 的每个值进行归一化：

\tilde{h}_i = \frac{h_i - \tilde{\mu}_i}{\sqrt{\tilde{\sigma}_i^2 + \varepsilon}}

这里的 $\varepsilon$ 是一个很小的正数，防止分母为0。

不过，均值为0、方差为1的分布不一定是最好的分布，强制把每一层的输出都变成这样的标准分布可能会限制网络的表达能力。因此 BN 引入了两个可学习的参数 $\gamma$ 、 $\beta$ ，让网络自己去学习具体的分布：

z_i = \gamma_i\,\tilde{h}_i + \beta_i

同时，在训练时我们可以获取到 minibatch 的统计数据，但是在测试推理过程中，我们通常一次只处理一个样本，并没有 minibatch 这个东西。为了解决这个问题，在训练过程中，BN 会维护一个全局的统计量：移动平均均值 $\hat{\mu}$ 和移动平均方差 $\hat{\sigma}^2$ 。在每个批次的训练中，这些值都会按照如下方式更新：

\begin{aligned} \hat{\mu} &\leftarrow \alpha\,\tilde{\mu} + (1-\alpha)\,\hat{\mu},\\ \hat{\sigma}_i^2 &\leftarrow \alpha\,\tilde{\sigma}_i^2 + (1-\alpha)\,\hat{\sigma}_i^2. \end{aligned}

这里的 $\alpha$ 是一个衰减系数。这样，训练结束后， $\gamma$ 、 $\beta$ 、 $\hat{\mu}$ 、 $\hat{\sigma}^2$ 的值固定下来。对于新的测试样本，BN层会使用这些固定值进行计算。

同样地，既然这些值也需要进行学习，我们也像对待其他神经网络一样对它们进行 forward 和 backward。

$b.$ `forward` 方法

BN 的 forward 方法实现非常简单，只需要更新 $\mu$ 、 $\sigma ^ 2$ ，并使用这些值计算当前 minibatch 的 $\hat{X}$ 即可。

同时，根据前面所说，我们需要把训练和测试分开计算：

def forward(self, X: np.ndarray, mode: str = "train") -> np.ndarray:
    """ Forward pass for 1D batch normalization layer.
    Allows taking in an array of shape (B, C) and performs batch normalization over it.
    """
    # implement a batch norm forward pass
    if mode == 'train':
        mu = np.mean(X, axis=0, keepdims=True)  # Shape (1, n_features)
        sigma = np.var(X, axis=0, keepdims=True)  # Shape (1, n_features)
        
        # Update running statistics with exponential moving average
        # Note: running stats are initialized as zeros in _init_parameters
        self.cache['running_mu'] = self.momentum * self.cache['running_mu'] + (1 - self.momentum) * mu
        self.cache['running_var'] = self.momentum * self.cache['running_var'] + (1 - self.momentum) * sigma
            
    elif mode == 'test':
        mu = self.cache['running_mu']
        sigma = self.cache['running_var']
    else:
        raise ValueError('invalid mode str')

    X_hat = (X - mu) / np.sqrt(sigma + self.eps)

    # cache any values required for backprop
    self.cache['X'] = X
    self.cache['X_hat'] = X_hat
    self.cache['mu'] = mu.flatten() if mu.ndim > 1 else mu  # Keep 1D for backward compatibility
    self.cache['var'] = sigma.flatten() if sigma.ndim > 1 else sigma  # Keep 1D for backward compatibility

    gamma = self.parameters['gamma']
    beta = self.parameters['beta']

    Y = gamma * X_hat + beta

    return Y

$c.$ `backward` 方法

我们先列出反向传播的计算过程：

\begin{aligned} \mu_i &= \frac{1}{B}\sum_{j=1}^{B} X_i^{(j)} ,\\ \sigma_i^2 &= \frac{1}{B}\sum_{j=1}^{B}\left(X_i^{(j)}-\mu_i\right)^2,\\ \hat{X}_i^{(j)} &= \frac{X_i^{(j)}-\mu_i}{\sqrt{\sigma_i^2+\varepsilon}},\\ Y_i^{(j)} &= \gamma_i\,\hat{X}_i^{(j)} + \beta_i. \end{aligned}

我们先计算对缩放参数 $\gamma$ 和平移参数 $\beta$ 的梯度：

\begin{aligned} \frac{\partial L}{\partial \gamma_i} &= \sum_{j=1}^{B}\frac{\partial L}{\partial Y_i^{(j)}}\,\hat{X}_i^{(j)},\\ \frac{\partial L}{\partial \beta_i} &= \sum_{j=1}^{B}\frac{\partial L}{\partial Y_i^{(j)}}. \end{aligned}

将上游梯度传回标准化输出 $\hat{X}$ ：

\begin{aligned} \frac{\partial L}{\partial \hat{X}_i^{(j)}} &= \frac{\partial L}{\partial Y_i^{(j)}}\,\gamma_i. \end{aligned}

然后我们计算方差的梯度：

\begin{aligned} \frac{\partial L}{\partial \sigma_i^2} &= \sum_{j=1}^{B}\frac{\partial L}{\partial \hat{X}_i^{(j)}}\,(X_i^{(j)}-\mu_i)\left(-\frac{1}{2}\right)\left(\sigma_i^2+\varepsilon\right)^{-\frac{3}{2}}. \end{aligned}

然后我们计算均值的梯度：

\begin{aligned} \frac{\partial L}{\partial \mu_i} &= \sum_{j=1}^{B}\frac{\partial L}{\partial \hat{X}_i^{(j)}}\left(-\frac{1}{\sqrt{\sigma_i^2+\varepsilon}}\right) + \frac{\partial L}{\partial \sigma_i^2}\left(-\frac{2}{B}\sum_{j=1}^{B}\bigl(X_i^{(j)}-\mu_i\bigr)\right). \end{aligned}

现在我们开始计算 $X_i$ 的梯度来源。对于 $\hat{X_i}$ ，两边求梯度（这里采用不太严谨的写法）：

\nabla(\hat{X_i})=\frac{1}{\sqrt{\sigma_i^2+\varepsilon}}\nabla(X_i)

它贡献了 $\frac{1}{\sqrt{\sigma_i^2+\varepsilon}}$ 的权重。同样地，有：

\nabla(\sigma_i^2)=\frac{2}{B}(X_i-\mu_i)

\nabla(\mu_i)=\frac{1}{B}X_i

这里我们直接简略掉求和，在实际代码中，对于原先是 $\sum$ 的项，我们需要和前面对偏置项的梯度运算一样，使用 np.sum 对特定的 axis 求和。

于是我们得到 $X_i$ 相对损失函数最终的梯度计算式：

\begin{aligned} \frac{\partial L}{\partial X_i^{(j)}} &= \frac{\partial L}{\partial \hat{X}_i^{(j)}}\frac{1}{\sqrt{\sigma_i^2+\varepsilon}} + \frac{\partial L}{\partial \sigma_i^2}\frac{2}{B}\,(X_i^{(j)}-\mu_i) + \frac{1}{B}\,\frac{\partial L}{\partial \mu_i}. \end{aligned}

同时需要注意：参数 dY 是通过激活层后的梯度，因此要得到 $dY_i$ 需要先从激活层反向传播。

def backward(self, dY: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
    """
    Backward method for batch normalization layer. You don't need to implement this to get full credit, although it is
    fun to do so if you have the time.
    """

    X = self.cache['X']
    X_hat = self.cache['X_hat']
    mu = self.cache['mu']
    var = self.cache['var']
    gamma = self.parameters['gamma']
    batch_size = X.shape[0]

    # implement backward pass for batchnorm.
    dGamma = np.sum(dY * X_hat, axis=0)
    dBeta = np.sum(dY, axis=0)
    dX_hat = dY * gamma
    dVar = np.sum(dX_hat * (X - mu) * (-0.5) * (var + self.eps)**(-1.5), axis=0)
    dMu = (np.sum(dX_hat * (-1.0 / np.sqrt(var + self.eps)), axis=0) +
               dVar * np.sum(-2.0 * (X - mu), axis=0) / batch_size)
    dX = (dX_hat / np.sqrt(var + self.eps) +
              dVar * 2.0 * (X - mu) / batch_size +
              dMu / batch_size)
        
    self.gradients["gamma"] = dGamma
    self.gradients["beta"] = dBeta
    ### END YOUR CODE ###
        
    return dX

4. 卷积层 `Conv2D`

$a.$ 卷积层原理概述

在阐释具体原理前，我们先明确符号定义：

$X$ ：网络的输入，通常是一个图像张量（多维数组）。它的形状是 $d_1 \times d_2 \times c$ ，其中 $d_1$ 、 $d_2$ 是图像的空间维度（高度和宽度）， $C$ 是通道数。对于彩色图片而言， $C$ 通常为 3,表示红、绿、蓝三种颜色的强度。
$\hat{y}$ ：网络的输出，通常是一个形状为 $1 × k$ 的向量（ $k$ 是类别的数量）。
$n^{[l]}$ ：第 $l$ 层的通道数。这也被称为滤波器的数量（见 cnn 笔记内容）。
$(k1, k2)^{[l]}$ ：第 $l$ 层的卷积核大小。
$W^{[l]}$ ：一个四维张量，它包含了第 $l$ 层所有的滤波器。它的形状是 $k_1 × k_2 × n^{[l-1]} × n^{[l]}$ 。
$b^{[l]}$ ：第 $l$ 层的偏置向量，形状为 $1 × n^{[l]}$ 。每个滤波器对应一个偏置值。
$H^{[l]}$ : 第 $l$ 层的输出。它是一个形状为 $r_1 × r_2 × n^{[l]}$ 的张量。 $(r_1, r_2)$ 是卷积操作后输出的空间尺寸，之后会详细讲解它的计算方法。
$ψ^{[l]}(\cdot)$ : 应用在第 $l$ 层的非线性激活函数（如 ReLU）。

我们知道，在卷积层中，每个滤波器都会与输入图像的所有通道进行卷积。这个操作本质上是一个滑动式的、逐元素乘积之和。令 $Z_{d_1, d_2, n}$ 为在第 $n$ 个滤波器在 $(d_1, d_2)$ 位置的输出，则有：

Z_{d_1, d_2, n} = (X \ast W)_{d_1, d_2, n} = \sum_{i} \sum_{j} \sum_{c} W_{i, j, c, n} X_{d_1 + i, d_2 + j, c} + b_n

这个式子看起来很复杂，在之后的代码实现中会详细讲解怎么将这个东西向量化的。

这一操作其实并不是数学意义上的卷积，而是互相关操作：我们使用卷积核，在输入图像上从左到右、从上到下地滑动。在每一个位置，我们计算卷积核和它所覆盖的图像区域有多么“匹配”。而特征图就是我们匹配后的输出，它是一张新的“地图”，图上的每个点的值代表了卷积核与原始图像在该点的匹配程度。值越高，说明匹配得越好。

在上面的公式中，我们是每次将滤波器在图像上移动一个像素。我们也可以选择更大的移动步长 stride。

卷积层的最终输出 $H^{[l]}$ 是将特征图 $Z^{[l]}$ 通过激活函数 $\phi^{[l]}$ 得到的：

H^{[l]} = \phi^{[l]}(Z^{[l]})

$b.$ 池化层原理概述

池化层用于对输入的特征图进行下采样 (downsample)。它接收一个形状为 $d_1 × d_2 × n$ 的输入数组，输出一个形状为 $r_1 × r_2 × n$ 的数组。

池化操作也有一个核（尺寸为 $k_1 × k_2$ ）和一个步长 $s$ 。对于输入的每个通道，我们取 $k_1 × k_2$ 窗口内的所有点的最大值或平均值。然后，我们将这个窗口滑动 $s$ 个像素，重复此过程，直到处理完整个特征图。

同样地，池化层的输出计算如下：

\begin{aligned} Z_{r_1, r_2, c} &= \operatorname{MaxPool}(X)_{r_1, r_2, c} \\ &= \max_{0 \le i < k_1,\; 0 \le j < k_2} X_{r_1 s + i,\; r_2 s + j,\; c} \end{aligned}

传统的 CNN 通过交替组合卷积层和池化层来处理图像。这个过程会逐步地“压缩”输入的空间尺寸，同时通过卷积层提取越来越复杂的特征（通道数 $n$ 通常会增加）。当特征图的空间尺寸变得足够小时，就将其展平（flatten），送入一个或多个全连接网络层 (fully-connected layers)，最终进行分类或回归任务。

$c.$ `forward` 方法

直接翻译卷积层的 forward 计算，我们直接

def convolution_forward_loops(X, W, b, pad, stride):
    pad_h, pad_w = pad
    k_h, k_w, in_channels, out_channels = W.shape
    n_examples, in_rows, in_cols, _ = X.shape

    out_rows = (in_rows + 2 * pad_h - k_h) // stride + 1
    out_cols = (in_cols + 2 * pad_w - k_w) // stride + 1

    X_padded = np.pad(
        X,
        ((0, 0), (pad_h, pad_h), (pad_w, pad_w), (0, 0)),
        mode='constant',
        constant_values=0
    )

    out = np.zeros((n_examples, out_rows, out_cols, out_channels))


    for n in range(n_examples):
        for h_out in range(out_rows):
            for w_out in range(out_cols):
                h_start = h_out * stride
                h_end = h_start + k_h
                w_start = w_out * stride
                w_end = w_start + k_w

                input_slice = X_padded[n, h_start:h_end, w_start:w_end, :]

                for c_out in range(out_channels):
                    kernel_slice = W[:, :, :, c_out]
                    out[n, h_out, w_out, c_out] = np.sum(input_slice * kernel_slice)
    out += b

    return out

这个循环十分低效，它通过循环提取 input_slice。而向量化的目标是一次性地准备好所有的 input_slice，然后用一次计算完成所有的点积。为了实现这个，我们可以将卷积操作转化为一个单一、巨大的矩阵乘法问题。

首先，在 numpy 中，一个数组（或矩阵）由下面这些性质决定：

shape：决定数组的形状。
stride：决定要移动多少个字节才能到达下一个维度的下一个元素。

因此，我们创建一个包含滑动窗口所有要素的数组作为我们的 shape：

view_shape=(n_examples, out_rows, out_cols, k_h, k_w, in_channels)

为什么要包含所有要素呢？因为之后我们就要用这个 shape 的矩阵做计算了，因此必须把这些都准备好。

然后，我们定义这些维度的移动规则：

s_n, s_r, s_c, s_ch = X_padded.stride
view_strides = (s_n, s_r * stride, s_c * stride, s_r, s_c, s_ch)

对 k_h 而言，一次只移动 s_r 步；而对于实际的 out_rows，移动的距离需要乘以步长 stride。

然后我们就可以构建出包含所有窗口的窗口矩阵了：

X_windows = np.lib.stride_tricks.as_strided(
    X_padded, 
    shape=view_shape, 
    strides=view_strides
)

构造完成窗口矩阵后，我们需要用这个矩阵和权重矩阵 $W$ 进行运算。我们使用 np.einsum 来进行乘法运算。einsum 能够找到两个张量共享的维度标签、沿着这些标签进行元素级别的乘法。

对于那些只出现在输入部分而没有出现在输出部分的标签，einsum 会将乘法结果沿着这些维度求和。
对于那些同时出现在输入和输出部分的标签，einsum 会保留这些维度。

综上，我们得到最终向量化的运算代码（也就是作业中要求的 "must operate on minibatches of data"）：

def forward(self, X: np.ndarray) -> np.ndarray:
    """Forward pass for convolutional layer. This layer convolves the input
    `X` with a filter of weights, adds a bias term, and applies an activation
    function to compute the output. This layer also supports padding and
    integer strides. Intermediates necessary for the backward pass are stored
    in the cache.
    """
    if self.n_in is None:
        self._init_parameters(X.shape)

    W = self.parameters["W"]
    b = self.parameters["b"]
    pad_h, pad_w = self.pad
    stride = self.stride

    k_h, k_w, in_channels, _ = W.shape
    n_examples, in_rows, in_cols, _ = X.shape 

    out_rows = (in_rows + 2 * pad_h - k_h) // stride + 1 
    out_cols = (in_cols + 2 * pad_w - k_w) // stride + 1 

    X_padded = np.pad(
        X,
        ((0, 0), (pad_h, pad_h), (pad_w, pad_w), (0, 0)),
        mode='constant'
    )

    view_shape = (n_examples, out_rows, out_cols, k_h, k_w, in_channels)
    s_n, s_r, s_c, s_ch = X_padded.strides
    view_strides = (s_n, s_r * stride, s_c * stride, s_r, s_c, s_ch)

    X_windows = np.lib.stride_tricks.as_strided(
        X_padded, 
        shape=view_shape, 
        strides=view_strides
    )

    out = np.einsum('nhwkij,kijo->nhwo', X_windows, W)
    out += b 

    self.cache['X'] = X 
    self.cache['Z'] = out
    out = self.activation.forward(out)

    return out

$d.$ `backward` 方法

同样地，我们以 CNN 在激活层前的输出为起点：

\delta_{n,r,c,o} \;=\; \frac{\partial Z_{n,r,c,o}}{\partial L}

卷积层的权重、偏执以及输入梯度的计算比较简单，它是由卷积核和原有图像矩阵窗口直接相乘得到的，和全连接层的区别只在于卷积核需要滑动窗口：

对偏置项，每个卷积核有自己的偏置项，我们沿着除 out_channels 进行求和：

\frac{\partial L}{\partial b_{o}} = \sum_{n=1}^{N}\sum_{r=1}^{R_{\mathrm{out}}}\sum_{c=1}^{C_{\mathrm{out}}}\delta_{n,r,c,o}

对权重矩阵，有：

\frac{\partial L}{\partial W_{i,j,k,o}} = \sum_{n=1}^{N}\sum_{r=1}^{R_{\mathrm{out}}}\sum_{c=1}^{C_{\mathrm{out}}} X^{(\mathrm{pad})}_{\,n,\,r\cdot s + i,\,c\cdot s + j,\,k}\; \delta_{n,r,c,o}

输入矩阵的处理比较复杂，有：

\begin{aligned} \frac{\partial L}{\partial X_{n,h,w,k}} &= \sum_{i=1}^{K_h}\sum_{j=1}^{K_w}\sum_{o=1}^{O} U^{(\mathrm{pad})}_{\,n,\,h+i,\,w+j,\,o}\; \bigl(W^{\mathrm{rot}}\bigr)^{T}_{\,i,j,o,k}. \end{aligned}

在计算 $X$ 的梯度时，我们需要对 $W$ 进行翻转与转置。其中插值上采样 (Upsampling with Zeros) 后的矩阵 $U$ ：

U_{n,u_r,u_c,o} = \begin{cases} \displaystyle \delta_{n,r,c,o}, & \text{if } u_r = r\cdot s,\; u_c = c\cdot s \text{ for some } r,c,\\[6pt] 0, & \text{otherwise.} \end{cases}

这里的公式看起来有些复杂，并且有一些在 forward 中没有的翻转和转置操作，下面我们逐一详解。

首先是权重矩阵的翻转。我们回到前向传播的公式：

Z_{h,w,o} \;=\; \sum_{i=0}^{K_h-1}\sum_{j=0}^{K_w-1}\sum_{k=1}^{C_{\text{in}}} X_{\,h+i,\,w+j,\,k}\;W_{\,i,\,j,\,k,\,o}

在前向传播中，输出位置 $(h,w)$ 用到的输入为 $(h+i,w+j)$ ，核索引为 $p=(h+i),q=(w+j)$ 。

而在反向传播中，输入矩阵的梯度计算如下：

\frac{\partial L}{\partial X_{p,q,k}} = \sum_{h}\sum_{w}\sum_{o} \frac{\partial L}{\partial Z_{h,w,o}}\;W_{\,p-h,\,q-w,\,k,\,o}

可以发现，我们的核索引变成了 $p-h, q-w$ 。我们需要把前向传播的 $+i,+j$ 转换成后向传播的 $-h,-w$ ，也就是把矩阵进行翻转。

然后是转置操作，这个操作比较容易理解：在前向传播中，我们的权重矩阵 $W$ 将 in_channels 映射到 out_channels 中；而在反向传播中，我们需要把 out_channels 的结果“倒流”回 in_channels 中，因此这两个维度在反向传播中需要转置。

最后是插值上采样过程。在前向传播的卷积过程中，由于卷积核可能会用大于 1 的步长进行卷积，输出空间会变得更加稀疏。这导致了：

输入的位置比输出更多。
前向过程中，stride 跳过了一部分位置。

于是我们需要“复原”前向传播时的跳格子操作——靠在 dLdZ 的格子之间插零来扩展成跟 stride=1 一样的稠密网格。

综合这些推导和前面的“构建大矩阵”的操作，可以写出如下的向量化实现：

def backward(self, dLdY: np.ndarray) -> np.ndarray:
    """Backward pass for conv layer. Computes the gradients of the output
    with respect to the input feature maps as well as the filter weights and
    biases.
    """

    X = self.cache['X']
    Z = self.cache['Z']
    W = self.parameters['W']
    pad_h, pad_w = self.pad
    stride = self.stride
    k_h, k_w = self.kernel_shape
    _, _, in_channels, _ = W.shape

    dLdZ = self.activation.backward(Z, dLdY)
    n_examples, out_rows, out_cols, out_channels = dLdZ.shape
    dLdb = np.sum(dLdZ, axis=(0, 1, 2))
    self.gradients['b'] = dLdb

    X_padded = np.pad(
        X,
        ((0, 0), (pad_h, pad_h), (pad_w, pad_w), (0, 0)),
        mode='constant'
    )

    view_shape = (n_examples, out_rows, out_cols, k_h, k_w, in_channels)
    s_n, s_r, s_c, s_ch = X_padded.strides
    view_strides = (s_n, s_r * stride, s_c * stride, s_r, s_c, s_ch)
    X_windows = np.lib.stride_tricks.as_strided(
        X_padded,
        shape=view_shape,
        strides=view_strides
    )

    dLdW = np.einsum('nhwijk,nhwo->ijko', X_windows, dLdZ)
    self.gradients['W'] = dLdW

    W_rot = np.rot90(W, 2, axes=(0, 1))
    W_transposed = W_rot.transpose(0, 1, 3, 2)
    if stride > 1:
        unsampled = np.zeros(
                        (n_examples, 
                        (out_rows - 1) * stride + 1,
                        (out_cols - 1) * stride + 1,
                        out_channels)
                    )
        unsampled[:, ::stride, ::stride, :] = dLdZ
    else:
        unsampled = dLdZ 

    unsampled_padded = np.pad(
        unsampled, 
        ((0,0), (k_h - 1 - pad_h, k_h - 1 - pad_h), (k_w - 1 - pad_w, k_w - 1 - pad_w), (0, 0)),
        mode='constant'
    )

    _, in_rows, in_cols, _ = X.shape 
    dLdZ_view_shape = (n_examples, in_rows, in_cols, k_h, k_w, out_channels)
    u_s_n, u_s_r, u_s_c, u_s_ch = unsampled_padded.strides
    dLdZ_view_strides = (u_s_n, u_s_r, u_s_c, u_s_r, u_s_c, u_s_ch)
    dLdZ_windows = np.lib.stride_tricks.as_strided(
        unsampled_padded,
        shape=dLdZ_view_shape,
        strides=dLdZ_view_strides
    )

    dLdX = np.einsum("nhwijo,ijok->nhwk", dLdZ_windows, W_transposed)
        
    return dLdX

除了前面所讲解的理论实现，在上面的代码中，还有如下的细节：

由于 $X$ 是输入层，因此 $\nabla X$ 的 channel 为 in_channels，而权重、偏置项的梯度计算中的 channel 为 out_channels。
插值上采样的代码实现中 unsampled 矩阵构造的参数需要一些简单的计算：
- 首先是这个矩阵的形状。通过简单的归纳推理可以得出：我们需要将现有矩阵放大 (out - 1) * stride + 1 才能恢复被 stride 缩放前的大小。
- 然后，我们要把原来每个 stride 卷积得到的值放回去，也就是 unsampled[:, ::stride, ::stride, :] = dLdZ。
注意插值上采样的 padding 过程。我们需要让卷积核覆盖所有的输入格点，因此 padding 的大小为 kernal_size - 1。但是原始的输入有自己的 padding pad_h、pad_w，我们需要把它删掉。
注意插值上采样的 stride 实现。和权重、偏置这些梯度求解不同，在求解 $X$ 的梯度时，我们需要遍历所有的输入格点、而不是以 stride 的步长遍历，因此上采样结果的 k_h 和 k_w 这两个 shape 的 stride 也设置为 s_r、s_c 而不是 s_r * stride、s_c * stride。

5. 池化层 `Pool2D`

$a.$ `forward` 方法

池化层的 forward 实现的具体细节和卷积层类似，不过需要注意：由于池化层是对卷积核进行池化的，因此我们需要对我们的窗口矩阵执行一次转置、把卷积核相关的维度放在最后。

def forward(self, X: np.ndarray) -> np.ndarray:
    """Forward pass: use the pooling function to aggregate local information
    in the input. This layer typically reduces the spatial dimensionality of
    the input while keeping the number of feature maps the same.

    As with all other layers, please make sure to cache the appropriate
    information for the backward pass.
    """
    # implement the forward pass
    n_examples, in_rows, in_cols, channels = X.shape
    k_h, k_w = self.kernel_shape
    pad_h, pad_w = self.pad
    stride = self.stride

    out_rows = (in_rows + 2 * pad_h - k_h) // stride + 1 
    out_cols = (in_cols + 2 * pad_w - k_w) // stride + 1 

    X_padded = np.pad(
        X,
        ((0, 0), (pad_h, pad_h), (pad_w, pad_w), (0, 0)),
        mode='constant'
    )

    view_shape = (n_examples, out_rows, out_cols, k_h, k_w, channels)
    s_n, s_r, s_c, s_ch = X_padded.strides
    view_strides = (s_n, s_r * stride, s_c * stride, s_r, s_c, s_ch)
    X_windows = np.lib.stride_tricks.as_strided(
        X_padded, 
        shape=view_shape, 
        strides=view_strides
    )

    # Rearrange to (N, out_H, out_W, C, k_H, k_W)
    X_windows_permuted = X_windows.transpose(0, 1, 2, 5, 3, 4)
        
    # Use the predefined pool_fn from __init__
    X_pool = self.pool_fn(X_windows_permuted, axis=(4, 5))
        
    # cache any values required for backprop
    self.cache = {
        "X_padded": X_padded,
        "X_windows": X_windows,   # (N,H_out,W_out,k_h,k_w,C)
        "out_rows": out_rows,
        "out_cols": out_cols,
    }
        
    # For max pooling, also store argmax information for backward pass
    if self.mode == "max":
        # Store mask indicating max positions for efficient backward pass
        max_mask = (X_windows_permuted == X_pool[:, :, :, :, None, None])
        self.cache["max_mask"] = max_mask

    return X_pool

$b.$ `backward` 方法

池化层的梯度传播如下：

平均池化层：梯度被平均分摊给池化窗口内的所有输入：

\frac{\partial L}{\partial X_{ij}} \;=\; \frac{\partial L}{\partial Y}\;\cdot\;\frac{1}{k_h k_w}

最大池化层：梯度只传递给池化窗口内取得最大值的那个输入：

\frac{\partial L}{\partial X_{ij}} = \begin{cases} \displaystyle \frac{\partial L}{\partial Y}, & \text{if } X_{ij} = X_{\max},\\[6pt] 0, & \text{if } X_{ij} < X_{\max}. \end{cases}

由于我们缓存了切分好的窗口，我们不需要像之前一样自己构建矩阵，直接使用缓存的窗口进行运算即可。

这里使用了一个优化简单的 for 循环求和的方法：我们可以先通过 np.arange 和 np.meshgrid 构建好索引初始值以及每步的跨度；然后把它 reshape 成矩阵的形状，就可以使用 np.add.at 一步完成相加操作了：

i_idx = np.arange(out_rows) * stride
j_idx = np.arange(out_cols) * stride
di = np.arange(k_h)
dj = np.arange(k_w)
ii, dii = np.meshgrid(i_idx, di, indexing='ij')
jj, djj = np.meshgrid(j_idx, dj, indexing='ij')

row_idx = ii + dii 
col_idx = jj + djj

row_idx = row_idx.reshape(1, out_rows, 1, k_h, 1, 1)
col_idx = col_idx.reshape(1, 1, out_cols, 1, k_w, 1)

n_idx = np.arange(n_examples).reshape(n_examples, 1, 1, 1, 1, 1)
c_idx = np.arange(in_channels).reshape(1, 1, 1, 1, 1, in_channels)

np.add.at(dLdX_padded, (n_idx, row_idx, col_idx, c_idx), grad_windows)

总体实现如下：

def backward(self, dLdY: np.ndarray) -> np.ndarray:
    """Backward pass for pooling layer.
    """
    # perform a backward pass
    X_padded = self.cache["X_padded"]
    X_windows = self.cache["X_windows"]
    out_rows, out_cols = self.cache["out_rows"], self.cache["out_cols"]
    k_h, k_w = self.kernel_shape
    stride = self.stride
    pad_h, pad_w = self.pad
    n_examples, _, _, in_channels = X_padded.shape

    dLdX_padded = np.zeros_like(X_padded)

    if self.mode == 'max':
        # Use precomputed max_mask if available, otherwise compute it
        if "max_mask" in self.cache:
            max_mask = self.cache["max_mask"]  # (N, out_H, out_W, C, k_H, k_W)
            # Transpose back to match X_windows shape: (N, out_H, out_W, k_H, k_W, C)
            mask = max_mask.transpose(0, 1, 2, 4, 5, 3).astype(np.float32)
        else:
            # Fallback to computing mask from X_windows
            mask_vals = np.max(X_windows, axis=(3, 4), keepdims=True)
            mask = (X_windows == mask_vals).astype(np.float32)
            
        # Handle ties by normalizing the mask
        mask_sum = np.sum(mask, axis=(3, 4), keepdims=True)
        mask /= (mask_sum + 1e-8)

        dLdY_exp = dLdY[:, :, :, None, None, :] # (batch_size, out_rows, out_cols, k_h, k_w, channels)
        grad_windows = mask * dLdY_exp
    elif self.mode == 'average':
        avg_factor = 1.0 / (k_h * k_w)
        dLdY_exp = dLdY[:, :, :, None, None, :] * avg_factor
        grad_windows = np.broadcast_to(dLdY_exp, X_windows.shape)
        
    i_idx = np.arange(out_rows) * stride
    j_idx = np.arange(out_cols) * stride
    di = np.arange(k_h)
    dj = np.arange(k_w)
    ii, dii = np.meshgrid(i_idx, di, indexing='ij')
    jj, djj = np.meshgrid(j_idx, dj, indexing='ij')

    row_idx = ii + dii 
    col_idx = jj + djj

    row_idx = row_idx.reshape(1, out_rows, 1, k_h, 1, 1)
    col_idx = col_idx.reshape(1, 1, out_cols, 1, k_w, 1)

    n_idx = np.arange(n_examples).reshape(n_examples, 1, 1, 1, 1, 1)
    c_idx = np.arange(in_channels).reshape(1, 1, 1, 1, 1, in_channels)

    np.add.at(dLdX_padded, (n_idx, row_idx, col_idx, c_idx), grad_windows)
    if pad_h == 0 and pad_w == 0:
        gradX = dLdX_padded
    else:
        gradX = dLdX_padded[:, pad_h:-pad_h, pad_w:-pad_w, :]

    return gradX

这里有一个实现的细节：在卷积层中，对于输入信息我们只缓存了 X；而在池化层中，我们需要缓存 X_window（max_mask 可缓存可不缓存，如果不缓存的话重新计算一下即可）。这是因为在卷积层中，我们只需输入+权重即可重建所有需要的局部卷积窗口。；但是在池化层中，我们必须明确知道窗口内部“谁贡献了输出”，而这些信息没法仅从原始 $X$ 推回去，必须提前保存。

6. 损失层

损失层实现了交叉熵损失函数的 forward 方法和 backward 方法。

$a.$ `forward` 方法

交叉熵函数的前向传播只需要计算一次交叉熵：

L=-\frac{1}{N}\sum_{i=1}^N\sum_{k=1}^C Y_{i,k}\ln(\hat Y_{i,k}+\varepsilon),

def forward(self, Y: np.ndarray, Y_hat: np.ndarray) -> float:
    """Computes the loss for predictions `Y_hat` given one-hot encoded labels
    """
    return -np.mean(np.sum(Y * np.log(Y_hat + 1e-15), axis=1))

$b.$ `backward` 方法

对 $\hat{Y}$ 求梯度即可：

\frac{\partial L}{\partial \hat{Y}} = -\frac{1}{N}\,\frac{Y}{\hat{Y} + \varepsilon}

def backward(self, Y: np.ndarray, Y_hat: np.ndarray) -> np.ndarray:
    """Backward pass of cross-entropy loss.
    """
    return -Y / (Y_hat + 1e-15) / Y_hat.shape[0]

7. 最终的神经网络层

$a.$ `forward` 方法

逐个调用每个层的 forward 方法即可。

def forward(self, X: np.ndarray) -> np.ndarray:
    """One forward pass through all the layers of the neural network.
    """
    out = X
    for layer in self.layers:
        out = layer.forward(out)
    return out

$b.$ `backward` 方法

我们计算出当前的损失、并逐个调用每个层的 backward 方法。

def backward(self, target: np.ndarray, out: np.ndarray) -> float:
    """One backward pass through all the layers of the neural network.
    During this phase we calculate the gradients of the loss with respect to
    each of the parameters of the entire neural network. Most of the heavy
    lifting is done by the `backward` methods of the layers, so this method
    should be relatively simple. Also make sure to compute the loss in this
    method and NOT in `self.forward`.
    """
    loss = self.loss.forward(target, out)
    dL = self.loss.backward(target, out)
    for layer in reversed(self.layers): # go backwards
        dL = layer.backward(dL)
    return loss

cs289-hw6

Thu, 25 Sep 2025 12:52:28 GMT

Write your blog post content here using Markdown.

Introduction

Add your introduction here.

Main Content

Add your main content here.

Conclusion

Add your conclusion here.

神经网络训练

Thu, 25 Sep 2025 03:50:27 GMT

生成：Gemini-2.5-pro，整理：fyerfyer

神经网络训练

1. 神经生物学基础

人工神经网络的许多核心概念都源于对生物大脑工作方式的模仿。通过对比生物神经系统，我们可以更深刻地理解人工神经网络的设计哲学。

大脑的基本计算单元是神经元 (Neuron)，它是一个负责处理和传递信息的细胞：

神经元 (Neuron)：大脑和神经系统的基本构成单位，负责思考与通讯。
动作电位 (Action Potential / Spike)：神经元用于与其他神经元交流的电化学脉冲信号。当一个神经元要传递信息时，它会“放电”或发射一个脉冲。
轴突 (Axon)：神经元上负责传出信号的“输出线”，动作电位沿着它传播。
树突 (Dendrite)：神经元上负责接收信号的“输入线”，呈树枝状。
突触 (Synapse)：一个神经元的轴突末梢与另一个神经元的树突相连接的“接头”，是信息传递的关键节点。
神经递质 (Neurotransmitter)：当动作电位到达轴突末梢时，会释放这种化学物质。它穿过突触间隙，与下一个神经元的树突上的受体结合，从而影响下一个神经元的电压，决定其是否也产生一次“放电”。这个过程在1到5毫秒内完成。

可以将我们的人工神经网络与生物大脑进行如下类比：

生物大脑概念	人工神经网络 (ANN) 概念	详细说明
神经元放电频率	单元的输出值	生物神经元的放电是“全或无”的，信息通过放电频率编码（如1000次/秒代表强信号"1"）。这对应ANN中一个节点的连续输出值（如0.9）。
突触强度	连接的权重 (Weight)	生物突触的连接强度决定了其对下游神经元的影响力大小。这直接对应ANN中连接的权重值。
兴奋性/抑制性神经递质	正/负权重	兴奋性递质促进放电，类似正权重；抑制性递质（如GABA）抑制放电，类似负权重。ANN的优势在于权重可以自由地在正负间变化。
输入的时空累加	输入的线性组合	生物神经元整合所有输入信号，当累积电压超过阈值时才放电。这对应ANN中对所有输入进行加权求和（ $\sum w_i x_i$ ）。
放电频率饱和	激活函数 (Sigmoid/ReLU)	生物神经元的放电频率有物理上限（如<1000Hz）和下限(0Hz)。这对应ANN中使用激活函数将输出值压缩到特定范围（如[0, 1]），防止输出无限增大。

2. 学习机制的对比

$a.$ 赫布法则

大脑学习的生物学基础被认为是突触可塑性 (Synaptic Plasticity)，即突触的连接强度是可变的。赫布法则 (Hebb's Rule) 对此做出了经典概括：

"Cells that fire together, wire together."

这意味着，如果一个神经元的放电总是能促使另一个神经元也放电，它们之间的兴奋性连接就会增强。基于赫布法则的算法虽然存在，但其学习速度和效果远不如反向传播。

反向传播是现代神经网络训练的核心算法。然而，它在生物学上的真实性备受质疑。

尽管有一些理论试图解释大脑中可能存在类似反向传播的机制，但这些解释都非常牵强。大脑真正的学习机制至今仍未被完全理解。计算机科学家研究神经生物学是为了获取灵感来改进算法，而神经学家研究ANN则是为了构建数学模型来理解大脑。

3. 训练加速优化

$a.$ 优化算法的选择

批量梯度下降 (Batch GD)：每一步都使用整个训练集来计算梯度。方向准确，但速度慢，内存开销大。
随机梯度下降 (Stochastic GD, SGD)：每一步只用一个随机样本来计算梯度。速度快，但更新方向非常不稳定，“嘈杂”。
小批量随机梯度下降 (Mini-batch SGD)：这是目前最主流的方法，是上述两者的折中。

每次更新使用一个大小为 $b$ （如 $b=256$ ）的小批量数据来计算梯度。

w \leftarrow w - \epsilon \nabla J_{minibatch}(w)

小批量SGD的优势如下:

收敛更稳定快速：通过平均一个小批量样本的梯度，降低了更新的方差（约为纯SGD的 $1/\sqrt{b}$ ），使得收敛路径更平滑。
高效利用硬件：不同样本的梯度计算是独立的，极易在GPU上进行并行化和向量化处理，极大提升计算效率。
优化内存访问：将小批量数据在内存中连续存放，可以高效利用CPU/GPU的缓存，分摊数据加载的开销。训练64个样本的速度可能和训练1个样本相差无几。

下面是一些在实际训练过程的注意事项：

在每个epoch开始前，应随机打乱整个训练集。

确保小批量是训练集的代表性抽样。对于不平衡数据集，可以采用分层采样，确保每个小批量中的类别比例与整体一致。

最佳学习率 $\epsilon$ 与批量大小 $b$ 相关，调整 $b$ 后通常需要重新寻找最佳 $\epsilon$ 。

$b.$ 学习率 $\epsilon$ 的选择

寻找最佳学习率可能非常耗时。一个非常实用的技巧是：使用一小部分随机抽样的训练数据来快速测试和估算一个好的学习率，然后将这个学习率应用到整个训练集上。实践表明，最佳学习率对训练集的大小并不十分敏感。

$c.$ 样本加权方案

神经网络会很快学会常见样本，而对稀有样本学得很慢。加权方案旨在解决此问题：

动机：强制模型关注那些稀有的、或被错误分类的样本。
方法：
- 对于SGD：可以更频繁地从稀有类别中抽样，或者在训练这些样本时使用更大的学习率 $\epsilon$ 。
- 对于Batch GD：在总代价函数中，为来自稀有类别的样本损失赋予更大的权重。

这一方法在处理类别极不平衡的数据时（如罕见病检测）非常有效，可以防止模型“偷懒”只预测多数类。

注意，此方法也可能放大“坏的异常值”（如错误标注的样本）的影响，导致模型学到错误信息，需要谨慎使用。

$d.$ 数据标准化

这是几乎所有情况下都推荐的数据预处理步骤。标准化常用的方法如下：

中心化 (Center)：对每个特征，减去其均值，使其均值为0。
缩放 (Scale)：对每个特征，除以其标准差，使其方差为1。

我们需要标准化的原因如下：

激活函数的有效区域：激活函数（如Sigmoid）的非线性区域通常在输入接近0的地方。标准化使得第一层隐藏单元的输入更容易落在这个有效区域，从而让网络更有效地学习。
改善代价函数的形状：标准化可以改善代价函数海森矩阵的条件数，将一个狭长的“山谷”地形（ill-conditioned）变得更像一个圆形的“碗”（well-conditioned），梯度下降可以更顺畅地走向最低点，从而加速收敛。
公平的正则化：如果使用L2正则化，标准化可以确保对所有特征的惩罚是公平的。

注意：在训练集上应用的任何标准化变换（减去的均值、除以的标准差），之后在验证集和测试集上也必须应用完全相同的变换。

$e.$ 权重初始化

正确的权重初始化对深度网络的训练至关重要。前面讲到了随机初始化权重以打破对称性。但初始值太小会导致梯度消失，太大则会导致梯度爆炸。于是，我们采用下面的权重初始化策略：

基本原则：一个单元的输出方差，应与其输入的方差保持一致。
经验法则 为了实现这一原则，我们设 $\eta_{in}$ $η_{in}$ 为一个单元的输入连接数 (fan-in)，则：
- ReLU 单元: He 初始化。从均值为0，方差为 $2/\eta_{in}$ 的正态分布 $\mathcal{N}(0, 2/\eta_{in})$ 或相应范围的均匀分布中采样。
- tanh 或线性单元: Xavier/Glorot 初始化。从均值为0，方差为 $1/\eta_{in}$ 的正态分布 $\mathcal{N}(0, 1/\eta_{in})$ 或相应范围的均匀分布中采样。

一个神经元的输入越多（fan-in越大），它接收到的信号总和就越大。为了平衡这一点，我们需要让每个输入的权重变得更小一些。所以，初始化的公式通常都包含除以扇入（或其变体）的操作。

对偏置项初始化，有:

隐藏层偏置: 通常初始化为0。
输出层偏置: 一个很好的技巧是，将其设置为能让网络初始输出接近训练数据的平均标签。例如，如果90%的样本是正类，就设置偏置使Sigmoid输出默认为0.9。这可以避免训练初期浪费大量时间去学习这个基本的数据分布。

$f.$ 动量

动量法是一种经典的梯度下降优化算法。它基于如下的直觉：如果之前的梯度方向大致相同，那么当前步伐应该更大。这就像给梯度下降的小球增加了“惯性”，帮助它冲出局部极小值的“小坑”，并在狭长的“山谷”中加速。

动量法的更新规则如下：

维护一个“动量”向量 $m$ ，它累积了过去梯度的指数衰减平均值。

\begin{aligned} m &\leftarrow \beta m - \epsilon \nabla J(w) \\ w &\leftarrow w + m \end{aligned}

其中 $\beta$ 是动量超参数（如0.9），控制“惯性”的衰减率。

动量法通常能让模型更快地收敛到最优解附近。但其缺点是，由于惯性，它可能会“冲过头”，在最优点附近来回震荡。

把神经网络的代价函数想象成一个复杂的水上乐园滑道。使用带动量的梯度下降法就像一个成功的游泳者，能够利用惯性顺利地滑向终点（局部最小值）。

神经网络

Thu, 25 Sep 2025 03:18:09 GMT

生成：Gemini-2.5-pro，整理：fyerfyer

神经网络

1. 简介

$a.$ 概述

神经网络 (Neural Networks) 是一种功能强大的非线性模型，可同时用于分类 (Classification) 和回归 (Regression) 任务。

它融合了机器学习中的多个核心概念：

感知机 (Perceptrons): 构成神经网络的基本单元。
线性/逻辑回归: 单个神经元可视为这些模型的扩展。
集成学习 (Ensembles): 复杂的神经网络可看作是大量简单学习器（神经元）的集成。
随机梯度下降 (SGD): 训练神经网络参数的核心优化算法。

与传统方法需要手动设计特征不同，神经网络最革命性的特点之一是能够自动学习特征 (Feature Learning)。它通过组合简单的神经元，将原始数据逐层抽象，最终学习出解决复杂问题所需的高维特征表示。

$b.$ 解决 XOR 问题的思路

1969年，Marvin Minsky 和 Seymour Papert 在其著作《感知机》中，指出了一个致命缺陷——异或 (XOR) 问题。

XOR 是一个简单的逻辑运算：

x1	x2	y
0	0	0
0	1	1
1	0	1
1	1	0

当我们将这四个数据点绘制在二维平面上时，会发现它们是线性不可分 (linearly inseparable) 的，即无法用一条直线将类别0和类别1完美分开。由于单个感知机本质上是一个线性分类器，因此它无法解决XOR问题。

一个简单的思路是手动为数据增加一个非线性特征，例如 $x_1x_2$ 。这样，原始的二维数据点就被映射到了三维空间：

x1	x2	x1*x2	y
0	0	0	0
0	1	0	1
1	0	0	1
1	1	1	0

在新的三维空间中，数据点变得线性可分了。我们可以轻易地找到一个平面（三维空间中的线性分类器）来分离开两个类别：

但这种方法依赖于人工设计特征，不具备通用性。更强大的方法是构建一个多层网络。

初步想法：将多个线性分类器（感知机）的输出作为后续分类器的输入。
遇到的问题：线性组合的线性组合，结果仍然是一个线性组合。无论叠加多少层线性分类器，其最终效果都等价于一个单一的线性分类器，因此依然无法解决XOR问题。
关键补充：非线性激活函数 为了打破线性的限制，我们必须在每一层线性组合之后，引入一个非线性激活函数 (Non-linear Activation Function)。

线性组合 $\rightarrow$ 非线性激活 $\rightarrow$ 线性组合 $\rightarrow$ 非线性激活 $\rightarrow$ ...

通过这种方式，网络获得了拟合复杂非线性决策边界的能力。一个经典的例子是用多个神经元组合模拟逻辑门来解决XOR问题：

x_1 \oplus x_2 = (x_1 \text{ OR } x_2) \text{ AND } (x_1 \text{ NAND } x_2)

这里的核心问题是：我们能否设计一个算法，让网络自动学习出这些组合的权重？答案就是反向传播算法。

2. 单隐藏层网络结构

$a.$ 整体架构

一个典型的单隐藏层网络由三部分构成：

输入层 (Input Layer): 接收 $d$ 维的原始数据向量 $\mathbf{x}$ 。
隐藏层 (Hidden Layer): 包含 $m$ 个神经元，负责提取和转换特征。其输出为 $m$ 维向量 $\mathbf{h}$ 。
输出层 (Output Layer): 产生 $k$ 维的最终预测结果 $\mathbf{\hat{y}}$ 。

$b.$ 权重矩阵与偏置项

网络的“知识”存储在连接各层神经元的权重中，这些权重被组织成矩阵。

第一层权重 $V$ : 维度为 $m \times (d+1)$ ，连接输入层和隐藏层。
第二层权重 $W$ : 维度为 $k \times (m+1)$ ，连接隐藏层和输出层。

为了将偏置项 (bias) 整合进矩阵运算，我们为输入向量 $\mathbf{x}$ 和隐藏层输出向量 $\mathbf{h}$ 增加一个恒为1的虚拟维度 (fictitious dimension)。这样，线性运算 $W\mathbf{x} + \mathbf{b}$ 就可以被简化为 $W'\mathbf{x'}$ 。

$c.$ 前向传播 (Forward Propagation)

前向传播是指数据从输入层流向输出层，并计算出最终预测值的过程。

计算隐藏层输出 $\mathbf{h}$ : 首先进行线性组合，然后通过非线性激活函数 $s$ （例如 Sigmoid 函数）。

\mathbf{h} = s_1(V\mathbf{x})

其中 $s_1$ 表示逐元素应用激活函数 $s$ 后，再为向量末尾追加一个1（作为下一层的偏置项）。对于隐藏层中的第 $i$ 个神经元：

h_i = s(\mathbf{V}_i \cdot \mathbf{x})

( $\mathbf{V}_i$ 是权重矩阵 $V$ 的第 $i$ 行)

计算输出层输出 $\mathbf{\hat{y}}$ : 将隐藏层的输出 $\mathbf{h}$ 作为输入，重复上述过程。

\mathbf{\hat{y}} = s(W\mathbf{h})

对于输出层中的第 $j$ 个神经元：

\hat{y}_j = s(\mathbf{W}_j \cdot \mathbf{h})

( $\mathbf{W}_j$ 是权重矩阵 $W$ 的第 $j$ 行)

将两步合并，整个网络的计算可以表示为一个高度非线性的函数：

\mathbf{\hat{y}} = s(W s_1(V\mathbf{x}))

3.网络训练

$a.$ 代价函数

训练的目标是找到最优的权重矩阵 $V$ 和 $W$ ，使得网络的预测值 $\mathbf{\hat{y}}$ 与真实标签 $\mathbf{y}$ 尽可能接近。

损失函数 (Loss Function) $L(\mathbf{\hat{y}}, \mathbf{y})$ : 衡量单个样本的预测误差。例如，回归任务常用的均方误差： $L(\mathbf{\hat{y}}, \mathbf{y}) = \|\mathbf{\hat{y}} - \mathbf{y}\|^2$
代价函数 (Cost Function) $J(V, W)$ : 衡量网络在整个训练集上的平均误差。 $J(V, W) = \frac{1}{n} \sum_{i=1}^n L(\mathbf{\hat{y}}(\mathbf{x}_i), \mathbf{y}_i)$

$b.$ 梯度下降

我们使用梯度下降 (Gradient Descent) 来寻找代价函数的最小值。其核心思想是沿着代价函数梯度的反方向更新权重。

令 $\mathbf{w}$ 为一个包含网络中所有权重（来自 $V$ 和 $W$ ）的长向量，更新规则如下：

\mathbf{w} \leftarrow \mathbf{w} - \epsilon \nabla J(\mathbf{w})

其中 $\epsilon$ 是学习率 (Learning Rate)，控制更新的步长； $\nabla J(\mathbf{w})$ 是代价函数对所有权重的梯度。

$c.$ 局部最小值

神经网络的代价函数是非凸 (non-convex) 的，存在许多局部最小值。梯度下降算法可能会陷入一个非最优的局部最小值。不过在实践中，通过精心设计的网络和优化算法，通常能找到一个“足够好”的解。

$d.$ 权重初始化与对称性问题

不能将所有权重都初始化为0。如果这样做，隐藏层中的所有神经元在每次迭代时都会计算出完全相同的值和梯度，它们的权重也会以完全相同的方式更新。这种对称性 (Symmetry) 使得多个神经元退化成一个，网络将无法学习复杂的特征。

为了打破对称性，权重必须被初始化为小的随机数。

4.反向传播算法

反向传播是高效计算梯度 $\nabla J(\mathbf{w})$ 的核心算法。它本质上是一种动态规划，通过在计算图上反复应用链式法则 (Chain Rule) 来避免重复计算。

$a.$ 核心思想

任何复杂的数学表达式都可以表示为一个计算图。反向传播分为两步：

前向传播: 从左到右计算图中每个节点的值，并缓存结果。
反向传播: 从右到左计算梯度。核心法则是：某节点的梯度 = 上游传来的梯度 × 本地梯度。

$b.$ 分支处理

当一个节点的输出流向多个后续节点时（在神经网络中非常普遍），其总梯度等于所有路径的梯度之和。

\frac{\partial L}{\partial \alpha} = \sum_i \frac{\partial L}{\partial y_i} \frac{\partial y_i}{\partial \alpha}

$c.$ 具体流程

反向传播的过程是从后向前，逐层计算梯度。

计算输出层的误差信号:

首先计算损失函数 $L$ 相对于网络直接输出 $\mathbf{\hat{y}}$ 的梯度 $\nabla_{\hat{y}} L$ 。这个梯度是反向传播的起点。

计算第二层权重 $W$ 的梯度:

应用链式法则，将来自上一步的误差信号 $\nabla_{\hat{y}} L$ 乘以本地梯度 $\nabla_W \mathbf{\hat{y}}$ 。

\nabla_W L = (\nabla_{\hat{y}} L) \cdot (\nabla_W \mathbf{\hat{y}})

计算隐藏层的误差信号:

将输出层的误差信号 $\nabla_{\hat{y}} L$ 通过权重 $W$ 反向传播回隐藏层，得到隐藏层的误差信号 $\nabla_h L$ 。

\nabla_h L = (\nabla_{\hat{y}} L) \cdot (\nabla_h \mathbf{\hat{y}}) = W^T (\nabla_{\hat{y}} L) \cdot (\text{...})

计算第一层权重 $V$ 的梯度:

使用上一步得到的隐藏层误差信号 $\nabla_h L$ ，重复步骤2的逻辑，计算 $V$ 的梯度。

\nabla_V L = (\nabla_h L) \cdot (\nabla_V \mathbf{h})

$d.$ 统一的梯度形式

对于三种常见的输出层配置，尽管其激活函数和损失函数形式各异，但最终的梯度形式却惊人地统一：

输出层配置	1. 线性 + 均方误差	2. Sigmoid + 逻辑损失	3. Softmax + 交叉熵
$\nabla_W L$	$2(\mathbf{\hat{y}} - \mathbf{y})\mathbf{h}^T$	$(\mathbf{\hat{y}} - \mathbf{y})\mathbf{h}^T$	$(\mathbf{\hat{y}} - \mathbf{y})\mathbf{h}^T$
$\nabla_h L$	$2W^T(\mathbf{\hat{y}} - \mathbf{y})$	$W^T(\mathbf{\hat{y}} - \mathbf{y})$	$W^T(\mathbf{\hat{y}} - \mathbf{y})$

这种简洁的形式并非巧合。它是精心选择的损失函数（如逻辑损失）的“爆炸梯度”与激活函数（如Sigmoid）的“消失梯度”在数学上抵消的结果，最终留下了 $(\mathbf{\hat{y}} - \mathbf{y})$ 这个干净、稳定的误差项。

5.梯度消失问题与激活函数

$a.$ 梯度消失问题

Sigmoid 函数在输出接近0或1的区域非常平坦，其导数 $s' = s(1-s)$ 趋近于0。在深层网络中，根据链式法则，梯度在反向传播时会与多个接近0的导数连乘，导致梯度信号逐层衰减，最终完全消失。这使得靠近输入层的网络权重无法得到有效更新，训练极其缓慢或停滞。

为了解决梯度消失问题，现代神经网络普遍在隐藏层使用 ReLU (Rectified Linear Unit) 作为激活函数。

定义: $r(\gamma) = \max(0, \gamma)$
导数:

r'(\gamma) = \begin{cases} 1, & \gamma > 0 \\ 0, & \gamma \le 0 \end{cases}

对于所有被激活的神经元（输入>0），其梯度恒为1。这意味着梯度信号可以无衰减地通过这些神经元进行反向传播，极大地缓解了梯度消失问题，使得训练深度网络成为可能。

隐藏层通常使用ReLU，但输出层的激活函数和损失函数需要根据具体任务来专门选择。

任务类型	常用激活函数	常用损失函数	目的/类比
回归	线性 (无)	均方误差	预测连续值 (线性回归)
二分类	Sigmoid	逻辑损失/交叉熵	预测概率，避免输出层梯度消失 (逻辑回归)
多分类	Softmax	交叉熵	预测概率分布，避免输出层梯度消失 (Softmax回归)

$b.$ Softmax 函数

Softmax 函数将一个 $k$ 维的实数向量 $\mathbf{a}$ 转换为一个 $k$ 维的概率分布向量 $\mathbf{\hat{y}}$ 。

\hat{y}_i = \frac{e^{a_i}}{\sum_{j=1}^k e^{a_j}}

其输出的所有元素都在 (0, 1) 之间，且总和为1，可解释为输入属于各个类别的概率。

6.神经网络与生物学

人工神经网络的灵感部分来源于生物大脑，但两者在计算风格上有本质区别：

特性	CPU (中央处理器)	Brain (生物大脑)
处理方式	串行 (Sequential)	大规模并行 (Massively Parallel)
组件速度	纳秒级 (ns)	毫秒级 (ms)
容错性	脆弱 (Fragile)	极强 (Fault-tolerant)
擅长领域	精确计算、逻辑规则	视觉、语音、联想、模糊问题

大脑的记忆以一种分布式的方式存储在亿万神经元的连接权重中，而非存储在某个特定的神经元里。这使得大脑具有极强的容错能力。训练得当的人工神经网络也具备此特性

决策树

Sat, 20 Sep 2025 08:19:58 GMT

决策树

1. 简介

决策树是一种用于分类和回归（比如预测房价）的非线性方法。它的核心结构就像一棵树，包含两种节点：

内部节点 (Internal nodes)：每个内部节点都会对一个特征进行测试，并根据测试结果决定走向哪个分支。通常一次只测试一个特征。
叶节点 (Leaf nodes)：树的最末端，它会给出一个最终的预测结果，比如样本属于哪个类别 $h(x)$ 。

和线性分类器是用一条直线（或超平面）来划分空间不同，决策树通过一系列与坐标轴平行的“切分”，把整个特征空间划分成一个个“小方块”（矩形区域）。每个“小方块”对应一个叶节点和一个预测结果。这使得它同时适用于类别型和数值型特征。

2. 决策树构建

构建决策树通常采用一种贪心、自顶向下的递归算法：

def GrowTree(S):
    # We say the leaves are pure
    if all(yi == C for i in S for some class C):
        return new leaf(C)
    else:
        # Choose best splitting feature j and splitting value β (*)
        j, beta = choose_best_split(S)
        
        # Or you could use ≤ and >
        S_left = {i for i in S if X[i][j] < beta}
        S_right = {i for i in S if X[i][j] >= beta}
        
        return new node(j, beta, GrowTree(S_left), GrowTree(S_right))

算法中的最佳划分可以用一个成本函数 $J(S)$ 来衡量。我们的目标是最小化切分后子节点成本的加权平均值：

\mathrm{Weighted\_Avg\_Cost}=\frac{\lvert S_{\text{left}}\rvert\,J\bigl(S_{\text{left}}\bigr)+\lvert S_{\text{right}}\rvert\,J\bigl(S_{\text{right}}\bigr)}{\lvert S_{\text{left}}\rvert+\lvert S_{\text{right}}\rvert}

我们采用熵 (Entropy) 的概念来计算成本函数。熵的相关概念如下：

惊喜 (Surprise): 某个事件发生的“惊喜度”是 $-\log_2(p)$ ，其中 $p$ 是该事件发生的概率。概率越小，事件发生时带来的“惊喜”或“信息量”就越大。
熵 (Entropy): 一个集合 $S$ 的熵，是该集合中随机抽取一个样本，其类别所带来的平均惊喜度：

H(S) = - \sum p_C \log_2(p_C)

其中 $p_C$ 是类别 $C$ 在集合 $S$ 中所占的比例。

我们使用熵来选择最佳切分。具体做法是选择能带来最大信息增益的切分：

计算切分前的熵 $H(S)$ 。
计算切分后子节点熵的加权平均值 $H_{\text{after}} = \frac{|S_l|H(S_l) + |S_r|H(S_r)}{|S|}$ 。
则切分的信息增益 $H(S) - H_{\text{after}}$ 。

最大化信息增益，就等同于最小化切分后的加权平均熵 $H_{\text{after}}$ 。因为熵是严格凹函数，信息增益总是非负的。它能很好地区分不同切分的优劣，避免了误分类率的那个问题。

切分的具体方法如下：

对于类别型特征: 如果有多个值，可以进行多路切分（每个值一个分支）或二元切分（将值分为两组）。
对于数值型特征:
1. 将节点中所有样本按该特征值进行排序。
2. 尝试在每两个不相等的相邻值之间进行切分。
3. 一个聪明的技巧: 在扫描排序好的列表时，我们不需要每次都重新计算熵。当我们把切分点从左向右移动一个位置时，仅仅是将一个样本从“右集合”移动到“左集合”。熵的更新可以在 $O(1)$ 时间内完成。这使得对数值型特征寻找最佳切分点的过程非常高效。

3. 决策树回归

我们前面所讲的是使用决策树进行分类，而决策树也可以用来解决回归问题。

决策树回归创建的是一个分段常数回归函数 (piecewise constant regression fn)：决策树会将整个数据空间划分成一个个“小方块”（由叶节点定义），在每个“小方块”区域内，所有数据点的预测值都是同一个常数。

在回归树中，叶节点存储的值不再是类别，而是落入该叶节点的所有训练样本的目标值 $y$ 的平均数：

\mu_S=\frac{1}{\lvert S\rvert}\sum_{i\in S}y_i

在回归树中，我们使用方差 (Variance) 作为成本函数 $J(S)$ ：

J(S)=\operatorname{Var}\bigl(\{y_i\}_{i\in S}\bigr) =\frac{1}{\lvert S\rvert}\sum_{i\in S}\bigl(y_i-\mu_S\bigr)^2,

这个公式衡量的是一个节点内所有样本 $y$ 值的离散程度。如果一个节点内所有样本的 $y$ 值都完全相同，那么方差就是0，成本也为0。因此，分裂的目标是选择一个特征和分裂点，使得分裂后的两个子节点的方差加权平均值最小。

4. 早停

基础的决策树算法会不停地分裂节点，直到每个叶节点都变得“纯净”（即只包含同一类别的样本）。但我们不一定非要这样做，有时候提前停止分裂会是更好的选择。这种方法也叫预剪枝 (Pre-pruning)。

提前停止的原因如下：

限制树的深度: 为了让预测速度更快。
限制树的大小: 当处理非常大的数据集时，一颗完整的树可能会变得异常庞大和复杂。
防止过拟合: 这是最主要的原因。如果一棵树生长得过于完美，以至于每个叶节点都完全纯净，它很可能学习到了训练数据中的噪声和偶然特征，导致在新的、未见过的数据上表现很差。
处理噪声或重叠的分布: 当数据本身有噪声，或者不同类别的数据在特征空间中本来就有很大重叠时，强行追求纯净的叶节点必然会导致过拟合。这时的决策树会像一个 1-近邻 (1-NN) 分类器，对单个训练点非常敏感。更好的做法是提前停止，让叶节点里包含一组近邻点，然后通过投票决定结果，这更像一个 k-近邻 (k-NN) 分类器，模型会更稳健。

我们可以选择如下的条件作为选择停止的条件：

下一次分裂带来的熵减或者误差降低不够大。（但讲义指出这个方法有风险，因为可能某次分裂收益小，但后续分裂收益大。所以后剪枝通常更好）。
节点中大部分样本都属于同一个类别。这可以处理异常值和类别重叠的情况。
节点包含的训练点太少。尤其是在大数据集上，为很少的几个点去分裂意义不大。
节点代表的特征空间的边长已经非常小了。再细分可能没有意义。
使用验证集 (Use validation) 来比较。这是最慢但最有效的方法：每次分裂前，都在一个独立的验证集上测试，看这次分裂是否真的能降低验证误差。

5. 后剪枝

为了避免过拟合，有一种通常比早停更有效的方法：后剪枝 (Post-pruning)。后剪枝的做法是：先让决策树生长得稍微“过大”一些，然后再用验证集的数据来评估，剪掉那些对验证集性能没有提升甚至有损害的分支。这样做避免了预剪枝“目光短浅”的问题。

我们不需要每次都从整个树中验证数据点，如果使用得当的方法，这个评估的过程可以变得非常快：

首先，将所有验证数据点在完整的、未剪枝的树上完整地跑一次。
对于每一个验证数据点，记录下它最终落在了哪个叶节点。
这样，每个叶节点都会关联一个列表，里面是所有落入该节点的验证数据点。
现在，当我们虑是否要剪掉某一个分裂时（如，合并叶节点 $A$ 和叶节点 $B$ 成为父节点 $P$ ），完全不需要关心树的其他部分。我们只需要关注那些落在叶节点 $A$ 和叶节点 $B$ 里的验证点。
我们只需要局部地计算误差变化：
- 剪枝前：叶节点 $A$ 对它里面的验证点有一个预测，叶节点 $B$ 对它里面的验证点也有一个预测。计算这两个节点总共正确分类了多少验证点。
- 剪枝后：叶节点 $A$ 和叶节点 $B$ 里的所有验证点现在都属于父节点 $P$ 。父节点 $P$ 会给出一个统一的预测。用这个新预测计算总共正确分类了多少验证点。
比较剪枝前后的正确数量。如果剪枝后正确分类的验证点变多了（即验证误差降低了），就执行剪枝。这个计算非常快，因为它只涉及少量数据点的重新归类。

6. 多元分类

标准的决策树在分裂节点时，每次只针对一个特征创建一个与坐标轴平行的分裂，如 $x_1 < 10$ 或 $x_2 > 5$ ，这些边界都是水平或垂直的。而多元分裂则是创建非轴对齐的 (non-axis-aligned) 分裂，它在一次分裂中会同时考虑多个特征。这种分裂通常是一个线性组合，例如 $3x_1 + 2x_2 > 5$ ，它的决策边界是一条斜线：

为了实现这种斜线决策边界，在每个节点，我们可以用其他的分类算法来寻找一个最优的分割超平面，如支持向量机，逻辑回归或高斯判别分析。通过这种方式，决策树允许这些线性分类器以一种层级化的方式组合起来，从而找到非线性的决策边界。

多元分类可能获得一个分类效果更好的分类器，但是也会导致规则的可解释性变差与速度变慢，对此我们可以用前面讲解的特征收缩方法，为每个节点选择合适的特征。

7. 集成学习

决策树有很高的方差：训练数据的微小变化可能会导致生成一棵完全不同的树。假设我们把训练数据随机分成两半，用每一半数据分别训练一棵决策树，这两棵树的结构可能差异巨大，尤其是当它们在根节点的第一次分裂就选择了不同的特征时，后续的整个结构可能就完全不同了。

为了解决这个问题，我们可以采用求平均的方法，通过“平均”许多不同决策树的答案来显著降低模型的方差

想象从某个分布中生成随机数。只生成一个数，它的不确定性可能很高。但如果生成 $n$ 个随机数并取它们的平均值，这个平均值的方差会降为原来的 $\frac{1}{n}$ 。

在机器学习中，我们称那些比随机猜测略好的算法为弱学习器 (weak learner)。集成学习就是将许多弱学习器组合起来，形成一个强大的强学习器 (strong learner)。

集成模型在预测结果时，将一个测试点交给群体中的所有 $T$ 个学习器，然后综合它们的结果：

回归问题: 取所有学习器输出的平均值或中位数。
分类问题: 进行多数投票 (majority vote)，或者平均所有学习器的后验概率，然后选择概率最高的类别。

学习器群体的构建方法主要有以下几种：

Bagging (套袋法): 这是最常用的方法之一。从一个训练集中进行有放回的随机抽样，创建出许多个略有不同的子训练集，然后在每个子训练集上训练一个学习器（例如决策树）。
随机森林 (Random Forests): Bagging的一种特殊形式，在构建决策树时进一步增加了随机性。

集成学习有以下的注意事项：

基学习器应具有低偏差。例如，使用深度决策树，因为它们能很好地拟合训练数据，即使它们因此过拟合。
**基学习器的高方差和过拟合是可以接受的！**集成学习的重点就是通过平均来消除方差。每个学习器可能以自己独特的方式过拟合，但当把它们平均起来时，这些随机的、方向各异的错误会相互抵消。
学习器的数量通常不是需要仔细调整的超参数。学习器的数量越多，方差就降得越低，模型性能就越好。唯一的限制是计算时间：我们是在用时间换取性能。

8. 套袋法

Bagging(Bootstrap AGGregatING) 是一种通用的、随机化的方法，其目的是从同一个训练数据集中创建出许多个不同的学习器，然后将这些学习器的结果“聚合”起来，以获得比单个学习器更好的性能。

该方法对 k-近邻 (k-NN) 算法的效果不佳，甚至可能会轻微地降低其性能。

Bagging 的整体流程如下：

Bootstrap (自助采样法)：这是 Bagging 的第一个核心步骤，也是创建不同学习器的关键。假设我们有一个包含 $n$ 个数据点的训练集。为了创建一个新的子训练集，我们从原始数据集中进行 $n'$ 次有放回的随机抽样（通常 $n'=n$ ）。

如果抽样次数 $n'$ 和原始样本量 $n$ 相等，那么平均而言，一个子训练集大约会包含原始数据中 63.2% 的独立数据点。（剩下的约 36.8% 从未被抽中的数据被称为 “袋外数据” (Out-of-Bag, OOB)，它们可以被用作一个天然的验证集来评估模型性能

Aggregating (聚合)：我们重复 Bootstrap 过程 $T$ $T$ 次，就会得到 $T$ $T$ 个不同的子训练集。然后我们在这 $T$ $T$ 个子训练集上分别训练出 $T$ $T$ 个学习器。然后，我们将这 $T$ $T$ 个学习器的预测结果进行聚合来得到最终的输出。
- 如果一个数据点在一个子训练集中被抽中了 $j$ 次，那么在训练对应的学习器时，这个点的权重就是 $j$ 。这在效果上等同于数据集中有 $j$ $j$ 个完全相同的点挤在一起。
  - 对于决策树: 在计算信息增益时，这个点的权重被视为 $j$ 。
  - 对于SVM: 如果这个点违反了分类间隔，它会产生 $j$ 倍的惩罚项。
  - 对于回归: 在计算损失函数时，这个点会产生 $j$ 倍的损失值。

9. 随机森林

$a.$ 基本算法

Bagging 方法通过对样本进行自助采样来构建多棵树。但这样做还不够好，因为 Bagging 创建出的多棵决策树之间，结构可能仍然非常相似。假如我们的数据集中有一个特别强的预测特征，那么几乎每一个通过自助采样得到的子样本中，这个强特征都很可能存在。因此，在构建决策树时，几乎每一棵树的根节点都会选择这个最强的特征来进行第一次分裂。这会导致树的整体结构非常相似。

为了解决上述问题，随机森林在 Bagging 的基础上，引入了第二次随机，其目标是强制降低树与树之间的相关性。

随机森林在构建决策树的过程中，当对某一个节点进行分裂时，不再是从全部 $d$ 个特征中寻找最优分裂点，而是遵循以下步骤：

从全部 $d$ 个特征中，随机抽取一个包含 $m$ 个特征的子集 ( $m < d$ )。
只在这个 $m$ 个特征的子集中，寻找最优的分割点。
剩下的 $d - m$ 个特征，在当前这个节点的分裂决策中被完全忽略。
对于树的每一个节点，都重复进行一次全新的、独立的特征抽样。

这里的 $m$ 是随机森林的一个关键超参数，它控制了随机性的强度。有一些经验法则可以作为不错的起始值：

分类问题: $m \approx \sqrt{d}$
回归问题: $m \approx \frac{d}{3}$

这里的第二次随机，也体现了偏差-方差的权衡：更小的 $m$ 值意味着更强的随机性：树与树之间的相关性更低。但是，这也意味着在每个节点，算法被限制了选择范围，可能无法使用到那个节点上“真正”最好的特征，这会增加单棵树的偏差。随机森林的精髓在于，它愿意牺牲一点单棵树的准确性（略微增加偏差），来换取整个森林中树的巨大多样性（不相关性）。最终，通过对大量不相关的、性能尚可的树的结果进行平均，总体的方差被极大地降低了，从而获得一个偏差低、方差也低的强大模型。

随机森林方法的优点如下：

预测精度极高，是目前最强大的通用机器学习算法之一。
通常，增加树的数量（几百甚至几千棵）可以持续降低测试误差（因为更多的树能更好地降低方差），不容易过拟合。

但是随机森林方法也有如下问题：

速度慢：训练成百上千棵深度决策树的计算成本很高。
失去了可解释性：模型变成了一个“黑箱”。我们无法像解释单棵决策树那样，直观地向别人解释随机森林的决策逻辑。

$b.$ 随机化分裂类型

除了随机选择特征，我们还可以引入更多随机性：在每个节点，不只局限于轴对齐的分割，而是生成 $s$ 个随机的多元分裂（如，随机的斜线、随机的二次曲线），然后从这 $s$ 个随机生成的分裂中选择最好的一个。

特征收缩方法

Fri, 19 Sep 2025 15:01:52 GMT

特征收缩方法

1. 岭回归

$a.$ 简介

岭回归 (Ridge Regression) 是标准最小二乘法线性回归的一种改良版，它额外增加一个 $\ell_2$ 惩罚项。

岭回归的成本函数如下：

J(w) = \|Xw − y \|^2 + λ \|w\|^2

岭回归的正规方程如下：

\bigl(X^{T}X+\lambda I^{\prime}\bigr)w = X^{T}y

具体的数学推导在 “机器学习基础” 中已经讲解的非常详细了，这里略过。我们主要讲解 $\ell_2$ 惩罚项的一些实际意义。

根据前面的“偏差——方差权衡”理论，当我们增大 $\lambda$ 时：

方差减小：模型变得更简单、更平滑，对训练数据的随机噪声不再那么敏感。
偏差增大：由于对模型加了限制，它可能无法完全捕捉数据中真实的复杂关系，导致模型欠拟合的风险增加。

我们再从几何角度解释一下这个正则化项的作用原理：

红色椭圆：代表了误差项 $\|Xw − y\|^2$ 的等值线。椭圆的中心是普通最小二乘法的解 $\hat{w}$ ，这里是误差最小的地方。
蓝色圆形：代表了惩罚项 $\|w\|^2$ 的等值线。圆心在原点，越靠近原点的圆代表权重越小。
岭回归的解：岭回归的目标是最小化这两项之和。在几何上，这个解就是红色椭圆与蓝色圆形第一次相切的那个点。

由图像可以看出， $\lambda$ 越大，惩罚越重，相当于对权重的限制越强。这会迫使解落在更小的蓝色圆上（更靠近原点），从而收缩 (shrink) 权重。

$b.$ 基于最大后验概率的推导

下面我们基于最大后验概率来推导岭回归的正则化项（又称Tikhonov正则化）。

在贝叶斯公式中，有：

P(\theta|D) = \frac{P(D|\theta)P(\theta)}{P(D)}

其中 $P(D|θ)$ 是似然 (Likelihood)， $P(\theta)$ 是先验 (Prior)。 $P(D)$ 是证据 (Evidence)，是数据的边际概率。在优化过程中， $P(D)$ 是一个和 $θ$ 无关的常数。因此，我们希望最大化：

\underset{\theta}{\operatorname{argmax}}\, P(\theta |D) \Rightarrow \underset{\theta}{\operatorname{argmax}}\,[P(D|θ) P(θ)]

对这个式子取对数：

\underset{\theta}{\operatorname{argmax}}\,\ln\big(P(D|\theta)P(\theta)\big) = \underset{\theta}{\operatorname{argmax}}\,\big[\ln P(D|\theta)+\ln P(\theta)\big]

对于对数似然部分，我们前面推导过，在线性回归和高斯噪声的假设下，最大化它就等价于最小化残差平方和：

\begin{aligned} \ln P(D|\theta) &= \ln \prod_{i=1}^n P(y_i|x_i, \theta) \\ &= \sum_{i=1}^n \ln \left( \frac{1}{\sigma_n\sqrt{2\pi}}\exp\left(-\frac{(y_i-x_i^T\theta)^2}{2\sigma_n^2}\right) \right) \\ &= \sum_{i=1}^n \left( -\ln(\sigma_n\sqrt{2\pi}) - \frac{(y_i-x_i^T\theta)^2}{2\sigma_n^2} \right) \\ &= -n\ln(\sigma_n\sqrt{2\pi}) - \frac{1}{2\sigma_n^2}\sum_{i=1}^n(y_i-x_i^T\theta)^2 \end{aligned}

于是问题转变为：我们应该对参数 $\theta$ 做一个什么样的先验假设呢？一个合理的假设是：我们相信模型的参数 $θ$ 不会太大，它们的值应该倾向于靠近 0。因为一个参数值很小的模型通常更简单、更平滑，不容易过拟合。均值为 0 的高斯分布可以很好地满足我们的需求。

于是我们假设 $\theta \sim \mathcal{N}(0, \sigma^2)$ ，则：

\begin{aligned} \ln P(\theta) &= \ln \prod_{j=1}^d P(\theta_j) \\ &= \sum_{j=1}^d \ln \left( \frac{1}{\sigma_p\sqrt{2\pi}}\exp\left(-\frac{\theta_j^2}{2\sigma_p^2}\right) \right) \\ &= \sum_{j=1}^d \left( -\ln(\sigma_p\sqrt{2\pi}) - \frac{\theta_j^2}{2\sigma_p^2} \right) \\ &= -d\ln(\sigma_p\sqrt{2\pi}) - \frac{1}{2\sigma_p^2}\sum_{j=1}^d\theta_j^2 \\ &= -d\ln(\sigma_p\sqrt{2\pi}) - \frac{\|\theta\|_2^2}{2\sigma_p^2} \end{aligned}

将上述两项代入 MAP 目标函数：

\hat{\theta}_{\text{MAP}} = \underset{\theta}{\operatorname{argmax}}\,\left[ -n\ln(\sigma_n\sqrt{2\pi}) - \frac{1}{2\sigma_n^2}\sum_{i=1}^n(y_i-x_i^T\theta)^2 -d\ln(\sigma_p\sqrt{2\pi}) - \frac{\|\theta\|_2^2}{2\sigma_p^2} \right]

在优化过程中，我们忽略所有与 $\theta$ 无关的常数项：

\hat{\theta}_{\text{MAP}} = \underset{\theta}{\operatorname{argmax}}\,\left[ - \frac{1}{2\sigma_n^2}\sum_{i=1}^n(y_i-x_i^T\theta)^2 - \frac{1}{2\sigma_p^2}\|\theta\|_2^2 \right]

令 $\lambda = \frac{\sigma_n^2}{\sigma_p^2}$ ，我们就得到了岭回归 (Ridge Regression) 的目标函数：

\hat{\theta}_{\text{MAP}} = \underset{\theta}{\operatorname{argmin}}\,\left[ \sum_{i=1}^n(y_i-x_i^T\theta)^2 + \lambda\|\theta\|_2^2 \right]

2. 特征子集选择

该部分由 gemini 生成

在介绍 LASSO 之前，我们先简单介绍一下特征子集选择。

特征选择的基本思想很简单：并非所有特征都是有用的。在一个数据集中，很多特征可能与预测目标无关，或者包含了冗余信息。同时，使用重要的特征能够增强模型的可解释性：一个只用了5个最重要特征的模型，远比一个用了500个特征的“黑箱”模型更容易理解和解释。

最直接的方法是直接尝试所有的特征组合。对于 $d$ 个特征，总共有 $2^d-1$ 个不同的选择，这个数量级过于庞大了，因此我们一般采用启发式方法：

算法 1：前向逐步选择 (Forward Stepwise Selection)
- 方法：
  1. 从一个不包含任何特征的“空模型”开始。
  2. 遍历所有尚未被选入的特征，将它们逐一加入当前模型，看哪个能让模型的性能提升最大（例如，通过交叉验证评估）。
  3. 将这个“最佳”特征正式加入模型。
  4. 重复步骤2和3，直到模型性能不再提升为止。
- 缺点：它是一种贪心算法，可能会错过最优解。例如，最好的特征对 $\lbrace A, B \rbrace$ 可能无法被找到，因为单独的 $A$ 和单独的 $B$ 都不是最好的单特征模型。
算法 2：后向逐步选择 (Backward Stepwise Selection)
- 方法：
  1. 从包含所有 d 个特征的“全模型”开始。
  2. 遍历所有已在模型中的特征，尝试逐一移除它们，看移除哪个能让模型的性能提升最大。
  3. 正式移除这个“最没用”的特征。
  4. 重复步骤2和3，直到模型性能不再提升为止。

这些算法的适用场景如下：

前向选择更适合只有少数特征是真正有用的场景。
后向选择更适合大部分特征都有用，只有少数是无用的场景。

3. LASSO 方法

LASSO ((Least Absolute Shrinkage and Selection Operator)) 全称是“最小绝对值收缩和选择算子”，它是一种非常巧妙的正则化方法。

与岭回归不同，LASSO 使用如下的正则化方法：

J(w) = \|Xw − y\|^2 + λ \sum|w_i|

正是从平方和到绝对值和这个微笑的改动，使得 LASSO 能够自然地将某些特征的权重精确地压缩到 0，从而自动进行特征选择。

为了理解 LASSO 的特征选择，我们从几何角度作出它的图像：

LASSO 的 $L_1$ 惩罚项的等值线是菱形，当误差等值线从中心点（最小二乘解）向外扩张时，它有极大的概率首先碰到菱形的一个顶点，而不是一条边。而菱形的顶点正好位于坐标轴上，例如，如果切点在 $w_2$ 轴的顶点上，那么该点的 $w_1$ 坐标就精确地为 0。这就是 LASSO 能够进行特征选择的几何原理。通过使用 $L_1$ 惩罚，它创造了带有“尖角”的约束区域，使得最优解天然地倾向于落在这些角上，从而导致某些权重变为零。

LASSO 的权重路径图如下：

可以清晰地看到，随着 $\lambda$ 从左到右增大，一条又一条的权重曲线被压到了 0，并且保持为 0。

在实际使用LASSO 方法时需要注意如下的事项：

LASSO 没有像岭回归那样的解析解，需要使用专门的优化算法来求解。
与岭回归一样，在使用 LASSO 之前，强烈建议先对特征进行标准化（例如，将它们缩放到均值为0，方差为1）。这是因为 LASSO 的惩罚是基于权重的绝对值，如果特征的尺度相差很大，那么尺度大的特征对应的权重会天然地更小，惩罚对它们就不公平了。

对机器学习方法的统计证明

Fri, 19 Sep 2025 10:31:08 GMT

对机器学习方法的统计证明

1. 模型建立

为了给回归问题建立一个统计模型，我们做出以下假设：

y_i=g(X_i) + \epsilon_i

这个公式描述了我们观察到的数据点 $(X_i, y_i)$ 是如何产生的，其中：

$g(X_i)$ 是真实函数 (Ground Truth)。我们相信在现实中，输入 $X$ 和输出 $y$ 之间存在一个我们不知道的、但固定不变的潜在规律 $g$ 。比如，房子的面积和它的“真实”价值之间可能有一个确定的函数关系。我们的目标就是找到一个函数 $h$ 来尽可能地接近这个未知的 $g$ 。
$\epsilon_i$ 是随机噪声 (Random Noise)。它代表了所有影响测量的随机因素，比如测量误差、数据记录错误，以及所有 $g$ 未能捕捉到的其他随机波动。 $\epsilon_i$ 来自某个概率分布 $D'$ ，并且其均值为零 ( $E[\epsilon] = 0$ )。这意味着，从长期来看，这些随机误差会相互抵消，不会系统性地偏高或偏低。

注意，在假设中，噪声分布 $\epsilon_i$ 是独立于 $X$ 的，这是我们的理想化建模。

然后我们再证明一个简单的结论：我们只需要知道所有 $X=x$ 时 $Y$ 的条件期望 $E[Y|X=x]$ ，那它就是 $g(x)$ 的完美估计。证明如下，我们将 $y$ 的表达式代入：

E(Y|X=x)=E(g(x)+\epsilon | X=x)

由于 $g(x)$ 是一个固定值（因为给定了 $x$ ），而 $E(\epsilon)=0$ ，因此 $E(g(x)+\epsilon | X=x) = g(x)$ 。这说明这个条件期望就是我们要找的 $g$ 。

2. 对最小二乘的推导

下面我们用这个模型解释最小二乘法的合理性。我们假设噪声 $\epsilon_i \sim \mathcal{N}(0, \sigma^2)$ ，则由前面的假设， $y_i$ 也服从正态分布：

E(y_i)=E(g(X_i) + \epsilon_i)=g(X_i)+0 = g(X_i)

\text{Var}(y_i)=\text{Var}(\epsilon_i)=\sigma^2

也即 $y \sim \mathcal{N}(g(X_i), \sigma^2)$ 。 $y$ 的 PDF 如下：

P\big(y_i\mid g(X_i);\sigma\big)=\frac{1}{\sigma\sqrt{2\pi}}\exp\left(-\frac{\big(y_i-g(X_i)\big)^2}{2\sigma^2}\right)

其联合概率分布就是似然函数：

\begin{aligned} L(g) &= P\bigl(y_1,\dots,y_n\mid X;g\bigr) \\ &= \prod_{i=1}^n P\bigl(y_i\mid X_i;g\bigr) \\ &= \prod_{i=1}^n \frac{1}{\sigma\sqrt{2\pi}} \exp\left(-\frac{\bigl(y_i-g(X_i)\bigr)^2}{2\sigma^2}\right) \end{aligned}

对其取对数：

\begin{aligned} \ell(g) &= \ln L(g) \\ &= \ln\prod_{i=1}^n P\bigl(y_i\mid X_i;g\bigr) \\ &= \ln\prod_{i=1}^n \frac{1}{\sigma\sqrt{2\pi}} \exp\left(-\frac{(y_i-g(X_i))^2}{2\sigma^2}\right) \\ &= \sum_{i=1}^n \ln\left(\frac{1}{\sigma\sqrt{2\pi}} \exp\left(-\frac{(y_i-g(X_i))^2}{2\sigma^2}\right)\right) \\ &= \sum_{i=1}^n \left[\ln\frac{1}{\sigma\sqrt{2\pi}} + \ln\exp\left(-\frac{(y_i-g(X_i))^2}{2\sigma^2}\right)\right] \\ &= \sum_{i=1}^n \left[-\ln\bigl(\sigma\sqrt{2\pi}\bigr) -\frac{(y_i-g(X_i))^2}{2\sigma^2}\right] \\ &= -n\ln\bigl(\sigma\sqrt{2\pi}\bigr) - \frac{1}{2\sigma^2}\sum_{i=1}^n (y_i-g(X_i))^2 \end{aligned}

我们的目的是最大化 $\ell(g)$ ，根据上面的式子，我们只需要最小化 $\sum_{i=1}^n (y_i-g(X_i))^2$ 即可，这正是正是模型预测值 $g(X_i)$ 和真实值 $y_i$ 之间差值的平方和。

3. 对逻辑回归的推导

我们现在处理的是分类问题，模型 $h(X_i)$ 输出的是一个概率，即模型预测数据点 $X_i$ 属于类别 $C$ 的概率。 $y_i$ 是真实的标签， $h(X_i)$ 是模型的预测概率。

为了能够使用我们之前处理离散变量的方法（计数法），我们设计下面的思想实验：我们想象对于每一个数据点 $X_i$ ，我们都创造了 $β$ 个完全相同的副本（ $β$ 是一个很大的整数）。那么这里面 $h(X_i)$ 比例的数据点会属于 $y_i$ ， $1-h(X_i)$ 比例的数据点会属于 $1-y_i$ ，这种情况发生的概率为：

P=h(X_i)^{y_i\beta}\,(1-h(X_i))^{(1-y_i) \beta}

对于所有的 $n$ 个数据点，其似然函数为：

L(h)=\prod_{i=1}^n h(X_i)^{y_i\beta}\bigl(1-h(X_i)\bigr)^{(1-y_i)\beta}

同样地，我们对上式取对数：

\begin{aligned} \ell(h) &= \ln L(h) \\ &= \sum_{i=1}^n \ln\Big(h(X_i)^{y_i\beta}\big(1-h(X_i)\big)^{(1-y_i)\beta}\Big) \\ &= \sum_{i=1}^n \Big[\ln\big(h(X_i)^{y_i\beta}\big)+\ln\big((1-h(X_i))^{(1-y_i)\beta}\big)\Big] \\ &= \sum_{i=1}^n \Big[y_i\beta\,\ln h(X_i)+(1-y_i)\beta\,\ln(1-h(X_i))\Big] \\ &= \beta\sum_{i=1}^n \Big[y_i\ln h(X_i)+(1-y_i)\ln(1-h(X_i))\Big] \end{aligned}

其中 $\sum_{i=1}^n \Big[y_i\ln h(X_i)+(1-y_i)\ln(1-h(X_i))\Big]$ 正是逻辑回归的损失函数，也是我们需要最小化的值。

4. 偏差——方差分解

$a.$ 前置概念

一个模型的误差主要来自两个方面：

偏差 (Bias): 指的是模型自身的局限性所导致的系统性错误。
方差 (Variance): 指的是模型对训练数据的微小变化过于敏感所导致的错误。

$b.$ 误差的数学分解

下面我们严格推导误差的来源。我们定义：

数据模型： $y_i = g(X_i) + \epsilon_i$ 。 $g$ 是真实规律， $\epsilon$ 是均值为0的噪声。
学习模型 $h$ ：我们从一组随机的训练数据 $(X, y)$ 中学习到了一个模型 $h$ 。
测试点 $z$ $z$ 和 $\gamma$ $γ$ ：
- $z$ ：一个固定的、任意的测试点。
- $γ = g(z) + ϵ$ ：在 $z$ 点的带噪声的真实标签。因为 $ϵ$ 是随机的，所以 $γ$ 也是随机的。

注意， $h$ 是一个随机变量。因为训练数据是从一个大总体中随机抽样的，每次抽到的数据都不同。用不同的训练数据去训练，你就会得到一个不同的模型 $h$ 。

我们的目标是分解在 $z$ 点的期望平方误差，即 $R(h) = E[(h(z) - γ)^2]$ 。这里的期望 $E$ 是一个全局期望，它包含了对所有可能的训练集以及所有可能的测试点噪声 $\epsilon$ 的平均。我们做如下推导：

\begin{aligned} R(h) &= \mathbb{E}\big[h(z)^2-2h(z)\gamma+\gamma^2\big] \\ &= \mathbb{E}[h(z)^2]-2\mathbb{E}[h(z)\gamma]+\mathbb{E}[\gamma^2] \\ &= \mathbb{E}[h(z)^2]-2\mathbb{E}[h(z)]\mathbb{E}[\gamma]+\mathbb{E}[\gamma^2] \\ &= \big(\operatorname{Var}(h(z))+\mathbb{E}[h(z)]^2\big)-2\mathbb{E}[h(z)]\mathbb{E}[\gamma]+\big(\operatorname{Var}(\gamma)+\mathbb{E}[\gamma]^2\big) \\ &= \big(\mathbb{E}[h(z)]^2-2\mathbb{E}[h(z)]\mathbb{E}[\gamma]+\mathbb{E}[\gamma]^2\big)+\operatorname{Var}(h(z))+\operatorname{Var}(\gamma) \\ &= \big(\mathbb{E}[h(z)]-\mathbb{E}[\gamma]\big)^2+\operatorname{Var}(h(z))+\operatorname{Var}(\gamma) \\ &= \big(\mathbb{E}[h(z)]-g(z)\big)^2+\operatorname{Var}(h(z))+\operatorname{Var}(\epsilon) \end{aligned}

这个式子表明：期望误差 = 偏差 $^2$ + 方差 + 不可约减的误差。这里的偏差和方差和我们在前置概念说的相对应。

$c.$ 对最小二乘的应用

我们以最小二乘法为例，看看偏差与方差在实际算法中是怎么体现的。

为了简化问题，我们进行如下理想化设定：

我们假设模型为 $h(x)=w^Tx$ ，没有偏置项 $b$ 。
真实规律 $g(z)$ 是线性的，即 $g(z)=v^Tz$ ，这里的 $v$ 是我们不知道的真实权重向量。
训练标签 $y$ 是由真实规律 $Xv$ 加上一个噪声向量 $e$ 产生的，即 $y = Xv + e$ 。其中 $e$ 的每个元素 $e_i$ 都来自均值为0，方差为 $\sigma ^ 2$ 的正态分布。

我们的目标是：通过最小二乘法，从带噪声的训练数据 $(X, y)$ 中学习到一个权重 $w$ ，然后分析用这个 $w$ 构成的模型 $h(z) = w^Tz$ 的偏差和方差。

我们知道最小二乘线性回归的解为 $w = X^{+}y$ ，其中 $X^{+} = (X^TX)^{-1}X^T$ 是 $X$ 的伪逆。

我们把 $y$ 的来源代入上式：

\begin{aligned} w &= X^{+}(Xv+e) \\ &= X^{+}Xv + X^{+}e \\ &= v + X^{+}e \end{aligned}

这个式子告诉我们，我们通过最小二乘法学习到的权重 $w$ ，等于真实的权重 $v$ 加上一个由噪声 $e$ 引起的扰动项 $X^{+}e$ 。我们学习的误差唯一的来源就是训练数据中的噪声。

我们接着计算偏差 $|E[h(z)] - g(z)|$ ：

\begin{aligned} \bigl|\mathbb{E}[h(z)]-g(z)\bigr| &= \bigl|\mathbb{E}[w^{T}z]-v^{T}z\bigr| \\ &= \bigl|(\mathbb{E}[w]-v)^{T}z\bigr| \\[6pt] \mathbb{E}[w] &= \mathbb{E}\bigl[v+X^{+}e\bigr] \\ &= \mathbb{E}[v]+\mathbb{E}[X^{+}e] \\ &= v + X^{+}\mathbb{E}[e] \\ &= v + 0 = v \\[6pt] \therefore\quad \bigl|(\mathbb{E}[w]-v)^{T}z\bigr| &= \bigl|(v-v)^{T}z\bigr| = 0 \end{aligned}

意味着，在我们的理想化设定下（模型类别匹配真实规律），最小二乘线性回归是一个无偏估计 (unbiased estimator)。这并不是说我们随便用一个训练集学到的 $w$ 就一定等于 $v$ 。而是说，如果我们能获得大量不同的训练集，分别训练出大量的 $w$ ，那么这些 $w$ 的平均值将会无限接近于真实的 $v$ 。模型犯的错（有时偏高，有时偏低）在平均意义上会相互抵消。

我们接着计算方差 $Var(h(z)) = Var(w^Tz)$ ：

\begin{aligned} \operatorname{Var}(w^{T}z) &= \operatorname{Var}\big((v+X^{+}e)^{T}z\big) \\ &= \operatorname{Var}\big(v^{T}z+(X^{+}e)^{T}z\big) \\ &= \operatorname{Var}\big((X^{+}e)^{T}z\big) \quad(\text{since }v^{T}z\text{ is constant})\\ &= \operatorname{Var}\big(z^{T}X^{+}e\big) \\ &= \sigma^{2}\,\|z^{T}X^{+}\|^{2} \\ &= \sigma^{2}\,(z^{T}X^{+})(z^{T}X^{+})^{T} \\ &= \sigma^{2}\,z^{T}X^{+}(X^{+})^{T}z \\ &= \sigma^{2}\,z^{T}(X^{T}X)^{-1}X^{T}\big((X^{T}X)^{-1}X^{T}\big)^{T}z \\ &= \sigma^{2}\,z^{T}(X^{T}X)^{-1}X^{T}X\big((X^{T}X)^{-1}\big)^{T}z \\ &= \sigma^{2}\,z^{T}(X^{T}X)^{-1}(X^{T}X)(X^{T}X)^{-1}z \quad(\text{since }(X^{T}X)^{-1}\text{ is symmetric})\\ &= \sigma^{2}\,z^{T}(X^{T}X)^{-1}z \end{aligned}

由于真实权重和测试点都是固定的， $v^Tz$ 是一个常数。

这个公式虽然精确，但不够直观。通过一些近似（当样本量 $n$ 很大时），可以得到一个更具启发性的结果：

\text{Var}(h(z)) \approx \sigma^2 \frac{d}{n}

这个式子揭露了方差的来源与控制，模型的方差：

与 $\sigma^2$ 成正比：数据噪声越大，模型越不稳定，方差越大。
与 $d$ 成正比：特征越多，模型越复杂，越容易拟合噪声，方差越大。这就是“维度灾难”的一种体现。
与 $n$ 成反比：训练数据越多，模型就越能看透噪声、抓住本质，从而变得越稳定，方差越小。

回归问题

Fri, 19 Sep 2025 02:28:07 GMT

回归问题

1. 概述

与前面讨论的分类问题不同，在回归问题中，对于数据 $X$ ，我们需要预测一个具体的数值（通常是连续的，比如房价、气温）。

我们之前讨论的 QDA 和 LDA 其实也包含了回归的思想，因为它们不仅给出了分类结果，还给出了这个预测正确的概率。

回归问题包含如下三个部分：

选择一个回归函数的形式 $h(x; w)$
选择一个损失函数 $L(\hat{y}, y)$
选择一个成本函数 $J(h)$

这一部分在之前 “机器学习基础” 的文章中详细讲过，这里就略过了。

2. 最小二乘线性回归

在最小二乘线性回归中，我们需要找到参数 $w$ 和 $α$ ，使得所有样本点的残差平方和 (Residual Sum of Squares, RSS) 最小：

\min \sum(X_i \cdot w + α - y_i)^2。

我们将 $X_i \ cdot w + \alpha$ 写成矩阵形式，转换成最小化：

\| Xw-y \| ^ 2

对这个式子对 $w$ 求梯度，令其为0：

\nabla \text{RSS}=2X^TXw - 2X^Ty = 0 \Rightarrow X^TXw = X^Ty

这个方程被称为正规方程组 (Normal Equations)。如果 $X^TX$ 这个矩阵是可逆的，那么 $w$ 的解就是 $w = (X^TX)^{-1}X^Ty$ 。如果 $X^TX$ 不可逆，则该方法失效，这通常意味着数据点共线或共面（比如样本点数量少于特征数量），导致问题有无穷多解（欠定的）。

3. 逻辑回归

逻辑回归是另一种非常重要的回归方法。它的回归函数是逻辑函数 $s(w\cdot x + \alpha)$ ，损失函数为交叉熵损失。我们希望使下面的式子最小：

J=\sum_{i=1}^{n}L\bigl(s(X_i\cdot w),\,y_i\bigr) =-\sum_{i=1}^{n}\bigl(y_i\ln s(X_i\cdot w)+(1-y_i)\ln(1-s(X_i\cdot w))\bigr)

需要注意这个函数是凸函数，这意味着它只有一个全局最小值，没有局部最小值。因此，我们可以使用梯度下降 (gradient descent) 法来求解，并且保证能找到最优解。

下面我们进行一下逻辑函数的梯度下降推导。首先，逻辑函数具有如下性质：

s'(x) = s(x) (1 - s(x))

于是有：

\begin{aligned} \nabla_w J &= -\sum_{i=1}^n\left(\frac{y_i}{s_i}-\frac{1-y_i}{1-s_i}\right)\nabla_w s_i,\quad s_i=s(X_i\cdot w)\\ &= -\sum_{i=1}^n\left(\frac{y_i}{s_i}-\frac{1-y_i}{1-s_i}\right)s'(X_i\cdot w)X_i\\ &= -\sum_{i=1}^n\left(\frac{y_i}{s_i}-\frac{1-y_i}{1-s_i}\right)s_i(1-s_i)X_i\\ &= -\sum_{i=1}^n (y_i-s_i)X_i \end{aligned}

也即：

\nabla_w J = -X^{T}\bigl(y - s(Xw)\bigr)

有了梯度计算式，我们就可以使用梯度下降与随机梯度下降方法了：

w \leftarrow w + \epsilon\, X^{T}\bigl(y - s(Xw)\bigr)

w \leftarrow w + \epsilon\,\bigl(y_i - s(X_i\cdot w)\bigr)\,X_i

这个更新规则和感知机算法 $w \leftarrow w + \epsilon\, X^{T}\bigl(y - \hat{y}\bigr)$ 非常相似。区别在于，感知机的 $\hat{y}$ 是一个硬性的 0 或 1 的预测，而逻辑回归中的 $s_i$ 是一个软性的、介于 0 和 1 之间的概率。可以把逻辑回归看作是感知机的一个 “平滑”或“概率化”的版本。

4. 加权最小二乘回归

在实际的回归问题中，某些数据点可能比其他点更可信，或者我们希望模型能更精确地拟合某些特定的点。于是我们可以使用加权最小二乘回归：

\min_w (Xw - y)^T \Omega (Xw - y) = \sum_{i=1}^n \omega_i \bigl(X_i\cdot w - y_i\bigr)^2

这个式子的正规方程为：

X^T \Omega Xw = X^T \Omega y

5. 牛顿法

牛顿法是一种用于寻找函数（例如成本函数 $J(w)$ ）极值的迭代优化算法。它通常比梯度下降法收敛得快得多。

我们对目标函数 $J(w)$ 的梯度 $\nabla J(w)$ 在当前点 $v$ 附近进行泰勒展开，并忽略高阶项：

\nabla J(w) \approx \nabla J(v) + H(v)(w - v)

其中 $H(x)$ 是 $J$ 在 $v$ 点的海森矩阵，可以把它理解为多变量函数的二阶导数：

H(f)=\begin{bmatrix} \frac{\partial^2 f}{\partial x_1^2} & \frac{\partial^2 f}{\partial x_1\partial x_2} & \cdots & \frac{\partial^2 f}{\partial x_1\partial x_n} \\ \frac{\partial^2 f}{\partial x_2\partial x_1} & \frac{\partial^2 f}{\partial x_2^2} & \cdots & \frac{\partial^2 f}{\partial x_2\partial x_n} \\ \vdots & \vdots & \ddots & \vdots \\ \frac{\partial^2 f}{\partial x_n\partial x_1} & \frac{\partial^2 f}{\partial x_n\partial x_2} & \cdots & \frac{\partial^2 f}{\partial x_n^2} \end{bmatrix}

我们令这个梯度为0，更新 $w$ 参数：

w = v - H^{-1}(v) \nabla J(v)

重复这个过程直到 $w$ 收敛。整个流程如下：

我们选择一个初始点 $w$ 。
计算该点的梯度 $\nabla J(w)$ 和海森矩阵 $H(w)=\nabla^2J(w)$ 。
求解线性方程组 $H(w)e=-\nabla J(w)$ ，得到更新步长。
更新 $w$ ： $w \leftarrow w + e$

牛顿法利用了二阶导数（曲率）信息，能更准地找到下降方向和步长，因此收敛速度远快于只使用一阶导数的梯度下降。但是计算成本很高，并且每次迭代都要重新计算梯度、海森矩阵和求解线性方程组。

6.使用牛顿法的逻辑回归

$a.$ 理论推导

在学习了牛顿法后，我们试着用这一收敛更快的算法来计算逻辑回归。

我们已知：

\nabla_w J= -\sum_{i=1}^n (y_i-s_i)X_i

对其求梯度得：

\begin{aligned} \nabla_w^2 J(w) &= -\sum_{i=1}^n \nabla_w\big((y_i - s_i) X_i\big)\\ &= -\sum_{i=1}^n X_i\big(\nabla_w (y_i - s_i)\big)^T\\ &= -\sum_{i=1}^n X_i\big(-\nabla_w s_i\big)^T\\ &= \sum_{i=1}^n X_i\big(\nabla_w s_i\big)^T\\ &= \sum_{i=1}^n X_i\big(s_i(1-s_i)X_i\big)^T\\ &= \sum_{i=1}^n s_i(1-s_i)\,X_i X_i^T \end{aligned}

向量微积分法则： $\nabla_w\big(fv\big)=v\big(\nabla_w f\big)^T,\; v\ \text{is constant}$ 。这是为了确保维度的正确。

将其写成矩阵形式，即得：

\nabla_w^2 J(w) = X\Omega X^T

其中 $\Omega=\operatorname{diag}\big(s_1(1-s_1),\,s_2(1-s_2),\,\ldots,\,s_n(1-s_n)\big)$

因为 $\Omega$ 是一个对角线上元素全为正的对角矩阵，所以 $\Omega$ 是正定的，这进一步保证了海森矩阵 $H = X^T\Omega X$ 是半正定的。而如果一个函数的海森矩阵在定义域内处处都是半正定的，那么这个函数就是凸函数。这意味着只要牛顿法能够收敛，我们就一定能够得到全局最小值。

我们将梯度和海森矩阵 $H(w)=\nabla_w^2 J(w)$ 带入，得到如下的牛顿法的线性方程组：

(X^{T}\Omega X)e = X^{T}(y - s)

观察这个式子，和我们先前的加权最小二乘回归的规范方程：

X^T \Omega Xw = X^T \Omega y

非常类似。这个计算逻辑回归的方法也被称为迭代重加权最小二乘 (Iteratively Reweighted Least Squares, IRLS)。它和加权最小二乘的计算方法类似，但是 IRLS 的权重矩阵 $\Omega$ 并不是固定的，每一次我们更新 $w$ 后， $\Omega$ 都要被重新计算。这个过程就像是每一轮迭代都在用新的权重，去解一个加权最小二乘问题。

不同的点在 IRLS 中的影响权重如下：

被正确分类，且离边界很远的点：这些点的 $s_i$ 接近 1，因此权重 $s_i(1-s_i)$ 很小，这说明模型已经很好地处理了它们，所以不需要再关注了。
被错误分类，且离边界很远的点：这些点的 $s_i$ 接近 0，因此权重 $s_i(1-s_i)$ 同样很小，但是右侧的误差项 $(y - s_i)$ 很大，牛顿法会集中修正这些点。
离决策边界很近的点：这些点的 $s_i$ 接近 0.5，权重 $s_i(1-s_i)$ 达到最大值，这些点有中等影响。

IRLS 优先关注那些被模型以高置信度搞错了的样本，这非常符合直觉。

$b.$ 算法加速

如果数据集 $n$ 非常大，每次迭代都用全部数据来计算 $X^T\Omega X$ 和 $X^T(y-s)$ 会非常慢。一个加速的技巧是：在每次迭代时，不使用全部样本，而是随机抽取一小部分样本（一个子集或 minibatch）来近似计算梯度和海森矩阵。这一做法的原理如下：

在优化的早期阶段，我们离最优点还很远，没必要进行精确到毫米的计算，只需要一个大致正确的方向就足够了。用一小部分数据算出的方向已经足够好。
随着迭代的进行，当我们越来越接近最优点时，可以逐渐增多每次迭代使用的样本数量，以获得更精确的更新方向，进行最后的“精调”。

这个思想是现代大规模机器学习优化的基石，著名的随机梯度下降（SGD）便是基于此思想。

$c.$ 逻辑回归与 LDA 的优劣

LDA 的优势

对于类别区分良好的数据，LDA更稳定
- 当两个类别的数据点可以被完美地分开时，逻辑回归的参数（权重 $w$ ）会趋向于无穷大，试图让预测概率无限接近0或1，从而使成本函数降为 0。这会导致数值上的不稳定。
- 而LDA是通过计算每个类别的均值和方差来确定模型的，这些统计量是稳定的，不会无限增大。因此，即使数据分得再开，LDA的模型参数也是稳定的。
处理多于 2个的类别时，更简单优雅
- LDA的框架天然支持多个类别。它为每个类别都拟合一个高斯分布，然后看新来的数据点更符合哪个类别的分布。
- 标准的逻辑回归是为二分类设计的。要处理多分类，就需要做一些修改，比如训练多个“一对多”的分类器，或者使用更复杂的Softmax回归。
当数据分布接近正态分布时，LDA更准确（尤其在样本少时）

逻辑回归的优势

更专注于决策边界，总能分开线性可分的数据
- 逻辑回归的唯一目标就是找到一个决策边界来最小化分类错误。只要数据是线性可分的，它就一定能找到一条线把它们分开。
在某些非高斯分布的数据上更稳健
- 这是LDA劣势的反面。正因为逻辑回归不对数据的分布做任何假设，所以当数据不符合高斯分布时（例如，数据有很长的“尾巴”或严重的偏斜），逻辑回归的表现通常会比LDA更好。
天然输出0到1之间的概率值
- 逻辑回归通过Sigmoid函数，其输出结果天然就是0到1之间的值，这可以很直观地被解释为分类的概率。

两者最根本的区别在于对数据点的处理上。逻辑回归更关注那些被错误分类或离决策边界很近的“问题”数据点。它在优化时，会给这些点更大的“权重”，努力把它们分对。对于那些已经被正确分类且离边界很远的点，它就不怎么关心了。而 LDA 对所有数据点一视同仁。在为每个类别计算均值和协方差时，每个点都贡献了相同的权重。这带来了下面的权衡：

逻辑回归的做法有利于降低训练误差，但如果数据中有一些“坏点”或“异常值”，模型就容易被这些坏点带偏，因为它太想把所有点都分对了。
LDA的做法对异常值不那么敏感，模型更稳定，但代价是如果它的高斯分布假设是错的，它可能无法得到最低的训练误差。

fyerfyer's Blog

nearest-neighbor-alg

最近邻算法

1. 最近邻分类

a.a.a. 核心思想

b.b.b. 对参数 kkk 的理解

c.c.c. 理论保证

2. 最近邻搜索算法

a.a.a. 穷举 k-NN 算法 (Exhaustive k-NN)

b.b.b. Voronoi 图的概念

c.c.c. 使用 Voronoi 图进行搜索

d.d.d. k-d 树的概念

e.e.e. 使用 k-d 树进行搜索

e.e.e. 近似搜索

Boosting 算法

Boosting 算法

1. AdaBoost 简介

2. 损失函数与公式推导

伪逆与神经网络生成方法优化

伪逆与神经网络生成方法优化

1. 伪逆

a.a.a. 定义

b.b.b. 重要性质

c.c.c. 几何直观

d.d.d. 在正规方程中的应用

2. 防止过拟合的方法整理

a.a.a. 数据增强

3. 双下降

无监督学习

无监督学习

1. 主成分分析

a.a.a. 概述

b.b.b. 算法

2. 奇异值分解

a.a.a. PCA 算法的问题

b.b.b. 数学推导

c.c.c. 主坐标

d.d.d. 紧凑 SVD

3. 聚类

a.a.a. 概述

b.b.b. k-means

c.c.c. 层次聚类

i.i.i. 聚类思想

b.b.b. 划分方法

卷积神经网络

卷积神经网络

1. 概述

a.a.a. 基本概念

b.b.b. 一个实际的例子

2. CNN 相关参数计算

3. 信息压缩与下采样

a.a.a. 池化

b.b.b. 步幅卷积

c.c.c. 全连接层

Homework6 Code Part1

Homework 6 Part1

1. 总体架构

2. 全连接层 FullyConnected

a.a.a. forward 方法

b.b.b. backward 方法

3. 批量归一化层 BatchNorm1D

a.a.a. 原理概述

b.b.b. forward 方法

c.c.c. backward 方法

4. 卷积层 Conv2D

a.a.a. 卷积层原理概述

b.b.b. 池化层原理概述

c.c.c. forward 方法

d.d.d. backward 方法

5. 池化层 Pool2D

a.a.a. forward 方法

b.b.b. backward 方法

6. 损失层

a.a.a. forward 方法

b.b.b. backward 方法

7. 最终的神经网络层

a.a.a. forward 方法

b.b.b. backward 方法

cs289-hw6

Introduction

$a.$ 核心思想

$b.$ 对参数 $k$ 的理解

$c.$ 理论保证

$a.$ 穷举 k-NN 算法 (Exhaustive k-NN)

$b.$ Voronoi 图的概念

$c.$ 使用 Voronoi 图进行搜索

$d.$ k-d 树的概念

$e.$ 使用 k-d 树进行搜索

$e.$ 近似搜索

$a.$ 定义

$b.$ 重要性质

$c.$ 几何直观

$d.$ 在正规方程中的应用

$a.$ 数据增强

$a.$ 概述

$b.$ 算法

$a.$ PCA 算法的问题

$b.$ 数学推导

$c.$ 主坐标

$d.$ 紧凑 SVD

$a.$ 概述

$b.$ k-means

$c.$ 层次聚类

$i.$ 聚类思想

$b.$ 划分方法

$a.$ 基本概念

$b.$ 一个实际的例子

$a.$ 池化

$b.$ 步幅卷积

$c.$ 全连接层

2. 全连接层 `FullyConnected`

$a.$ `forward` 方法

$b.$ `backward` 方法

3. 批量归一化层 `BatchNorm1D`

$a.$ 原理概述

$b.$ `forward` 方法

$c.$ `backward` 方法

4. 卷积层 `Conv2D`

$a.$ 卷积层原理概述

$b.$ 池化层原理概述

$c.$ `forward` 方法

$d.$ `backward` 方法

5. 池化层 `Pool2D`

$a.$ `forward` 方法

$b.$ `backward` 方法

$a.$ `forward` 方法

$b.$ `backward` 方法

$a.$ `forward` 方法

$b.$ `backward` 方法

$a.$ 赫布法则

$a.$ 优化算法的选择

$b.$ 学习率 $\epsilon$ 的选择

$c.$ 样本加权方案

$d.$ 数据标准化

$e.$ 权重初始化

$f.$ 动量

$a.$ 概述

$b.$ 解决 XOR 问题的思路

$a.$ 整体架构

$b.$ 权重矩阵与偏置项

$c.$ 前向传播 (Forward Propagation)

$a.$ 代价函数

$b.$ 梯度下降

$c.$ 局部最小值

$d.$ 权重初始化与对称性问题

$a.$ 核心思想

$b.$ 分支处理

$c.$ 具体流程

$d.$ 统一的梯度形式

$a.$ 梯度消失问题

$b.$ Softmax 函数

$a.$ 基本算法

$b.$ 随机化分裂类型

$a.$ 简介

$b.$ 基于最大后验概率的推导

$a.$ 前置概念

$b.$ 误差的数学分解

$c.$ 对最小二乘的应用