学習する（５：スライディングウインドウ）

print("✅ 馬ごとの時系列シーケンス化（スライディングウィンドウ）＋特徴量拡張の前処理パイプライン")
# 並び替え & インデックス振り直し
data = data.sort_values(by=["馬ID", "日付"]).reset_index(drop=True)

# 類似度計算
def compute_all_max_similarities(values: np.ndarray, sequence_length: int, device=None) -> np.ndarray:
    if device is None:
        device = "cuda" if torch.cuda.is_available() else "cpu"
    values_tensor = torch.tensor(values, dtype=torch.float32, device=device)
    normed_values = F.normalize(values_tensor, p=2, dim=1)
    sims_matrix = normed_values @ normed_values.T
    num_rows = values.shape[0]
    num_seqs = num_rows - sequence_length + 1
    max_similarities = torch.zeros(num_seqs, device=device)
    for i in range(num_seqs):
        target_idx = i + sequence_length - 1
        max_similarities[i] = 0.0 if i == 0 else sims_matrix[target_idx, i:target_idx].max()
    return max_similarities.cpu().numpy()

@lru_cache(maxsize=None)
def cached_similarity(values_bytes: bytes, shape_tuple: tuple, sequence_length: int):
    if shape_tuple[0] < sequence_length:
        raise ValueError(f"shape too short: {shape_tuple} < sequence_length={sequence_length}")
    values = np.frombuffer(values_bytes, dtype=np.float32).reshape(shape_tuple)
    return compute_all_max_similarities(values, sequence_length)

exclude_columns = ["着順", "日付", "レースID", "馬ID"]
feature_columns = [c for c in data.columns if c not in exclude_columns]
assert list(data.drop(columns=exclude_columns).columns) == feature_columns, \
    "data.drop(...).columns と feature_columns の順序が一致していません"
with open("main_feature_order.json", "w", encoding="utf-8") as f:
    json.dump(feature_columns, f, ensure_ascii=False, indent=2)
print("✅ main_feature_order 保存済み")

embedding_indices = {col: feature_columns.index(col) for col in embedding_cols}
numeric_name_mask = np.array([col not in set(embedding_cols) for col in feature_columns], dtype=bool)
keep_numeric_idx  = np.where(numeric_name_mask)[0]

missing = sorted(set(embedding_cols) - set(feature_columns))
assert not missing, f"embedding_colsにあるのにfeature_columnsに無い: {missing}"

leaks = sorted(set(feature_columns[i] for i in keep_numeric_idx) & set(embedding_cols))
assert not leaks, f"数値側にEmbedding列が混入: {leaks}"

emb_idx = np.array([embedding_indices[c] for c in embedding_cols], dtype=np.int64)
comp_idx = np.setdiff1d(np.arange(len(feature_columns)), keep_numeric_idx)
assert np.array_equal(np.sort(comp_idx), np.sort(emb_idx)), \
    f"補集合≠embedding: extra={sorted(set(feature_columns[i] for i in comp_idx) - set(embedding_cols))}, " \
    f"missing={sorted(set(embedding_cols) - set(feature_columns[i] for i in comp_idx))}"

values = data.drop(columns=exclude_columns).to_numpy(dtype=np.float32, copy=True)
y_all   = data["着順"].to_numpy()
r_all   = data["レースID"].to_numpy()
h_all   = data["馬ID"].to_numpy()
hist_all= data["履歴長_norm"].to_numpy(dtype=np.float32)
d_all = data["日付"].to_numpy(dtype="datetime64[ns]")

ids = h_all 
starts = np.r_[0, np.flatnonzero(ids[1:] != ids[:-1]) + 1]
ends   = np.r_[starts[1:], len(ids)]

S = sequence_length
X_list, y_list, race_list, horse_list, hist_list, used_len_list, sim_list = [], [], [], [], [], [], []
date_list = [] 

