[Machine Learning] 损失函数和优化过程

文章目录

在统计学习的框架中，我们通常试图找到一个函数或概念，这个函数可以很好地解释或拟合给定的数据。这通常通过最小化某种风险或损失来实现。为了找到一个好的模型，我们尝试在预定义的假设空间 H H H 中找到一个函数，该函数在训练数据上的经验风险 (Empirical Risk) 最小。但是，我们的真正目标是找到一个函数，其预期风险 (Expected Risk)（对于所有可能的数据分布）最小。这通常需要平衡模型的复杂性与其在数据上的表现。

假设存在一个最佳函数或概念 c c c，它最好地拟合数据，即 c = arg min ⁡ h R ( h ) c = \argmin\limits_{h} R(h) c=hargminR(h)，其中 R ( h ) R(h) R(h) 是函数 h h h 的风险。

在实践中，我们不能在所有可能的函数空间中搜索，因此我们限制搜索在一个预定义的 hypothesis class（假设类） H H H中。给定训练样本 S = { ( X 1 , Y 1 ) , ... , ( X n , Y n ) } S = \{(X_1, Y_1), \dots, (X_n, Y_n)\} S={(X1,Y1),...,(Xn,Yn)}，我们可以计算函数 h h h 的经验风险 R S ( h ) R_S(h) RS(h) 为：

R S ( h ) = ∑ i = 1 n ℓ ( X i , Y i , h ) R_S(h) = \sum\limits_{i=1}^n \ell(X_i,Y_i,h) RS(h)=i=1∑nℓ(Xi,Yi,h)

预期风险是对于所有可能的数据分布的平均风险，定义为：

R ( h ) = E [ R S ( h ) ] = E [ ℓ ( X i , Y i , h ) ] R(h) = \mathbb{E}[R_S(h)] = \mathbb{E}[\ell(X_i,Y_i,h)] R(h)=E[RS(h)]=E[ℓ(Xi,Yi,h)]

在整个函数空间中的最佳假设 (目标概念) 是:

c = arg min ⁡ h R ( h ) c = \argmin\limits_{h} R(h) c=hargminR(h)

而在预定义的假设类 H H H 中的最优假设是:

h ∗ = arg min ⁡ h ∈ H R ( h ) h^* = \argmin\limits_{h \in H} R(h) h∗=h∈HargminR(h)

使用经验风险来估计 h h h 从训练数据中，我们得到:
h S = arg min ⁡ h ∈ H R S ( h ) = arg min ⁡ h ∈ H 1 n ∑ i = 1 n ℓ ( X i , Y i , h ) h_S = \argmin\limits_{h \in H} R_S(h) = \argmin\limits_{h \in H} \frac{1}{n} \sum\limits_{i=1}^n \ell(X_i,Y_i,h) hS=h∈HargminRS(h)=h∈Hargminn1i=1∑nℓ(Xi,Yi,h)

因此，选择一个合适的假设空间和损失函数 ℓ \ell ℓ 是至关重要的。

假设类 H H H是一个函数集，其中每个函数都尝试从输入特征映射到输出标签， H = { h 1 , h 2 , ... } H = \{ h_1, h_2, \dots \} H={h1,h2,...}。通常， H H H 由一个特定的算法或模型结构定义，如线性回归、决策树等。

首先，0-1损失函数是最直接的分类误差度量。对于给定的分类器 h h h，它只是简单地计算误分类的数据点的数量。数学上，这定义为： arg min ⁡ h E [ 1 Y ≠ s i g n ( h ( X ) ) ] \argmin\limits_{h} \mathbb{E}[1_{Y \neq sign(h(X))}] hargminE[1Y=sign(h(X))]。但我们通常遇到的问题是：

真实数据的分布 P ( X , Y ) P(X,Y) P(X,Y) 是未知的，因此我们不能直接计算上述期望。
0-1损失在计算上是困难的，因为它是不连续的、非凸的，这使得优化变得复杂。

