AUC 和排序损失（Rank loss）的关系，这问题我在面试、评审、代码 review 里被问过不下二十次。很多人第一次听到“AUC 就是配对误排序率”时会点头，回头写代码还是老老实实挂一个 BCE，然后在排序指标上反复调参。这篇文章我不打算做名词解释流水线，而是把这两者从定义、公式、代理损失一路推到 PyTorch 里能跑的代码，再把我自己在实际训练里踩过的坑摊开来说。适合谁看？写过排序或推荐模型、被“loss 降了 AUC 不涨”折磨过的人；也适合刚学完 ROC 曲线、想知道 AUC 到底能不能反传的人。核心关键词 AUC、排序损失、Rank loss 会在下面反复出现，但我尽量让它们出现在干货里，而不是标题里堆着好看。

1. AUC 到底量的是什么：先把“抽一对”这件事说透

1.1 把 AUC 拆成一次抽签实验

绝大部分教材讲 AUC 都从 ROC 曲线下手：横轴假正率、纵轴真正率，扫一遍阈值画曲线，取线下面积。这条路严谨，但不利于建立直觉。我更愿意换一种说法：把测试集里所有正样本扔进一个袋子，所有负样本扔进另一个袋子，你随机从两个袋子里各抽一个出来，让模型给它们打分，如果正样本分数比负样本高，记 1 分；低就记 0 分；打平记 0.5 分。把这个实验重复到穷尽所有组合，平均分就是 AUC。

这个视角一下子就把 AUC 的性质暴露干净了。第一，AUC 只关心相对顺序，不关心分数的绝对值，你把所有分数取对数、取平方、加个常数，只要单调变换不变，AUC 一个字节都不会动。第二，AUC 对正负样本比例不敏感——因为你每次都是“各抽一个”，袋子大小不影响单次实验的概率。这也是为什么负样本从 1 万降到 1 千，AUC 往往几乎不变，而准确率会剧烈波动的原因。第三，AUC 是对所有配对等权平均的，不管这个配对是“头部样本”还是“尾部样本”，只要抽到就算一份。这一点后面会变成一个非常重要的批评点，因为绝大多数排序损失并不是等权的。

顺带说一个常见误区：AUC 不是“准确率”，也不是“排序质量”的全部。一个在头部排序极准、尾部排得乱七八糟的模型，AUC 可能很高；一个概率校准很差但排序单调的模型，AUC 也是满分。所以业务上如果是“只看前 10 个位置”，AUC 会给你过于乐观的估计，这时候要看 precision@k 或者 NDCG。

1.2 排序损失（Rank loss）在优化什么

排序损失这个词覆盖面很宽，但它们的共同思路只有一个：不去单独约束每个样本的分数，而是一对一对地、或者一列表一列表地约束“谁应该在谁前面”。最小粒度的写法是 pairwise（成对）：给我一对样本 $(i, j)$，其中 $i$ 应该是正例、$j$ 应该是负例，你模型给它们的分数差 $s_i - s_j$ 越大越好，越小我罚你越多。这就是排序损失最核心的形态。

再往上一层是 listwise（列表级）：一次给我一整个候选列表，我要求整个列表的排序尽量符合某种整体指标，比如 NDCG、比如 softmax 似然。listwise 的梯度通常是“相对权重”的形式，谁的顺序错了、错了多少位、换位后指标损失多少，都会体现在梯度大小上。LambdaRank 那一套就是在做这件事：把 $\lambda_{ij}$ 定义为交换 $i$、$j$ 之后 NDCG 的变化量，然后沿着方向推。

这两个层次的区别在实际训练里非常关键。pairwise 损失本质上只在关心“pair 内的二元比较”，它不知道第 3 名和第 30 名有什么差别；listwise 损失则能看到整个列表的分布，它对头部位置通常更敏感（因为 exp 会把大分数放大）。而你最终用来验收的指标 AUC，恰好是等权 pairwise 的——这个错位，就是后面很多奇妙现象的根源。

1.3 一句话先说清两者的关系

