Bradley-Terry损失函数详解：从原理到Python实战

1次阅读

没有评论

共计 2382 个字符，预计需要花费 6 分钟才能阅读完成。

在推荐系统、体育赛事排名等场景中，我们经常遇到这样的数据：用户对物品 A 和 B 表现出明确的偏好（如 A >B），但缺乏绝对评分。这类数据称为成对比较数据（pairwise comparison），它的核心特点是：

只记录相对偏好关系
不依赖绝对评分尺度
天然适合排名学习任务

Bradley-Terry 模型假设每个物品 $i$ 有一个潜在强度参数 $\theta_i$，物品 $i$ 战胜物品 $j$ 的概率表示为：

$$ P(i > j) = \frac{e^{\theta_i}}{e^{\theta_i} + e^{\theta_j}} $$

给定观测到的对战结果集合 $D={(i,j)}$，通过极大似然估计求解参数。对数似然函数为：

$$ \mathcal{L}(\theta) = \sum_{(i,j) \in D} \left[\theta_i – \log(e^{\theta_i} + e^{\theta_j}) \right] $$

对应的损失函数（负对数似然）为：

$$ \mathcal{J}(\theta) = -\mathcal{L}(\theta) $$

首先需要将原始比较数据转换为配对矩阵。假设有 N 个物品，构建 N×N 的矩阵 $C$，其中 $C_{ij}$ 表示 i 战胜 j 的次数：

import torch
def build_pair_matrix(raw_data, num_items):
    """
    raw_data: List of (winner_idx, loser_idx) tuples
    num_items: Total number of distinct items
    """
    C = torch.zeros((num_items, num_items))
    for winner, loser in raw_data:
        C[winner, loser] += 1
    return C

关键点：使用 log-sum-exp 避免数值溢出

class BradleyTerryLoss(torch.nn.Module):
    def __init__(self, reg_lambda=0.01):
        super().__init__()
        self.reg_lambda = reg_lambda

    def forward(self, theta, C):
        """
        theta: (N,) tensor of strength parameters
        C: (N,N) count matrix where C_ij = # times i beat j
        """
        N = theta.shape[0]

        # Pairwise differences
        theta_diff = theta.view(N,1) - theta.view(1,N)  # (N,N)

        # Log likelihood terms
        log_terms = torch.log1p(torch.exp(-theta_diff))  # stable log(1 + exp(-x))

        # Apply mask for observed pairs
        valid_pairs = (C > 0)
        loss = -torch.sum(C[valid_pairs] * (theta_diff[valid_pairs] - log_terms[valid_pairs]))

        # L2 regularization
        reg_loss = self.reg_lambda * torch.sum(theta**2)

        return loss + reg_loss

# Hyperparameters
learning_rate = 0.1
num_epochs = 100

# Initialize parameters
theta = torch.randn(num_items, requires_grad=True)

# Optimizer
optimizer = torch.optim.Adam([theta], lr=learning_rate)
loss_fn = BradleyTerryLoss(reg_lambda=0.1)

# Training loop
for epoch in range(num_epochs):
    optimizer.zero_grad()
    loss = loss_fn(theta, C)
    loss.backward()
    optimizer.step()

    if epoch % 10 == 0:
        print(f"Epoch {epoch}, loss={loss.item():.4f}")