大数定律描述了随机变量的样本均值与整体均值之间的关系。它确保了当样本大小趋于无穷大时，样本均值趋于整体均值。更形式化地说，考虑一个随机变量 X X X，其期望值为 E [ X ] \mathbb{E}[X] E[X]。对于 X X X 的 n n n 个独立同分布的样本 X 1 , X 2 , ... , X n X_1, X_2, \dots, X_n X1,X2,...,Xn，它们的样本均值定义为 X n ˉ = 1 n ∑ i = 1 n X i \bar{X_n} = \frac{1}{n} \sum_{i=1}^{n} X_i Xnˉ=n1∑i=1nXi。当 n → ∞ n \rightarrow \infty n→∞ 时, X n ˉ → E [ X ] \bar{X_n} \rightarrow \mathbb{E}[X] Xnˉ→E[X]。

通过大数定律，我们可以使用这些样本来估计某些与分布相关的数量，例如期望损失。假设我们的目标是估计由假设 h h h 引起的期望损失 E [ 1 Y ≠ sign ( h ( X ) ) ] \mathbb{E}[1_{Y \neq \text{sign}(h(X))}] E[1Y=sign(h(X))]。我们可以使用来自真实分布的样本 D \mathcal{D} D 来估计这个期望：

1 n ∑ i = 1 n 1 Y i ≠ sign ( h ( X i ) ) \frac{1}{n} \sum_{i=1}^{n} 1_{Y_i \neq \text{sign}(h(X_i))} n1i=1∑n1Yi=sign(h(Xi))

随着样本数量 n n n 的增加，上述估计将接近真实的期望损失。

为了在实践中使问题变得可解，我们使用所谓的 surrogate loss function（替代损失函数），它们在优化上更容易处理，但仍旨在近似0-1损失函数。

Hinge loss（合页损失）：这是支持向量机中使用的损失函数。
ℓ ( X , Y , h ) = max ⁡ { 0 , 1 − Y h ( X ) } \ell(X,Y,h) = \max \{0,1−Yh(X)\} ℓ(X,Y,h)=max{0,1−Yh(X)}
Logistic loss（逻辑损失）：这是逻辑回归中使用的。它对于异常值更为稳健，并且为概率提供了良好的估计。
Least square loss（最小二乘损失）：主要在回归问题中使用。
Exponential loss（指数损失）：是AdaBoost算法中使用的损失函数。

大多数流行的替代损失函数都是为了在大样本极限下模拟0-1损失函数的效果。这些被称为 classification-calibrated （分类校准的）替代损失函数。这意味着，如果训练数据无穷大，则使用这些损失函数训练的分类器在0-1损失上的表现将与真正的最佳分类器一致。

给定一个代理损失函数 ℓ \ell ℓ 和相应的函数 ϕ \phi ϕ 使得 ϕ ( Y h ( X ) ) = ℓ ( X , Y , h ) \phi(Yh(X)) = \ell(X, Y, h) ϕ(Yh(X))=ℓ(X,Y,h)。这里， Y Y Y 是标签，取值为 ( − 1 , 1 ) (-1, 1) (−1,1)，而 h ( X ) h(X) h(X) 是分类器对输入 X X X 的预测得分。为了检查 ℓ \ell ℓ 是否是分类校准的，我们通常检查以下条件:

ϕ \phi ϕ 是凸的。
ϕ \phi ϕ 在0处可导，并且 ϕ ′ ( 0 ) < 0 \phi'(0) < 0 ϕ′(0)<0。

满足上述条件意味着在大部分情况下，对于一个给定的数据点，分类器 h h h 使代理损失最小化时，也会使0-1损失最小化。

例如，考虑Hinge损失 ℓ hinge ( X , Y , h ) = max ⁡ { 0 , 1 − Y h ( X ) } \ell_{\text{hinge}}(X,Y,h) = \max \{ 0, 1-Yh(X) \} ℓhinge(X,Y,h)=max{0,1−Yh(X)}