如果只用一句话概括：AUC 是“配对误排序率”的补集，而排序损失是这个不可导的配对误排序率的一个可导代理。展开一点说，AUC 度量的是“随机的正负对里，正样本排在前面的比例”，那么 $1 - \text{AUC}$ 自然就是“随机正负对里，排错的比例”。这个比例在数学上精确等于一种 0-1 配对损失在全体配对上的期望。而 0-1 损失不可导，没法拿来做梯度下降，所以我们用 logistic、hinge 这类“平滑版”的配对损失去替代它——这就是 RankNet、RankSVM 那一系方法的由来。

理解了这套逻辑，你就能回答很多实际问题：为什么用 pair 损失训出来的模型 AUC 通常比纯 BCE 高一点；为什么 biclass 交叉熵的 loss 降到底了 AUC 还在动；为什么在极端不平衡的数据上 Auc 和 loss 会背离。这些问题在后面的章节里都会具体展开。

2. 把关系从数学上钉死：$1 - \text{AUC}$ 就是配对误排序率

2.1 AUC 的期望形式与经验形式

设正样本集合为 $\mathcal{P}$，样本量为 $P$；负样本集合为 $\mathcal{N}$，样本量为 $N$；模型打分函数为 $s(\cdot)$。AUC 的期望形式可以写成：

$$\text{AUC} = \mathbb{P}\big(s(x^+) > s(x^-)\big) + \tfrac{1}{2}\mathbb{P}\big(s(x^+) = s(x^-)\big)$$

这里的 x⁺ 和 x⁻ 是独立地从正负分布里各抽一个样本。经验形式就是把期望换成样本平均：

$$\text{AUC} = \frac{1}{PN}\sum_{i \in \mathcal{P}}\sum_{j \in \mathcal{N}} \Big( \mathbb{1}[s_i > s_j] + \tfrac{1}{2}\mathbb{1}[s_i = s_j] \Big)$$

这个式子和统计里的 Wilcoxon-Mann-Whitney U 统计量是同一个东西，只是归一化方式不同。知道这一点的好处是：你完全可以用排序法在 $O((P+N)\log(P+N))$ 的时间里算 AUC，而不需要真的去遍历 $P \times N$ 个配对。具体做法是把所有样本混在一起按分数排序，求正样本的秩和，然后套公式 $\text{AUC} = \frac{\sum \text{rank}_i - P(P+1)/2}{PN}$。1000 个正样本、10 万个负样本的话，逐对法是 1 亿次比较，排序法几千万次就搞定了，差了两个数量级。

提示：如果你的 AUC 是拿“逐对遍历”实现的，在负样本上百万的场景里它会直接把评估脚本跑成 PPT。评估阶段请务必用排序法或者现成库。

2.2 恒等式：$1 - \text{AUC}$ 等于配对 0-1 损失的均值

现在定义配对 0-1 损失，注意这里 $i$ 是正样本、$j$ 是负样本：

$$\ell_{01}(s_i, s_j) = \mathbb{1}[s_i < s_j] + \tfrac{1}{2}\mathbb{1}[s_i = s_j]$$

因为对任意一对，三种情况（大于、等于、小于）互斥且完备，所以有：

$$\ell_{01}(s_i, s_j) + \Big(\mathbb{1}[s_i > s_j] + \tfrac{1}{2}\mathbb{1}[s_i = s_j]\Big) = 1$$

两边对所有配对求和再除以 $PN$，立刻得到：

$$1 - \text{AUC} = \frac{1}{PN}\sum_{i}\sum_{j} \ell_{01}(s_i, s_j)$$

这就是那个“钉死”关系的恒等式，没有任何近似。它告诉你：AUC 不是一个抽象的曲线面积，它就是一个具体的损失函数的期望值。你想提高 AUC，等价于你想压低这个配对 0-1 损失。反过来说，任何最小化配对 0-1 损失的方法，都在直接优化 AUC。

这个恒等式还有一个副产品：它解释了为什么 AUC 在正负样本比例 100:1 和 1:1 的情况下数值差不多。因为式子里的 $PN$ 是归一化因子，配对的数量变了，但每一对的“权重”被均摊掉了，比例不影响结果。而准确率没有这个归一化，所以会随着比例剧烈漂移。