for s, e in zip(starts, ends):
    v = values[s:e]        
    v_num = v[:, keep_numeric_idx] 
    y = y_all[s:e]           
    r = r_all[s:e]             
    h = h_all[s:e]           
    n, D = v.shape
    try:
        ms = cached_similarity(v_num.tobytes(), v_num.shape, S)
    except Exception as ex:
        ms = np.zeros(max(1, n - S + 1), dtype=np.float32)

    if n >= S:
        shape   = (n - S + 1, S, D)
        strides = (v.strides[0], v.strides[0], v.strides[1])
        win = as_strided(v, shape=shape, strides=strides)  
        idx_end = np.arange(S - 1, n)          

        X_list.append(win.copy())                       
        y_seq = np.minimum(y[idx_end], 6)  # 1..5 以外は 6
        y_list.append(y_seq - 1)                          
        race_list.append(r[idx_end])
        horse_list.append(h[idx_end])
        hist_list.append(hist_all[s:e][idx_end])
        used_len_list.append(np.full(win.shape[0], S, dtype=np.float32))
        sim_list.append(ms.astype(np.float32))
        date_list.append(d_all[s:e][idx_end])

    else:
        pad = np.repeat(v[-1:], S - n, axis=0)
        seq = np.vstack([v, pad])[None, ...] 
        X_list.append(seq.astype(np.float32))
        y_last = y[-1]
        y_list.append(np.array([min(y_last, 6) - 1], dtype=np.int64))
        race_list.append(np.array([r[-1]], dtype=r.dtype))
        horse_list.append(np.array([h[-1]], dtype=h.dtype))
        hist_list.append(np.array([hist_all[e-1]], dtype=np.float32))
        used_len_list.append(np.array([float(n)], dtype=np.float32))
        sim_list.append(np.array([ms[0] if len(ms) else 0.0], dtype=np.float32))
        date_list.append(np.array([d_all[e-1]], dtype="datetime64[ns]"))

X_sequences      = np.concatenate(X_list, axis=0)    
y_targets        = np.concatenate(y_list, axis=0).astype(np.int64)  
race_ids         = np.concatenate(race_list, axis=0)
horse_ids        = np.concatenate(horse_list, axis=0)
history_lengths  = np.concatenate(hist_list, axis=0).astype(np.float32)
used_lens        = np.concatenate(used_len_list, axis=0).astype(np.float32)
similarity_scores= np.concatenate(sim_list, axis=0).astype(np.float32)
sequence_end_dates = np.concatenate(date_list, axis=0).astype("datetime64[ns]") 

used_ratio = used_lens / float(S)
sim_tiled  = np.repeat(similarity_scores[:, None], S, axis=1)[..., None] 
hist_tiled = np.repeat(history_lengths[:,   None], S, axis=1)[..., None]  
used_tiled = np.repeat(used_ratio[:,       None], S, axis=1)[..., None] 

X_sequences = np.concatenate([X_sequences, sim_tiled, hist_tiled, used_tiled], axis=2) 

data = data.sort_values(by=["馬ID", "日付"]).reset_index(drop=True)

def compute_all_max_similarities(values, sequence_length, device=None): ...

exclude_columns = ["着順", "日付", "レースID", "馬ID"]
feature_columns = [c for c in data.columns if c not in exclude_columns]

values = data.drop(columns=exclude_columns).to_numpy(dtype=np.float32, copy=True)
y_all   = data["着順"].to_numpy()
r_all   = data["レースID"].to_numpy()
h_all   = data["馬ID"].to_numpy()

starts = np.r_[0, np.flatnonzero(ids[1:] != ids[:-1]) + 1]
ends   = np.r_[starts[1:], len(ids)]

shape   = (n - S + 1, S, D)
strides = (v.strides[0], v.strides[0], v.strides[1])
win = as_strided(v, shape=shape, strides=strides)

X_sequences      = np.concatenate(X_list, axis=0)
y_targets        = np.concatenate(y_list, axis=0).astype(np.int64)
...
sim_tiled  = np.repeat(similarity_scores[:, None], S, axis=1)[..., None]