对应的 ϕ \phi ϕ 函数为 ϕ ( z ) = max ⁡ { 0 , 1 − z } \phi(z) = \max \{ 0, 1-z \} ϕ(z)=max{0,1−z}

这个函数在 z = 1 z=1 z=1 处是不可导的，但是在 z = 0 z=0 z=0 处是可导的，且其导数小于0，因此Hinge损失是分类校准的。

现在可以考虑以下两个分类器的定义：

h s h_s hs 是基于有限训练数据和替代损失函数的最优分类器。
h c h_c hc 是基于整个数据分布和0-1损失函数的最优分类器。

使用替代损失函数和训练数据，我们可以找到 h s h_s hs：

h s = arg min ⁡ h 1 n ∑ i = 1 n ℓ ( X i , Y i , h ) h_s = \argmin\limits_{h} \frac{1}{n} \sum\limits_{i=1}^n \ell(X_i,Y_i,h) hs=hargminn1i=1∑nℓ(Xi,Yi,h)

与此同时，如果我们知道整个数据的分布，我们可以找到 h c h_c hc：

h c = arg min ⁡ h E [ 1 Y ≠ sign ( h ( X ) ) ] h_c = \argmin\limits_{h} \mathbb{E}[1_{Y \neq \text{sign}(h(X))}] hc=hargminE[1Y=sign(h(X))]

当我们的训练数据量无限大时，使用替代损失函数得到的 h s h_s hs 将与使用0-1损失函数得到的 h c h_c hc越来越接近。这可以通过以下公式表示：

E [ 1 Y ≠ sign ( h S ( X ) ) ] ⟶ n → ∞ E [ 1 Y ≠ sign ( h c ( X ) ) ] \mathbb{E}[1_{Y \neq \text{sign}(h_S(X))}] \overset{n \rightarrow \infty}{\longrightarrow} \mathbb{E}[1_{Y \neq \text{sign}(h_c(X))}] E[1Y=sign(hS(X))]⟶n→∞E[1Y=sign(hc(X))]

这意味着，当我们基于有限的样本数据集优化代理损失时，我们实际上是在优化该数据集上的经验损失。大数定律保证，随着样本数的增加，这个经验损失的期望会接近于真实的期望损失。同时，如果我们的代理损失是分类校准的，那么优化这个代理损失将隐式地优化0-1损失。当训练数据的大小趋向于无穷大时，通过最小化替代损失函数得到的分类器的期望0-1损失将趋近于最优的0-1损失。

当替代损失函数是凸的且光滑时，我们可以使用一系列的优化算法，如梯度下降、牛顿法等，来解决以下问题：
h = arg min ⁡ h ∈ H 1 n ∑ i = 1 n ℓ ( X i , Y i , h ) h = \argmin\limits_{h \in H} \frac{1}{n} \sum\limits_{i=1}^n \ell(X_i,Y_i,h) h=h∈Hargminn1i=1∑nℓ(Xi,Yi,h)

假设函数 (f(h)) 在点 (h_k) 是可微的，我们可以使用泰勒级数来近似函数在 (h_k) 附近的值：
f ( x + Δ x ) ≈ f ( x ) + ∇ f ( x ) T Δ x + 1 2 Δ x T ∇ 2 f ( x ) Δ x + ... f(x + \Delta x) \approx f(x) + \nabla f(x)^T \Delta x + \frac{1}{2} \Delta x^T \nabla^2 f(x) \Delta x + \dots f(x+Δx)≈f(x)+∇f(x)TΔx+21ΔxT∇2f(x)Δx+...

如果我们只考虑上述近似的第一项和第二项（线性近似），我们得到：
f ( h + Δ h ) ≈ f ( h ) + ∇ f ( h ) T Δ h f(h + \Delta h) \approx f(h) + \nabla f(h)^T \Delta h f(h+Δh)≈f(h)+∇f(h)TΔh

