学習する（１１：ヘイズワイズ、トップ１、nDCG@K）

def weighted_pairwise_ranking_loss(preds, targets, weights=None):
    N = preds.size(0)
    if N < 2:
        return torch.tensor(0.0, device=preds.device)
    i, j = torch.triu_indices(N, N, offset=1, device=preds.device)
    diff = torch.sign(targets[j] - targets[i])
    pred_diff = preds[i] - preds[j]
    if weights is not None:
        w = (weights[i] + weights[j]) * 0.5
    else:
        w = 1.0
    return torch.nn.functional.softplus(-diff * pred_diff).mul(w).mean()

def soft_top1_loss(preds: torch.Tensor,
                   targets: torch.Tensor,
                   class_weights: torch.Tensor | None = None) -> torch.Tensor:
    preds   = preds.reshape(-1)
    targets = targets.reshape(-1).to(preds.device)

    if targets.numel() == 0:
        return torch.tensor(0.0, device=preds.device)

    probs = torch.softmax(preds, dim=0)
    eps = 1e-12

    if torch.all((targets == 0) | (targets == 1)) and targets.sum() > 0:
        mask = targets.float() / targets.sum()
        return -torch.sum(mask * torch.log(probs + eps))

    min_val = targets.min()
    winner_mask = (targets == min_val).float()
    winner_mask = winner_mask / winner_mask.sum()

    weight = torch.tensor(1.0, device=preds.device)
    if class_weights is not None and class_weights.numel() > 0:
        idx = int(min_val.item()) - 1
        if 0 <= idx < class_weights.numel():
            weight = class_weights[idx].to(preds.device)

    return -weight * torch.sum(winner_mask * torch.log(probs + eps))

def hard_ndcg3_loss_torch(preds: torch.Tensor,
                          targets: torch.Tensor,
                          mask: torch.Tensor | None = None,
                          k: int = 3) -> torch.Tensor:

    if preds.dim() == 1:
        preds = preds.unsqueeze(0)
        targets = targets.unsqueeze(0)
        if mask is not None and mask.dim() == 1:
            mask = mask.unsqueeze(0)

    R, S = preds.shape
    device = preds.device
    dtype = preds.dtype

    if mask is None:
        mask = torch.zeros((R, S), dtype=torch.bool, device=device)

    targ = targets.to(torch.long)
    rel = (targ.max(dim=1, keepdim=True).values - targ + 1).to(preds.dtype)

    valid = ~mask
    preds_masked = preds.masked_fill(~valid, float("-inf"))
    rel_masked   = rel.masked_fill(~valid, 0.0)

    kk = min(k, S)

    topk_idx = torch.topk(preds_masked, k=kk, dim=1).indices  
    gains    = rel_masked.gather(1, topk_idx) 
    discounts = 1.0 / torch.log2(torch.arange(2, kk + 2, device=device, dtype=dtype))
    dcg = (gains * discounts.unsqueeze(0)).sum(dim=1)  

    ideal_idx = torch.topk(rel_masked, k=kk, dim=1).indices
    ideal_gains = rel_masked.gather(1, ideal_idx)
    idcg = (ideal_gains * discounts.unsqueeze(0)).sum(dim=1) 

    ndcg = torch.where(idcg > 0, dcg / idcg, torch.ones_like(dcg))
    return (1.0 - ndcg.mean()).to(dtype)