2.3 tie 为什么按 0.5 算

打平的时候记 0.5，这不是随手拍的。从期望角度，如果你把“打平”当作抛硬币决定谁在前，那么一对打平的样本有 50% 概率被判对、50% 被判错，取平均正好是 0.5。从统计角度，U 统计量本来就对结（tie）用平均秩处理，0.5 是平均秩在二值情形下的自然结果。

这个 0.5 在实际业务里非常要命。假设你的模型输出被量化成整数（很多线上打分服务为了省带宽会做定点化），那么大量样本会落在同一个分数上。这时候 AUC 会被“拽”向 0.5，因为打平的对贡献 0.5 而不是 1。我见过一个团队把线上分数从 float32 截断到 3 位小数，离线 AUC 掉了 0.6 个点，排查了两天才发现是量化引入的 tie，而不是模型变差。

注意：评估前检查一下打分是否存在大量重复值。如果唯一值数量远小于样本数，AUC 已经不可信了，先解决精度问题。

2.4 不可导：为什么这个漂亮的损失不能直接反传

理论上，既然 $1 - \text{AUC}$ 就是损失，那直接把它当 loss 反传不就行了？问题出在指示函数上。$\mathbb{1}[s_i < s_j]$ 是阶跃函数，除了 $s_i = s_j$ 那一瞬间，导数处处为零。这意味着梯度几乎全部消失，优化器完全不知道往哪个方向走。即使你在 $s_i = s_j$ 处强行定义次梯度，那也只是一个孤立点上的信息，对绝大多数样本毫无指导意义。

更麻烦的是，这个损失对参数的依赖是“分片常数”的：你稍微动一下参数，只要没有跨过某个临界点让某一对的顺序翻转，损失值一点都不变。这种“平坦 + 断崖”的损失曲面，梯度下降基本无能为力。

所以从业者的做法是找一个代理损失（surrogate loss）：它在数学上平滑、可导、凸（最好），同时和 0-1 损失的形状“长得像”——分数差为正且很大时损失接近 0，分数差为负时损失快速上升。这个替换是否可靠，就成了理论上的核心问题。

2.5 代理损失凭什么能代替它：一致性的通俗解释

这里要引入一个概念叫“一致性（consistency）”。通俗地说：如果我把代理损失优化到它的理论最优，那么对应的 0-1 损失（也就是 $1-\text{AUC}$）是不是也达到了最优？如果是，这个代理就是“一致的”；如果不是，我可能在优化一个和 AUC 南辕北辙的东西。

好消息是，logistic 损失和 hinge 损失都是具有一致性的代理，这类结论在统计学习理论里有比较成熟的刻画。直观理解：这两个损失都是凸的、单调递减、在分数差为 0 处的导数严格为负，满足“界”的条件——它们能从上方控制住 0-1 损失，反过来当代理损失趋近 0 时，0-1 损失也必须趋近 0。这就保证了优化的方向不会跑偏。

但“一致性”是一个渐近概念，说的是样本趋于无穷、优化到全局最优时的行为。实际训练里我们用的是小批量、有限步、局部最优，一致性给不了任何保证。所以我一直认为：一致性是让你敢用这个代理的底气，不是让你相信它一定好用的理由。真正决定成败的是采样策略、batch 构成、梯度尺度这些工程细节。

另外还有一个容易被忽略的点：AUC 的样本估计本身是个 U 统计量，方差比普通均值大不少。正样本只有几百个的时候，AUC 的 bootstrap 置信区间可能宽到 ±0.02。这意味着你在验证集上看到的 AUC 涨了 0.003，很可能只是噪声。做对比实验时务必固定随机种子、多跑几次，或者干脆用交叉验证的分组均值。

3. 不同排序损失和 AUC 的“亲疏远近”

3.1 Pairwise Logistic：和 AUC 血缘最近的那个

这是 RankNet 用的损失，也是我认为在“贴近 AUC”这件事上最直接的形态：