现在，考虑我们的梯度下降更新步骤： h k + 1 = h k + η d k h_{k+1} = h_k + \eta d_k hk+1=hk+ηdk，其中 d k d_k dk 是下降方向， Δ h = η d k \Delta h = \eta d_k Δh=ηdk。我们要找到一个 Δ h \Delta h Δh 使得 f ( h + Δ h ) f(h + \Delta h) f(h+Δh) 尽可能小。从上面的线性近似中，我们可以看到，要使 f ( h + Δ h ) f(h + \Delta h) f(h+Δh) 的增量 ∇ f ( h ) T Δ h \nabla f(h)^T \Delta h ∇f(h)TΔh 尽可能小， Δ h \Delta h Δh 应该与梯度 ∇ f ( h ) \nabla f(h) ∇f(h) 的反方向对齐。因此，通常会选择梯度的负方向 − ∇ f ( h ) -\nabla f(h) −∇f(h) 作为下降方向。

但是，如果我们想利用函数在某个点的曲率信息，或者加速优化过程，我们就可以引入 D k D^k Dk 这样的矩阵,，矩阵 D k D^k Dk 通常被称为预条件矩阵或缩放矩阵。

考虑到一般的更新规则 h k + 1 = h k − η D k ∇ f ( h k ) h_{k+1} = h_k - \eta D^k \nabla f(h_k) hk+1=hk−ηDk∇f(hk)。其中， D k D^k Dk 是一个正定对称矩阵。正定性保证了更新的方向是下降方向，即 ∇ f ( h k ) T D k ∇ f ( h k ) > 0 \nabla f(h_k)^T D^k \nabla f(h_k) > 0 ∇f(hk)TDk∇f(hk)>0。

Steepest Descent（最速下降法）

D k = I D^k = I Dk=I

此时，矩阵 D k D^k Dk 是单位矩阵，这意味着我们只沿着梯度的负方向移动。
Newton's Method（牛顿法）

D k = [ ∇ 2 f ( h k ) ] − 1 D^k = [\nabla^2 f(h_k)]^{-1} Dk=[∇2f(hk)]−1

这里，矩阵 D k D^k Dk 是Hessian矩阵的逆，Hessian矩阵给出了函数的曲率信息。使用Hessian矩阵的逆可以帮助算法更快地收敛，但计算可能会更加昂贵，尤其是在高维度情况下。

假设我们已经选择了下降方向 d k d_k dk，Exact Line Search是这样定义的： η = arg min ⁡ η f ( h k − η ∇ f ( h k ) ) \eta = \argmin\limits_{\eta} f(h_k - \eta \nabla f(h_k)) η=ηargminf(hk−η∇f(hk))

简单地说，它搜索一个步长 η \eta η，使得从当前位置 h k h_k hk开始，沿着梯度方向移动 η \eta η步长后，函数 f f f达到最小值。尽管这种方法可以找到最佳的步长，但在实际应用中，它可能会很昂贵，因为每次迭代都需要求解一个新的优化问题。

L-Lipschitz连续描述了一个函数的增长率是有界的。如果一个函数满足Lipschitz连续性，则该函数的变化速率在任意两点之间都是有限的，并且受到某个常数的约束。

给定一个函数 f f f ，如果存在一个正常数 L L L ，使得对于定义域内的任意两点 x 1 x_1 x1 和 x 2 x_2 x2 ，都满足以下条件：
∣ f ( x 1 ) − f ( x 2 ) ∣ ≤ L ∣ ∣ x 1 − x 2 ∣ ∣ |f(x_1) - f(x_2)| \leq L ||x_1 - x_2|| ∣f(x1)−f(x2)∣≤L∣∣x1−x2∣∣

，那么我们称函数 f f f 是 L-Lipschitz连续的。

如果已知梯度是L-Lipschitz连续的，那么可以使用以下公式选择学习率：

