学習と評価で利用（１５：評価ユーティリティセット）

def normalize_hist_race(hist_race: torch.Tensor, eps=1e-6):

    hist_race = torch.nan_to_num(hist_race, nan=0.0)

    if torch.max(hist_race) > 0:
        max_val = torch.max(hist_race)
        min_val = torch.min(hist_race)
        if max_val != min_val:
            hist_race = (hist_race - min_val) / (max_val - min_val + eps)
        else:
            hist_race = torch.ones_like(hist_race)
    hist_race = torch.clamp(hist_race, 0.0, 1.0)
    return hist_race

def compute_class_weights(y_ranks):
    counts = Counter(y_ranks)
    total = sum(counts.values())
    weights = {cls: total / count for cls, count in counts.items()}
    return weights
    
class EarlyStopping:
    def __init__(self, patience=3, mode="max"):
        self.patience = patience
        self.counter = 0
        self.best_score = None
        self.early_stop = False
        self.mode = mode  # "max"（大きいほど良い） or "min"

    def __call__(self, current_score):
        if self.best_score is None:
            self.best_score = current_score
            return False

        if (self.mode == "max" and current_score > self.best_score) or \
           (self.mode == "min" and current_score < self.best_score):
            self.best_score = current_score
            self.counter = 0
        else:
            self.counter += 1

        if self.counter >= self.patience:
            self.early_stop = True
            return True

        return False
    
def normalize_targets_for_ranking(y: torch.Tensor):
    """
    y: [S] … 0/1(one-hot, float想定) か 0..K-1 / 1..K の順位（小さいほど良い）
    戻り: (正規化y, 種別)
    """
    # one-hot は「浮動小数の0/1」のときのみ認める
    if y.dtype.is_floating_point:
        if (y.ge(0) & y.le(1)).all() and y.sum() > 0:
            return y, "onehot"

    # それ以外は整数順位扱い → 1始まりに正規化
    y = y.to(torch.long)
    minv = y.min()
    if minv < 1:
        y = y - minv + 1   # 0..K-1 → 1..K
    return y, "rank"

def run_validation(model, val_dataloader, device, class_weights, autocast_ctx):
    model.eval()
    sum_ndcg3, sum_top1_acc, n_races = 0.0, 0.0, 0

    with torch.no_grad():
        for X_pack, y_pack, hist_pack, cat_pack, ids_pack, mask_pack in val_dataloader:
            X_pack = X_pack.to(device, non_blocking=True)
            y_pack = y_pack.to(device, non_blocking=True)
            mask_pack = mask_pack.to(device, non_blocking=True)
            if hist_pack is not None:
                hist_pack = hist_pack.to(device, non_blocking=True)
            cat_pack = {k: v.to(device, non_blocking=True) for k, v in cat_pack.items()}

            with autocast_ctx:
                preds = model(X_pack, cat_pack, mask=mask_pack)  # [B,S]

            valid_mask = ~mask_pack
            # hist が None の時のためのイテレータ
            hist_iter = (hist_pack if hist_pack is not None else [None]*preds.size(0))

            for r_valid, p_r, y_r, h_r in zip(valid_mask, preds, y_pack, hist_iter):
                # レース内の有効頭のみ
                if r_valid.sum() < 2:
                    continue
                p_r = p_r[r_valid]
                y_r = y_r[r_valid]
                y_r, _ = normalize_targets_for_ranking(y_r)

                # NDCG@3（= 1 - loss）
                lndcg3 = hard_ndcg3_loss_torch(p_r, y_r)
                ndcg3 = float(1.0 - lndcg3)

                # Top-1 的中率（参考）
                winners = (y_r == y_r.min()).nonzero(as_tuple=False).squeeze(-1)
                top1_acc = float((torch.argmax(p_r).unsqueeze(0) == winners).any().float())

                sum_ndcg3 += ndcg3
                sum_top1_acc += top1_acc
                n_races += 1

    return (sum_ndcg3 / n_races) if n_races > 0 else 0.0  # ←「大きいほど良い」