$$\ell(s_i, s_j) = \log\big(1 + e^{-(s_i - s_j)}\big)$$

它就是 softplus 作用于负的分数差。为什么说它贴近 AUC？因为它对每一对样本的权重是完全相同的，平均下来正好是“配对误排序率”的一个平滑替代。你对它求梯度：

$$\frac{\partial \ell}{\partial s_i} = -\frac{1}{1 + e^{s_i - s_j}} = -\sigma(s_j - s_i)$$

$$\frac{\partial \ell}{\partial s_j} = +\frac{1}{1 + e^{s_i - s_j}} = +\sigma(s_j - s_i)$$

注意这个 $\sigma(s_j - s_i)$ 的物理含义：当模型把这对排反了、而且反得很离谱（$s_j \gg s_i$）时，它接近 1，梯度大；当排对了而且很确定（$s_i \gg s_j$）时，它接近 0，梯度自动消失。这就是所谓的“难例优先”，也是 LambdaRank 里那个 $\lambda$ 的原始来源——后来大家给 $\lambda$ 乘上交换位置导致的 NDCG 变化量 $|\Delta \text{NDCG}|$，就得到了 LambdaRank。

所以如果你只想要一个“最像 AUC”的损失函数，pairwise logistic 就是默认答案。它的缺点也很明显：配对数量是 $P \times N$，全量算不动，必须采样；而且它对难例的敏感度是“连续”的，不像 hinge 那样直接截断。

3.2 Hinge（RankSVM）：带间隔的版本

$$\ell(s_i, s_j) = \max\big(0,\ m - (s_i - s_j)\big)$$

这里的 $m$ 是间隔（margin），通常取 1。含义是：光排对还不够，分数差要超过 $m$ 才算“合格”，否则照样罚。这个设计的动机和 SVM 一样，是为了让决策边界有一定的余量，提升泛化。

从 AUC 的角度看，hinge 和 logistic 是一致的，都满足凸性和单调性。但行为差别不小：hinge 在分数差超过 $m$ 之后梯度直接为 0，不再优化“已经排对的样本”；而 logistic 永远有一点点梯度，会继续把分数差拉大。在排序任务里，这个差别会导致：用 hinge 训出来的模型，分数分布容易出现一堆挤在间隔边界附近的值，tie 变多；用 logistic 训出来的模型，分数分布拉得更开。

我个人在排序任务上更偏 logistic，因为分数拉得开对下游的阈值切分、多模型融合更友好。hinge 的优势在样本极少、需要强正则的场景，它的稀疏性（只有违反间隔的样本贡献梯度）本身就是一种正则。

3.3 Listwise 的 softmax 交叉熵：更“聪明”，但不一定更贴 AUC

listwise 最常见的形式是 softmax 交叉熵。假设一个列表里有若干正样本和若干负样本，对每个正样本 $i$：

$$\ell = -\log \frac{e^{s_i / \tau}}{\sum_{k} e^{s_k / \tau}}$$

$\tau$ 是温度。这个损失和 pairwise logistic 有一个很漂亮的联系：可以证明在只有 1 正 1 负时，它退化成 pairwise logistic；但在多负样本时，它给每个负样本的权重是 softmax 概率，是“按分数相对大小”分配的，而不是等权。

这就是关键差异所在。AUC 对每个负样本等权，而 softmax 对“当前分数高的负样本”赋予更大权重。这在召回场景其实是好事——你更关心把那些混进头部的负样本压下去；但对 AUC 来说，一个排在第 900 名的负样本和排在第 2 名的负样本权重完全一样，softmax 会把大量梯度花在头部，尾部样本被“忽略”了。结果就是：softmax 训出来的模型头部排序很漂亮，AUC 却不一定比 pairwise 高。

这里要提一句 LambdaLoss 那套框架，它把很多 listwise 损失统一成“$\lambda$ 加权”的形式，权重来自指标增益。用 NDCG 增益加权，优化的就是 NDCG；用 1 加权，优化的就退化成 pairwise。这套框架的价值在于让你意识到：你选的不是“一个损失”，你选的是“每个配对的权重”。想让损失更贴 AUC，就把权重设成常数；想让损失更贴头部业务，就把权重设成位置衰减的。

