レース予想（２：学習時と同じ前処理を推論に適用する ― preprocess_like_training 関数をつくる）

@torch.no_grad()
def preprocess_like_training(
    X,
    stats: dict,
    *,
    inplace: bool = False,
    out_dtype_torch: torch.dtype = torch.float32,
    return_numpy_if_numpy_input: bool = True,
):
    TAIL = int(stats["TAIL"])
    keep_numeric_idx = stats["keep_numeric_idx"]
    means_np = stats["means"].astype(np.float32)
    stds_np  = stats["stds"].astype(np.float32)
    keep_for_seq = stats["keep_for_seq"]

    stds_np_safe = np.where(stds_np == 0.0, 1.0, stds_np)

    if isinstance(X, np.ndarray):
        Xw = X if inplace else X.copy()
        if Xw.ndim == 2:
            Xw = Xw[None, ...]
            squeeze_back = True
        elif Xw.ndim == 3:
            squeeze_back = False
        else:
            raise ValueError("X は (S,D_all) か (B,S,D_all)")

        assert Xw.shape[-1] >= TAIL, "TAIL 列不足（列順要確認）"

        X_main = Xw[..., :-TAIL] if TAIL > 0 else Xw  # ★ TAIL=0時も全部をメイン扱い
        X_tail = Xw[..., -TAIL:] if TAIL > 0 else Xw[..., :0]

        # 標準化（安全版）
        part = X_main[:, :, keep_numeric_idx]
        part = (part - means_np.reshape(1,1,-1)) / stds_np_safe.reshape(1,1,-1)
        X_main[:, :, keep_numeric_idx] = part

        X_main_kept = np.take(X_main, keep_for_seq, axis=2)
        X_seq = np.concatenate([X_main_kept, X_tail], axis=2) if TAIL > 0 else X_main_kept

        # ★ 非有界値サニタイズ
        X_seq = np.where(np.isfinite(X_seq), X_seq, 0.0).astype(np.float32, copy=False)

        if squeeze_back:
            X_seq = X_seq[0]
        return X_seq if return_numpy_if_numpy_input else torch.from_numpy(X_seq)

    if torch.is_tensor(X):
        Xw = X if inplace else X.clone()
        if Xw.dim() == 2:
            Xw = Xw.unsqueeze(0)
            squeeze_back = True
        elif Xw.dim() == 3:
            squeeze_back = False
        else:
            raise ValueError("X は (S,D_all) か (B,S,D_all)")

        device, dtype = Xw.device, Xw.dtype
        kni = torch.as_tensor(keep_numeric_idx, dtype=torch.long, device=device)
        means_t = torch.as_tensor(means_np, dtype=dtype, device=device)
        stds_t  = torch.as_tensor(stds_np,  dtype=dtype, device=device)
        # ★ 分母0対策
        stds_t = torch.where(stds_t == 0, torch.ones_like(stds_t), stds_t)

        kfs = torch.as_tensor(keep_for_seq, dtype=torch.long, device=device)

        assert Xw.size(-1) >= TAIL, "TAIL 列不足（列順要確認）"

        X_main = Xw[..., :-TAIL] if TAIL > 0 else Xw
        X_tail = Xw[..., -TAIL:] if TAIL > 0 else Xw[..., :0]

        part = X_main.index_select(-1, kni)
        part.sub_(means_t).div_(stds_t)
        X_main.index_copy_(-1, kni, part)

        X_main_kept = X_main.index_select(-1, kfs)
        X_seq = torch.cat([X_main_kept, X_tail], dim=-1) if TAIL > 0 else X_main_kept

        # ★ 非有界値サニタイズ
        X_seq = torch.where(torch.isfinite(X_seq), X_seq, torch.zeros_like(X_seq))

        if X_seq.dtype != out_dtype_torch:
            X_seq = X_seq.to(out_dtype_torch)
        if squeeze_back:
            X_seq = X_seq.squeeze(0)
        return X_seq

    raise TypeError("X は np.ndarray か torch.Tensor を指定")
stats = load_scale_stats("scale_stats.json")
X_seq = preprocess_like_training(
    X_sequences_raw,
    stats,
    inplace=False,              
    out_dtype_torch=torch.float32, 
    return_numpy_if_numpy_input=True
)