【Debug日志 | BCE 下的“捣蛋鬼”】

import torch, torch.nn.functional as F

B, C = 32, 5
logits = torch.randn(B, C)  # 模拟模型输出
labels = (torch.rand(B, C) < torch.tensor([0.01,0.02,0.05,0.1,0.2])).float()  # 极不平衡

# ❌ 错 1：把 pos_weight 写成了“正/负比”（应为 负/正）
pos = labels.sum(dim=0) + 1e-6
neg = labels.numel()/C - pos
wrong_pos_weight = (pos / neg).clamp(min=1e-3)      # ❌

# ❌ 错 2：还叠加了 element-wise 的 weight（双重压制负例/搞乱标度）
elem_weight = torch.ones_like(labels) * 0.5         # ❌ 随手设
loss = F.binary_cross_entropy_with_logits(
    logits, labels,
    pos_weight=wrong_pos_weight,  # 形状 [C]
    weight=elem_weight,           # 形状 [B,C]
    reduction='mean'
)
print('loss=', loss.item())

with torch.no_grad():
    pos = labels.sum(dim=0)
    neg = labels.size(0) - pos
    print('pos ratio:', (pos / labels.size(0)).tolist())
    print('expected pos_weight (neg/pos):', (neg / pos.clamp_min(1)).tolist())

prob = torch.sigmoid(logits)
print('mean prob per class:', prob.mean(dim=0).tolist())
print('pass@0.5 per class:', (prob>0.5).float().mean(dim=0).tolist())

def compute_pos_weight(train_labels: torch.Tensor) -> torch.Tensor:
    """
    train_labels: [N, C] in {0,1}
    return: [C] tensor on CPU，后续 to(device)
    """
    pos = train_labels.sum(dim=0)                 # [C]
    neg = train_labels.size(0) - pos
    # 处理“0 正例”类别：给一个温和的上限，避免 inf
    pw = (neg / pos.clamp_min(1)).clamp(max=100.0)
    return pw

# 用法
pos_weight = compute_pos_weight(train_labels)
criterion = torch.nn.BCEWithLogitsLoss(pos_weight=pos_weight.to(device), reduction='mean')

logits = model(x)                # [B,C]
loss = criterion(logits, labels) # labels float in {0,1}

import numpy as np
from sklearn.metrics import f1_score

def search_thresholds(probs, labels, per_class=True):
    """
    probs/labels: numpy array [N,C]
    return: thresholds [C] or scalar
    """
    if not per_class:
        grid = np.linspace(0.01, 0.99, 99)
        f1 = [f1_score(labels.ravel(), (probs.ravel()>t).astype(int)) for t in grid]
        return float(grid[int(np.argmax(f1))])

    C = probs.shape[1]
    th = np.zeros(C)
    for c in range(C):
        grid = np.linspace(0.01, 0.99, 99)
        f1 = [f1_score(labels[:,c], (probs[:,c]>t).astype(int)) for t in grid]
        th[c] = grid[int(np.argmax(f1))]
    return th

# 1) 准备损失
pos_weight = compute_pos_weight(train_labels).to(device)
criterion = torch.nn.BCEWithLogitsLoss(pos_weight=pos_weight, reduction='mean')

# 2) 训练
for x, y in train_loader:
    x, y = x.to(device), y.to(device).float()
    logits = model(x)
    loss = criterion(logits, y)
    optimizer.zero_grad(set_to_none=True)
    loss.backward()
    torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
    optimizer.step()

# 3) 验证（阈值搜索）
probs_val, labels_val = [], []
with torch.no_grad():
    for x, y in val_loader:
        p = torch.sigmoid(model(x.to(device))).cpu()
        probs_val.append(p); labels_val.append(y)
probs_val = torch.cat(probs_val).numpy()
labels_val = torch.cat(labels_val).numpy()
thr = search_thresholds(probs_val, labels_val, per_class=True)

# 4) 报告指标
pred = (probs_val > thr).astype(int)
print_metrics(pred, labels_val)  # 自己实现一个包含 per-class 的表