3.4 四类损失的对照

这张表的用法是：如果你的验收指标就是 AUC，优先选等权的 pairwise logistic；如果你验收的是 NDCG@10 或者头部转化，listwise 更合适；如果两者都要，用 Lambda 加权把权重调成位置敏感的折中方案。

4. 动手：用 PyTorch 手写配对损失并盯住 AUC

4.1 造数据与打分模型

先构造一个不平衡的二分类数据集，正样本占 10%，模拟真实排序场景里的长尾分布。模型用一个简单的 MLP 打分器，输出一维分数，不做 sigmoid——记住，AUC 只关心顺序，套 sigmoid 只是单调变换，不影响 AUC，但会影响数值稳定性，实践中我倾向于输出裸分数（logit），在需要概率的时候再单独校准。

import numpy as np import torch import torch.nn as nn import torch.nn.functional as F from sklearn.datasets import make_classification from sklearn.model_selection import train_test_split from sklearn.metrics import roc_auc_score X, y = make_classification( n_samples=30000, n_features=30, n_informative=8, n_redundant=0, weights=[0.9, 0.1], random_state=42 ) X_tr, X_va, y_tr, y_va = train_test_split( X, y, test_size=0.25, stratify=y, random_state=42 ) X_tr = torch.tensor(X_tr, dtype=torch.float32) y_tr = torch.tensor(y_tr, dtype=torch.float32) X_va = torch.tensor(X_va, dtype=torch.float32) y_va = torch.tensor(y_va, dtype=torch.float32) class Scorer(nn.Module): def __init__(self, in_dim): super().__init__() self.net = nn.Sequential( nn.Linear(in_dim, 64), nn.ReLU(), nn.Linear(64, 32), nn.ReLU(), nn.Linear(32, 1) ) def forward(self, x): return self.net(x).squeeze(-1)

这里有个细节值得说：squeeze(-1)别写成squeeze()，否则 batch size 为 1 的时候会把整个维度压没，得到一个标量，后续的unsqueeze全部错乱。这类 bug 在小 batch 调试时几乎必现，我踩过不止一次。

4.2 三种损失的实现与数值稳定

先说 pairwise logistic。最直观的写法是torch.log(1 + torch.exp(-diff))，但这个式子在diff是很小的负数时（也就是严重排反时）会溢出：exp(-diff)变成天文数字，log之后得到 inf，反向传播直接 nan。正确做法是用softplus，它内部做了 log-sum-exp 的稳定化处理。

def pairwise_logistic_loss(scores, labels, tau=1.0): pos = scores[labels == 1] neg = scores[labels == 0] if pos.numel() == 0 or neg.numel() == 0: # 保留计算图，返回 0 梯度 return scores.sum() * 0.0 diff = pos.unsqueeze(1) - neg.unsqueeze(0) # (P, N) return F.softplus(-diff / tau).mean()

tau是温度，取值小于 1 会让损失对分数差更敏感、梯度更集中在难例上；大于 1 则更平滑。我在训练初期用 1.0 保证稳定，后期降到 0.5 做“锐化”，效果类似于一个软性的难例挖掘。

return scores.sum() * 0.0这一行是必须的，不能直接return 0。直接返回 Python 标量，反向传播会报“不参与计算图”的错，或者更糟——静默地不更新参数。这种静默失败最难排查，因为 loss 曲线看起来正常，模型就是不涨。

再看 hinge 和 listwise：

def pairwise_hinge_loss(scores, labels, margin=1.0): pos = scores[labels == 1] neg = scores[labels == 0] if pos.numel() == 0 or neg.numel() == 0: return scores.sum() * 0.0 diff = pos.unsqueeze(1) - neg.unsqueeze(0) return torch.clamp(margin - diff, min=0).mean() def listwise_softmax_loss(scores, labels, tau=1.0): pos_mask = labels == 1 if pos_mask.sum() == 0: return scores.sum() * 0.0 logits = scores / tau log_z = torch.logsumexp(logits, dim=0) return (log_z - logits[pos_mask]).mean()