h k + 1 = h k − 1 L ∇ f ( h k ) h_{k+1} = h_k - \frac{1}{L} \nabla f(h_k) hk+1=hk−L1∇f(hk)

梯度下降:
- 假设:
  - Lipschitz梯度：这意味着梯度(或导数)的变化受到上限。
  - 凸函数: 函数在其定义域上至少是局部凸的。
- 收敛速率:
  O ( 1 k ) O\left(\frac{1}{k}\right) O(k1)
  这意味着算法的误差随迭代次数k的逆减少。
梯度下降:
- 假设:
  - Lipschitz梯度
  - 强凸性：比常规凸函数有更严格的凸性，这意味着函数有一个下界。
- 收敛速率:
  O ( 1 − μ L ) k O\left(1-\frac{\mu}{L}\right)^k O(1−Lμ)k
  其中, μ \mu μ 是强凸性参数, L L L 是Lipschitz常数。此收敛速率比简单凸函数更快。
牛顿法:
- 假设:
  - Lipschitz梯度
  - 强凸性
- 收敛速率:
  ∑ i = 1 k ρ k \sum\limits_{i = 1}^{k}\rho_k i=1∑kρk
  其中, ρ k → 0 \rho_k \rightarrow 0 ρk→0。这意味着牛顿法的收敛速度非常快，尤其是当接近最优解时。

\textbf{牛顿法及其变种}:

牛顿法是一种迭代优化算法，用于在实数或复数域中寻找函数的零点。在机器学习和优化中，牛顿法经常被用来寻找损失函数的最小值。这种方法的核心思想是使用函数的二阶泰勒级数展开来迭代地近似函数的零点或最小值。

牛顿法的优点是，如果函数是二次的，那么可以在一次迭代中找到最小值。

在实践中，计算Hessian矩阵和其逆可能会遇到困难，尤其是当维度很高时。因此，提出了多种牛顿法的实用变种。
修改Hessian以确保其为正定:

为了确保Hessian矩阵是可逆的和正定的，我们可以对其进行微小的修改，例如，通过向其添加一个正则化项。
每m次迭代计算一次Hessian:

由于Hessian矩阵的计算可能是计算密集型的，所以一个策略是每m次迭代计算一次，而在其他迭代中使用最近计算的Hessian。
只使用Hessian的对角线:

通过只考虑Hessian矩阵的对角线元素，可以大大减少计算的复杂性。这种方法称为对角Hessian牛顿法。
拟牛顿法:

拟牛顿法是一种旨在近似Hessian矩阵而避免直接计算它的方法。其中，BFGS (Broyden--Fletcher--Goldfarb--Shanno algorithm) 和L-BFGS (Limited-memory BFGS) 是最著名的拟牛顿方法。L-BFGS 是BFGS的内存效率版本，只存储Hessian矩阵的最近的几个更新。

在机器学习中，我们经常关心两种主要的误差来源：近似误差 (Approximation Error) 和估计误差 (Estimation Error)。近似误差是因预定义的假设空间 H H H 的限制而导致的误差，它是最优假设 h ∗ h^* h∗ 和目标概念 c c c 之间的差异。估计误差是由于有限的样本大小而导致的误差，它是从数据中学习的假设 h S h_S hS 和最优假设 h ∗ h^* h∗ 之间的差异。

如果目标概念 c c c 在预定义的假设空间 H H H 中，那么近似误差将为零。然而，选择一个大而复杂的假设空间虽然可以减小近似误差，但它会增加估计误差，因为模型可能会过拟合数据。

为了解释为什么选择大的假设空间会导致大的估计误差，我们引入了 Probably Approximately Correct (PAC) 学习框架。PAC学习提供了一种量化学习算法性能的方法，特别是在考虑有限的样本大小和特定的假设空间时。它的核心思想是，对于足够大的样本大小，算法将以高概率找到一个近似正确的假设。