logsumexp同样是稳定性考虑，自己写torch.log(torch.exp(x).sum())在大分数上必溢出。listwise 这里假设“一个 batch 就是一个候选列表”，如果你的 batch 是多个列表拼起来的，需要按列表做 segment logsumexp，那是另一套实现（可以用 scatter 或者循环分组）。

4.3 AUC 的两种算法

评估阶段我用 sklearn 的roc_auc_score，但为了让你看清它和配对损失的关系，这里手写一个逐对版本和一个排序版本，两者结果必须一致。

def auc_by_pairs(pos, neg): diff = pos.unsqueeze(1) - neg.unsqueeze(0) win = (diff > 0).float() + 0.5 * (diff == 0).float() return win.mean().item() def auc_by_rank(scores, labels): order = torch.argsort(scores) s_sorted = scores[order] n = s_sorted.numel() ranks = torch.empty(n, dtype=torch.float32) i = 0 while i < n: j = i while j + 1 < n and s_sorted[j + 1] == s_sorted[i]: j += 1 ranks[i:j + 1] = (i + j) / 2.0 + 1.0 # 平均秩，1-based i = j + 1 ranks_orig = torch.empty_like(ranks) ranks_orig[order] = ranks P = (labels == 1).sum().item() N = (labels == 0).sum().item() pos_rank_sum = ranks_orig[labels == 1].sum().item() return (pos_rank_sum - P * (P + 1) / 2.0) / (P * N)

这里的平均秩处理就是 tie 的 0.5 来源。排序版本在样本量大时快得多，我实测在 30 万样本上，逐对版本要跑十几秒，排序版本 0.1 秒以内。校验的时候建议两种都跑一遍，差值小于 1e-6 才算实现对，因为这是你后面对比实验的地基。

4.4 训练循环与对比实验

关键在于 batch 的构造。如果直接随机采 batch，正样本只占 10%，一个 512 的 batch 里只有 50 个正样本、460 个负样本，配对数量 23000，勉强够用；但如果正样本比例降到 1%，一个 batch 里可能一个正样本都没有，pairwise 损失直接返回 0，模型就停在那不动了。所以我的做法是分层采样：每个 step 固定采 128 个正样本、384 个负样本，正样本不够就重复采样。

def make_batch(pos_idx, neg_idx, n_pos=128, n_neg=384, gen=None): ip = torch.randint(0, len(pos_idx), (n_pos,), generator=gen) ineg = torch.randint(0, len(neg_idx), (n_neg,), generator=gen) idx = torch.cat([pos_idx[ip], neg_idx[ineg]]) return idx def train(loss_fn, epochs=30, lr=1e-3, seed=0): torch.manual_seed(seed) g = torch.Generator().manual_seed(seed) model = Scorer(X_tr.shape[1]) opt = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=1e-5) pos_idx = torch.where(y_tr == 1)[0] neg_idx = torch.where(y_tr == 0)[0] steps = len(pos_idx) // 128 for ep in range(epochs): model.train() for _ in range(steps): idx = make_batch(pos_idx, neg_idx, gen=g) xb, yb = X_tr[idx], y_tr[idx] scores = model(xb) loss = loss_fn(scores, yb) opt.zero_grad() loss.backward() opt.step() model.eval() with torch.no_grad(): va_scores = model(X_va) va_auc = roc_auc_score(y_va.numpy(), va_scores.numpy()) if (ep + 1) % 5 == 0: print(f"epoch {ep+1:3d} | val AUC {va_auc:.4f}") return model, va_auc

跑三组实验：纯 BCE、pairwise logistic、listwise softmax，分别记录验证集 AUC。我在一份类似的模拟数据上得到的量级是这样的：BCE 收敛到 0.883，pairwise logistic 到 0.897，listwise softmax 到 0.891。差距不大但稳定复现，pairwise 略优的原因就是它的权重和 AUC 的权重一致。注意这只是我这一份数据的观察，换数据集排序会变，不要当成结论照抄。

4.5 结果怎么读：把 loss 和 AUC 放在一张图里

训练时我习惯同时打印三个量：pairwise loss（在固定的验证配对上算）、验证集 AUC、以及 $1 - \text{AUC}$。后两个只差一个减法，但把它们和 loss 并排看，你能立刻判断出代理损失有没有“跑偏”。

健康的训练曲线是这样的：pairwise_loss和1 - AUC两条线形状相似，同步下降，差距保持在一个相对稳定的区间内。如果pairwise_loss一路降到 0.05 而1 - AUC卡在 0.12 不动，说明模型在过拟合训练集的配对，或者你的 batch 配对分布和全量分布差异过大。如果反过来，1 - AUC降了但pairwise_loss不降，那多半是你在评估时用的 pair 采样和训练时不一样，两个数字根本不在同一个分布上。

提示：评估用的 pair 集必须固定下来，每次评估都用同一批正负对，否则 loss 曲线会抖得像心电图，什么结论都读不出来。

5. 实战里的坑：为什么 loss 降了 AUC 不涨

5.1 batch 内配对为空或过少

这是最高频的翻车点。正样本比例 0.5% 的时候，一个 1024 的 batch 里期望只有 5 个正样本。pairwise 损失的梯度几乎全部来自这 5 个正样本和 1000 多个负样本的配对，方差极大，相当于每步都在用一个极小的子样本估计真实的配对梯度。表现就是 loss 曲线剧烈震荡，AUC 长时间原地踏步。

解决办法有三条，我一般组合使用。第一是分层采样，前面已经写了，保证每个 batch 的正负比例固定。第二是增大 batch，让配对数量上去，但代价是显存。第三是用队列缓存负样本，把前几个 step 的负样本分数存下来参与当前 step 的配对计算，这样等效放大了负样本池，代价是分数会略微过期（因为模型已经更新了）。第三条在双塔召回里非常常见，效果也很实在，但要注意队列长度别太大，过期太严重反而伤模型。

还有一个隐蔽的变体：多卡训练时，如果每张卡各自算 pairwise 损失再平均，等价于每张卡的 batch 变小了。正确做法是把所有卡的分数 gather 到一起算配对，或者干脆用 listwise 让每张卡内部自洽。

5.2 配对采样偏差与梯度尺度

全量配对是 $P \times N$，采样配对必然会引入偏差。最朴素的均匀采样（每个正样本和每个负样本等概率被抽到）是无偏的，但效率低，因为大量“已经排得很好”的配对贡献的梯度接近 0。难例挖掘（只取分数最高的若干负样本）效率高，但会引入偏差：模型会过度关注头部的负样本，尾部的排序质量下降，而 AUC 是等权的，所以最终 AUC 可能反而不如均匀采样。

我的折中方案是“混合采样”：一半配对均匀采，一半配对从难例里采。这样既保证了全局的排序质量，又加速了头部收敛。调这个比例本质上是在调“你多在意头部”。

另一个容易忽略的是梯度尺度。pairwise logistic 的梯度是 $\sigma(s_j - s_i)$，取值范围 [0, 1]，而 BCE 的梯度是 $(\hat{y} - y)$，取值范围也是 [0, 1]，看起来差不多。但 pairwise 是 $P \times N$ 个配对求平均，相当于每个正样本的梯度被放大了 $N$ 倍再除以 $PN$，实际的有效步长和 BCE 不在一个量级。我一般会把 pairwise 的学习率设成 BCE 的 1/2 到 1/5，或者干脆用梯度裁剪兜底。直接沿用 BCE 的学习率，前几个 step loss 会炸。

5.3 logloss 降到底了，AUC 还在动

这是很多人困惑的场景：BCE 的 loss 已经降到 0.05 了，验证集 AUC 又涨了 0.5 个点。这矛盾吗？不矛盾。BCE 优化的是每个样本的独立概率似然，它关心的是“这个样本的分数绝对值离 0 或 1 有多近”；AUC 关心的是“正负样本之间的相对顺序”。这两件事在模型容量有限的时候是冲突的：为了让一个很难的正样本概率从 0.6 提到 0.9，模型可能要牺牲一批简单负样本的分数，而这批负样本的相对顺序被打乱了，AUC 就掉。

反过来也成立：AUC 提升不一定让 BCE 下降，因为把一对样本的顺序调对，可能只是把两个分数同时往上推，边际概率没变好甚至变差（校准变差）。所以严格来说，这两个指标度量的是模型的不同侧面，一个是判别力（排序），一个是校准度（概率）。业务上如果要做阈值决策、要算期望收益，概率校准很重要；如果只做 top-k 推荐，排序才是王道。

我自己的经验是：排序任务优先看 AUC 或 NDCG，把 BCE 当作辅助监控指标；如果模型需要输出可解释的概率，那就用 BCE 训，训完再做 Platt scaling 或者 isotonic 校准，而不要指望 AUC 高就一定校准好。

5.4 全局 AUC 掩盖了分组崩塌

在推荐和广告里，样本天然按用户、按场景分组。全局 AUC 把所有人的样本混在一起算，会出现辛普森悖论式的误判：每个用户内部的排序都变差了，但因为用户之间的分数分布整体平移，全局 AUC 反而上升了。这种“假涨”线上会被打脸。

正确的做法是看 GAUC（分组 AUC 的加权平均）：

$$\text{GAUC} = \frac{\sum_u w_u \cdot \text{AUC}_u}{\sum_u w_u}$$

权重 $w_u$ 一般取该用户的曝光数或者点击数。分组内样本太少（比如少于 10 个正样本）的用户，AUC 方差极大，我一般直接过滤掉，或者做贝叶斯平滑。这个指标和 pairwise 损失的关系也更自然：pairwise 损失本来就是在“同一组内的正负对”上算的，只要你的 batch 是按组构造的，损失下降就约等于 GAUC 上升。这也解释了为什么分组场景下 pairwise 损失往往比 BCE 更有优势——它天然尊重了组内的比较结构。

5.5 常见问题速查

6. 我在实际项目里的几条取舍

6.1 什么时候值得上 pairwise 损失

不是所有排序任务都值得折腾 pairwise。我的判断标准是：如果正负样本极度不平衡（正样本低于 5%）且验收指标是排序类指标，那 pairwise 的收益最明显；因为 BCE 在这种分布下会被大量简单负样本主导，梯度淹没在“把负样本压到 0”这件事上，对正样本之间的相对顺序没什么动力。相反，如果正负比例接近 1:1，BCE 和 pairwise 的差距往往在千分位，不值得为它增加一套配对采样代码和一堆超参。

另一个判断维度是候选集大小。召回阶段候选动辄上万，全量配对不现实，这时候 listwise softmax 加上 in-batch 负采样是更工程化的选择；精排阶段候选只有几百，pairwise 完全扛得住，收益也更直接。我自己在精排上基本默认 pairwise logistic 起步，把 softmax 作为对照组。

6.2 一个几乎不增加成本的监控技巧

最后分享一个我常用的做法：训练时维护一个固定的小规模“配对探针集”——从验证集里固定抽 2000 个正样本、2000 个负样本，组成 400 万个固定配对（实际算的时候可以再抽样到 20 万对）。每个 epoch 结束，在探针集上算一次 pairwise 0-1 损失和 AUC，一起打印。

这么做的好处是：这两个数在同一批配对上算出来，理论上严格满足 $1 - \text{AUC} = \text{loss}_{01}$，那么它们之间的差距就精确反映了“代理损失和真实损失的距离”。如果这个差距在扩大，说明模型正在优化代理而不是优化 AUC，该调温度、调采样或者加正则了。这个信号比单看 AUC 曲线敏感得多，而且成本几乎为零——反正验证集前向都要跑，多算一个均值而已。

踩过几次坑之后我越来越觉得，AUC 和排序损失的关系不是一道理论题，而是一个必须在训练循环里被持续观测的工程约束。你把 $1-\text{AUC}$ 和代理损失并排放着看，很多问题会自己浮出水面，根本不需要去猜。