| |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| from pathlib import Path |
| from typing import Any |
|
|
| import numpy as np |
| import pandas as pd |
| from sklearn.metrics import pairwise_distances |
| from sklearn.preprocessing import StandardScaler |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser( |
| description="Run the CB-Telemetry time-matched retrieval protocol on released feature tables." |
| ) |
| parser.add_argument("--root", default=".", help="CB-Telemetry dataset root.") |
| parser.add_argument("--feature-table", required=True, help="Anchor feature table used to define rows and slots.") |
| parser.add_argument("--output-dir", required=True, help="Directory for retrieval outputs.") |
| parser.add_argument("--max-slot-gap", type=int, default=1, help="Maximum neighboring-slot gap.") |
| parser.add_argument("--min-dates-per-pair", type=int, default=12, help="Minimum dates required per slot pair.") |
| parser.add_argument("--bootstrap-samples", type=int, default=2000, help="Bootstrap resamples for intervals.") |
| parser.add_argument("--bootstrap-seed", type=int, default=42, help="Bootstrap random seed.") |
| parser.add_argument("--random-seed", type=int, default=42, help="Random seed for the permuted-control baseline.") |
| parser.add_argument( |
| "--archive-scope", |
| choices=["global", "same_archive_only"], |
| default="global", |
| help="Candidate pool: all target rows, or rows from the same archive only.", |
| ) |
| parser.add_argument( |
| "--representation", |
| action="append", |
| default=[], |
| help="Repeat as name=feature_table_path. Paths are resolved relative to --root unless absolute.", |
| ) |
| parser.add_argument( |
| "--include-metadata-controls", |
| action="store_true", |
| help="Add metadata_basic, metadata_calendar, and random_permuted_continuous controls.", |
| ) |
| return parser.parse_args() |
|
|
|
|
| def resolve_path(root: Path, raw_path: str) -> Path: |
| path = Path(raw_path).expanduser() |
| if not path.is_absolute(): |
| path = (root / path).resolve() |
| return path |
|
|
|
|
| def release_path(root: Path, path: Path) -> str: |
| try: |
| return path.resolve().relative_to(root).as_posix() |
| except ValueError: |
| return path.as_posix() |
|
|
|
|
| def build_key(df: pd.DataFrame) -> pd.Series: |
| return ( |
| df["archive"].astype(str).str.strip() |
| + "||" |
| + df["date"].astype(str).str.strip() |
| + "||" |
| + df["filename"].astype(str).str.strip() |
| ) |
|
|
|
|
| def add_slot_metadata(df: pd.DataFrame) -> pd.DataFrame: |
| result = df.copy() |
| result["timestamp_dt"] = pd.to_datetime(result["timestamp"], errors="raise") |
| result["date"] = result["date"].astype(str) |
| result["archive"] = result["archive"].astype(str) |
| result["filename"] = result["filename"].astype(str) |
| result["key"] = build_key(result) |
| result["dawn_slot_id"] = 0 |
| result["slot_count_on_date"] = 0 |
| result["slot_hour_signature"] = "" |
| for date_str, group in result.groupby("date", sort=True): |
| ordered = group.sort_values(["timestamp_dt", "filename"]).copy() |
| slot_ids = np.arange(1, len(ordered) + 1, dtype=np.int32) |
| result.loc[ordered.index, "dawn_slot_id"] = slot_ids |
| result.loc[ordered.index, "slot_count_on_date"] = int(len(ordered)) |
| signature = "-".join(str(int(item)) for item in ordered["hour"].tolist()) |
| result.loc[ordered.index, "slot_hour_signature"] = signature |
| result["dawn_slot_id"] = result["dawn_slot_id"].astype(int) |
| result["slot_count_on_date"] = result["slot_count_on_date"].astype(int) |
| return result |
|
|
|
|
| def feature_columns(df: pd.DataFrame) -> list[str]: |
| columns = [col for col in df.columns if col.startswith("f_")] |
| if not columns: |
| raise RuntimeError("No f_* feature columns were found.") |
| return columns |
|
|
|
|
| def standardize(matrix: np.ndarray) -> np.ndarray: |
| return StandardScaler().fit_transform(matrix.astype(np.float32, copy=False)).astype(np.float32) |
|
|
|
|
| def load_representation_matrix(root: Path, path_text: str, anchor_df: pd.DataFrame) -> np.ndarray: |
| path = resolve_path(root, path_text) |
| df = pd.read_csv(path, low_memory=False).copy() |
| df["date"] = df["date"].astype(str) |
| df["archive"] = df["archive"].astype(str) |
| df["filename"] = df["filename"].astype(str) |
| df["key"] = build_key(df) |
| columns = feature_columns(df) |
| indexed = df.set_index("key") |
| keys = anchor_df["key"].tolist() |
| missing = [key for key in keys if key not in indexed.index] |
| if missing: |
| raise RuntimeError(f"{path} is missing {len(missing)} anchor rows.") |
| matrix = indexed.loc[keys, columns].to_numpy(dtype=np.float32) |
| return standardize(matrix) |
|
|
|
|
| def parse_representations(items: list[str]) -> list[tuple[str, str]]: |
| if not items: |
| raise ValueError("At least one --representation name=path is required.") |
| result: list[tuple[str, str]] = [] |
| for item in items: |
| if "=" not in item: |
| raise ValueError(f"Invalid representation argument: {item}") |
| name, raw_path = item.split("=", 1) |
| result.append((name.strip(), raw_path.strip())) |
| return result |
|
|
|
|
| def build_metadata_matrix(anchor_df: pd.DataFrame, include_calendar: bool) -> np.ndarray: |
| archive_dummies = pd.get_dummies(anchor_df["archive"].astype(str), prefix="archive", dtype=np.float32) |
| slot_dummies = pd.get_dummies(anchor_df["dawn_slot_id"].astype(int), prefix="slot", dtype=np.float32) |
| blocks = [ |
| anchor_df["hour"].astype(np.float32).to_numpy()[:, None], |
| archive_dummies.to_numpy(dtype=np.float32), |
| slot_dummies.to_numpy(dtype=np.float32), |
| ] |
| if include_calendar: |
| date_dt = pd.to_datetime(anchor_df["date"].astype(str), format="%Y%m%d", errors="raise") |
| month_angle = 2.0 * np.pi * (date_dt.dt.month.to_numpy(dtype=np.float32) - 1.0) / 12.0 |
| year_offset = date_dt.dt.year.to_numpy(dtype=np.float32) - float(date_dt.dt.year.min()) |
| blocks.extend( |
| [ |
| np.sin(month_angle).astype(np.float32)[:, None], |
| np.cos(month_angle).astype(np.float32)[:, None], |
| year_offset.astype(np.float32)[:, None], |
| ] |
| ) |
| return standardize(np.column_stack(blocks).astype(np.float32)) |
|
|
|
|
| def cosine_rank_indices(query_matrix: np.ndarray, target_matrix: np.ndarray) -> np.ndarray: |
| distances = pairwise_distances(query_matrix, target_matrix, metric="cosine") |
| return np.argsort(distances, axis=1) |
|
|
|
|
| def reciprocal_rank(rank_index_zero_based: int) -> float: |
| return 1.0 / float(rank_index_zero_based + 1) |
|
|
|
|
| def summarize_query_rows(query_df: pd.DataFrame) -> dict[str, float]: |
| rank_positions = query_df["rank_position"].to_numpy(dtype=np.float32) |
| return { |
| "top1_hit_rate": float(query_df["top1_hit"].mean()), |
| "top5_hit_rate": float(query_df["top5_hit"].mean()), |
| "mrr": float(query_df["reciprocal_rank"].mean()), |
| "median_rank": float(np.median(rank_positions)), |
| "mean_rank": float(np.mean(rank_positions)), |
| } |
|
|
|
|
| def evaluate_pair_subset( |
| matrix: np.ndarray, |
| pair_df: pd.DataFrame, |
| query_slot: int, |
| target_slot: int, |
| archive_label: str, |
| ) -> dict[str, Any]: |
| eligible_dates = pair_df.groupby("date")["dawn_slot_id"].nunique().reset_index(name="slot_count") |
| eligible_dates = eligible_dates[eligible_dates["slot_count"] == 2]["date"].astype(str).tolist() |
| pair_df = pair_df[pair_df["date"].isin(eligible_dates)].copy() |
| query_df = pair_df[pair_df["dawn_slot_id"] == query_slot].copy().sort_values("date").reset_index(drop=True) |
| target_df = pair_df[pair_df["dawn_slot_id"] == target_slot].copy().sort_values("date").reset_index(drop=True) |
|
|
| if query_df.empty or target_df.empty: |
| raise RuntimeError(f"slot_pair {query_slot}->{target_slot} has no valid rows.") |
| if query_df["date"].tolist() != target_df["date"].tolist(): |
| raise RuntimeError(f"slot_pair {query_slot}->{target_slot} query and target dates are not aligned.") |
|
|
| query_matrix = matrix[query_df["anchor_row_index"].to_numpy()] |
| target_matrix = matrix[target_df["anchor_row_index"].to_numpy()] |
| ranks = cosine_rank_indices(query_matrix, target_matrix) |
|
|
| positive_dates = query_df["date"].tolist() |
| target_dates = target_df["date"].tolist() |
| query_rows: list[dict[str, Any]] = [] |
| for row_idx, expected_date in enumerate(positive_dates): |
| ranked_dates = [target_dates[item] for item in ranks[row_idx].tolist()] |
| positive_rank = ranked_dates.index(expected_date) |
| query_rows.append( |
| { |
| "date": str(expected_date), |
| "query_slot": int(query_slot), |
| "target_slot": int(target_slot), |
| "archive_scope_label": archive_label, |
| "candidate_size_per_query": int(len(target_df)), |
| "chance_top1": 1.0 / float(len(target_df)), |
| "rank_position": int(positive_rank + 1), |
| "top1_hit": 1.0 if positive_rank == 0 else 0.0, |
| "top5_hit": 1.0 if positive_rank < min(5, len(ranked_dates)) else 0.0, |
| "reciprocal_rank": reciprocal_rank(positive_rank), |
| } |
| ) |
|
|
| query_result_df = pd.DataFrame(query_rows) |
| metrics = summarize_query_rows(query_result_df) |
| return { |
| "query_slot": int(query_slot), |
| "target_slot": int(target_slot), |
| "archive_scope_label": archive_label, |
| "query_rows": int(len(query_df)), |
| "candidate_rows": int(len(target_df)), |
| "candidate_size_per_query": int(len(target_df)), |
| "chance_top1": 1.0 / float(len(target_df)), |
| "top1_hit_rate": metrics["top1_hit_rate"], |
| "top5_hit_rate": metrics["top5_hit_rate"], |
| "mrr": metrics["mrr"], |
| "median_rank": metrics["median_rank"], |
| "mean_rank": metrics["mean_rank"], |
| "date_examples": positive_dates[:5], |
| "query_details": query_rows, |
| } |
|
|
|
|
| def evaluate_slot_pair( |
| matrix: np.ndarray, |
| anchor_df: pd.DataFrame, |
| query_slot: int, |
| target_slot: int, |
| archive_scope: str, |
| min_dates_per_pair: int, |
| ) -> list[dict[str, Any]]: |
| pair_df = anchor_df[anchor_df["dawn_slot_id"].isin([query_slot, target_slot])].copy() |
| if archive_scope == "global": |
| return [ |
| evaluate_pair_subset( |
| matrix, |
| pair_df=pair_df, |
| query_slot=query_slot, |
| target_slot=target_slot, |
| archive_label="all", |
| ) |
| ] |
|
|
| rows: list[dict[str, Any]] = [] |
| for archive_name, archive_df in pair_df.groupby("archive", sort=True): |
| if archive_df["dawn_slot_id"].nunique() < 2: |
| continue |
| eligible_dates = archive_df.groupby("date")["dawn_slot_id"].nunique().reset_index(name="slot_count") |
| eligible_dates = eligible_dates[eligible_dates["slot_count"] == 2] |
| if int(len(eligible_dates)) < min_dates_per_pair: |
| continue |
| rows.append( |
| evaluate_pair_subset( |
| matrix, |
| pair_df=archive_df.copy(), |
| query_slot=query_slot, |
| target_slot=target_slot, |
| archive_label=str(archive_name), |
| ) |
| ) |
| return rows |
|
|
|
|
| def build_slot_pairs( |
| anchor_df: pd.DataFrame, |
| max_slot_gap: int, |
| min_dates_per_pair: int, |
| archive_scope: str, |
| ) -> list[tuple[int, int]]: |
| max_slot_id = int(anchor_df["dawn_slot_id"].max()) |
| pairs: list[tuple[int, int]] = [] |
| for query_slot in range(1, max_slot_id + 1): |
| for target_slot in range(1, max_slot_id + 1): |
| if query_slot == target_slot: |
| continue |
| if abs(query_slot - target_slot) > max_slot_gap: |
| continue |
| pair_df = anchor_df[anchor_df["dawn_slot_id"].isin([query_slot, target_slot])].copy() |
| if archive_scope == "global": |
| eligible_dates = pair_df.groupby("date")["dawn_slot_id"].nunique().reset_index(name="slot_count") |
| eligible_dates = eligible_dates[eligible_dates["slot_count"] == 2] |
| if int(len(eligible_dates)) >= min_dates_per_pair: |
| pairs.append((query_slot, target_slot)) |
| continue |
|
|
| archive_has_valid_pair = False |
| for _, archive_df in pair_df.groupby("archive", sort=True): |
| if archive_df["dawn_slot_id"].nunique() < 2: |
| continue |
| eligible_dates = archive_df.groupby("date")["dawn_slot_id"].nunique().reset_index(name="slot_count") |
| eligible_dates = eligible_dates[eligible_dates["slot_count"] == 2] |
| if int(len(eligible_dates)) >= min_dates_per_pair: |
| archive_has_valid_pair = True |
| break |
| if archive_has_valid_pair: |
| pairs.append((query_slot, target_slot)) |
| if not pairs: |
| raise RuntimeError("No valid slot pairs satisfy min_dates_per_pair.") |
| return sorted(pairs) |
|
|
|
|
| def aggregate_pair_rows(method_name: str, pair_df: pd.DataFrame) -> dict[str, float | str]: |
| return { |
| "method": method_name, |
| "mean_top1_hit_rate": float(pair_df["top1_hit_rate"].mean()), |
| "mean_top5_hit_rate": float(pair_df["top5_hit_rate"].mean()), |
| "mean_mrr": float(pair_df["mrr"].mean()), |
| "mean_median_rank": float(pair_df["median_rank"].mean()), |
| "mean_candidate_size": float(pair_df["candidate_size_per_query"].mean()), |
| "mean_chance_top1": float(pair_df["chance_top1"].mean()), |
| } |
|
|
|
|
| def evaluate_representation( |
| method_name: str, |
| matrix: np.ndarray, |
| anchor_df: pd.DataFrame, |
| slot_pairs: list[tuple[int, int]], |
| archive_scope: str, |
| min_dates_per_pair: int, |
| ) -> dict[str, Any]: |
| pair_rows: list[dict[str, Any]] = [] |
| query_rows: list[dict[str, Any]] = [] |
| for query_slot, target_slot in slot_pairs: |
| rows = evaluate_slot_pair( |
| matrix, |
| anchor_df, |
| query_slot=query_slot, |
| target_slot=target_slot, |
| archive_scope=archive_scope, |
| min_dates_per_pair=min_dates_per_pair, |
| ) |
| for row in rows: |
| raw_query_details = row.pop("query_details") |
| row["method"] = method_name |
| pair_rows.append(row) |
| for query_detail in raw_query_details: |
| query_detail["method"] = method_name |
| query_rows.append(query_detail) |
| if not pair_rows: |
| raise RuntimeError(f"method={method_name} has no valid pair rows.") |
| aggregate = aggregate_pair_rows(method_name, pd.DataFrame(pair_rows)) |
| return {"aggregate": aggregate, "pairs": pair_rows, "queries": query_rows} |
|
|
|
|
| def percentile_interval(samples: list[float]) -> tuple[float, float]: |
| values = np.asarray(samples, dtype=np.float64) |
| return float(np.percentile(values, 2.5)), float(np.percentile(values, 97.5)) |
|
|
|
|
| def bootstrap_pair_level( |
| method_name: str, |
| pair_df: pd.DataFrame, |
| bootstrap_samples: int, |
| rng: np.random.Generator, |
| ) -> dict[str, Any]: |
| metric_names = ["top1_hit_rate", "mrr", "top5_hit_rate"] |
| point_estimates = {metric: float(pair_df[metric].mean()) for metric in metric_names} |
| boot_values = {metric: [] for metric in metric_names} |
| pair_count = len(pair_df) |
| for _ in range(bootstrap_samples): |
| sampled_indices = rng.integers(0, pair_count, size=pair_count) |
| sampled = pair_df.iloc[sampled_indices] |
| for metric in metric_names: |
| boot_values[metric].append(float(sampled[metric].mean())) |
|
|
| result: dict[str, Any] = { |
| "method": method_name, |
| "bootstrap_unit": "pair", |
| "bootstrap_samples": int(bootstrap_samples), |
| "group_count": int(pair_count), |
| } |
| for metric in metric_names: |
| ci_low, ci_high = percentile_interval(boot_values[metric]) |
| result[f"{metric}_point_estimate"] = point_estimates[metric] |
| result[f"{metric}_ci_low"] = ci_low |
| result[f"{metric}_ci_high"] = ci_high |
| return result |
|
|
|
|
| def bootstrap_date_level( |
| method_name: str, |
| query_df: pd.DataFrame, |
| bootstrap_samples: int, |
| rng: np.random.Generator, |
| ) -> dict[str, Any]: |
| grouped_queries = { |
| group_key: group.copy().reset_index(drop=True) |
| for group_key, group in query_df.groupby(["query_slot", "target_slot", "archive_scope_label"], sort=True) |
| } |
| point_pair_rows: list[dict[str, float | str]] = [] |
| for group_key, group in grouped_queries.items(): |
| metrics = summarize_query_rows(group) |
| point_pair_rows.append( |
| { |
| "group_key": str(group_key), |
| "top1_hit_rate": metrics["top1_hit_rate"], |
| "mrr": metrics["mrr"], |
| "top5_hit_rate": metrics["top5_hit_rate"], |
| } |
| ) |
| point_pair_df = pd.DataFrame(point_pair_rows) |
| point_estimates = { |
| "top1_hit_rate": float(point_pair_df["top1_hit_rate"].mean()), |
| "mrr": float(point_pair_df["mrr"].mean()), |
| "top5_hit_rate": float(point_pair_df["top5_hit_rate"].mean()), |
| } |
| boot_values = {"top1_hit_rate": [], "mrr": [], "top5_hit_rate": []} |
| for _ in range(bootstrap_samples): |
| sampled_pair_rows: list[dict[str, float | str]] = [] |
| for group_key, group in grouped_queries.items(): |
| sampled_indices = rng.integers(0, len(group), size=len(group)) |
| sampled_group = group.iloc[sampled_indices].reset_index(drop=True) |
| metrics = summarize_query_rows(sampled_group) |
| sampled_pair_rows.append( |
| { |
| "group_key": str(group_key), |
| "top1_hit_rate": metrics["top1_hit_rate"], |
| "mrr": metrics["mrr"], |
| "top5_hit_rate": metrics["top5_hit_rate"], |
| } |
| ) |
| sampled_pair_df = pd.DataFrame(sampled_pair_rows) |
| boot_values["top1_hit_rate"].append(float(sampled_pair_df["top1_hit_rate"].mean())) |
| boot_values["mrr"].append(float(sampled_pair_df["mrr"].mean())) |
| boot_values["top5_hit_rate"].append(float(sampled_pair_df["top5_hit_rate"].mean())) |
|
|
| result: dict[str, Any] = { |
| "method": method_name, |
| "bootstrap_unit": "date", |
| "bootstrap_samples": int(bootstrap_samples), |
| "group_count": int(len(grouped_queries)), |
| "query_row_count": int(len(query_df)), |
| } |
| for metric in ["top1_hit_rate", "mrr", "top5_hit_rate"]: |
| ci_low, ci_high = percentile_interval(boot_values[metric]) |
| result[f"{metric}_point_estimate"] = point_estimates[metric] |
| result[f"{metric}_ci_low"] = ci_low |
| result[f"{metric}_ci_high"] = ci_high |
| return result |
|
|
|
|
| def bootstrap_rows( |
| method_name: str, |
| pair_df: pd.DataFrame, |
| query_df: pd.DataFrame, |
| bootstrap_samples: int, |
| bootstrap_seed: int, |
| ) -> list[dict[str, Any]]: |
| pair_rng = np.random.default_rng(bootstrap_seed) |
| date_rng = np.random.default_rng(bootstrap_seed + 1000) |
| return [ |
| bootstrap_date_level(method_name, query_df, bootstrap_samples=bootstrap_samples, rng=date_rng), |
| bootstrap_pair_level(method_name, pair_df, bootstrap_samples=bootstrap_samples, rng=pair_rng), |
| ] |
|
|
|
|
| def write_markdown(output_path: Path, summary: dict[str, Any]) -> None: |
| lines = [ |
| "# CB-Telemetry Time-Matched Retrieval", |
| "", |
| f"- feature_table: `{summary['feature_table']}`", |
| f"- max_slot_gap: `{summary['max_slot_gap']}`", |
| f"- min_dates_per_pair: `{summary['min_dates_per_pair']}`", |
| f"- archive_scope: `{summary['archive_scope']}`", |
| f"- bootstrap_samples: `{summary['bootstrap_samples']}`", |
| f"- slot_pairs: `{summary['slot_pairs']}`", |
| "", |
| "## Aggregate", |
| "", |
| "| method | top1 | chance_top1 | mrr | top5 | mean_candidate_size |", |
| "| --- | --- | --- | --- | --- | --- |", |
| ] |
| for row in summary["aggregate_rows"]: |
| lines.append( |
| f"| {row['method']} | {row['mean_top1_hit_rate']:.4f} | {row['mean_chance_top1']:.4f} | " |
| f"{row['mean_mrr']:.4f} | {row['mean_top5_hit_rate']:.4f} | {row['mean_candidate_size']:.1f} |" |
| ) |
| lines.extend(["", "## Bootstrap 95% CI", "", "| method | unit | top1 | mrr | top5 |", "| --- | --- | --- | --- | --- |"]) |
| for row in summary["bootstrap_rows"]: |
| lines.append( |
| f"| {row['method']} | {row['bootstrap_unit']} | " |
| f"{row['top1_hit_rate_point_estimate']:.4f} [{row['top1_hit_rate_ci_low']:.4f}, {row['top1_hit_rate_ci_high']:.4f}] | " |
| f"{row['mrr_point_estimate']:.4f} [{row['mrr_ci_low']:.4f}, {row['mrr_ci_high']:.4f}] | " |
| f"{row['top5_hit_rate_point_estimate']:.4f} [{row['top5_hit_rate_ci_low']:.4f}, {row['top5_hit_rate_ci_high']:.4f}] |" |
| ) |
| output_path.write_text("\n".join(lines) + "\n", encoding="utf-8") |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| root = Path(args.root).expanduser().resolve() |
| output_dir = resolve_path(root, args.output_dir) |
| output_dir.mkdir(parents=True, exist_ok=True) |
|
|
| feature_table_path = resolve_path(root, args.feature_table) |
| anchor_df = add_slot_metadata(pd.read_csv(feature_table_path, low_memory=False)) |
| anchor_df = anchor_df.sort_values(["date", "timestamp_dt", "filename"]).reset_index(drop=True) |
| anchor_df["anchor_row_index"] = np.arange(len(anchor_df), dtype=np.int32) |
| slot_pairs = build_slot_pairs( |
| anchor_df, |
| max_slot_gap=args.max_slot_gap, |
| min_dates_per_pair=args.min_dates_per_pair, |
| archive_scope=args.archive_scope, |
| ) |
|
|
| representation_matrices: list[tuple[str, np.ndarray, str]] = [] |
| for method_name, raw_path in parse_representations(args.representation): |
| representation_matrices.append((method_name, load_representation_matrix(root, raw_path, anchor_df), raw_path)) |
|
|
| if args.include_metadata_controls: |
| representation_matrices.append(("metadata_basic", build_metadata_matrix(anchor_df, include_calendar=False), "generated")) |
| representation_matrices.append(("metadata_calendar", build_metadata_matrix(anchor_df, include_calendar=True), "generated")) |
| continuous_columns = feature_columns(anchor_df) |
| continuous_matrix = anchor_df[continuous_columns].to_numpy(dtype=np.float32) |
| rng = np.random.default_rng(args.random_seed) |
| permuted = continuous_matrix[rng.permutation(len(anchor_df))] |
| representation_matrices.append(("random_permuted_continuous", standardize(permuted), "generated")) |
|
|
| aggregate_rows: list[dict[str, Any]] = [] |
| pair_rows: list[dict[str, Any]] = [] |
| query_rows: list[dict[str, Any]] = [] |
| all_bootstrap_rows: list[dict[str, Any]] = [] |
| detailed_results: dict[str, Any] = {} |
|
|
| for method_name, matrix, source_path in representation_matrices: |
| result = evaluate_representation( |
| method_name=method_name, |
| matrix=matrix, |
| anchor_df=anchor_df, |
| slot_pairs=slot_pairs, |
| archive_scope=args.archive_scope, |
| min_dates_per_pair=args.min_dates_per_pair, |
| ) |
| aggregate_rows.append(result["aggregate"]) |
| pair_rows.extend(result["pairs"]) |
| query_rows.extend(result["queries"]) |
| method_pair_df = pd.DataFrame(result["pairs"]) |
| method_query_df = pd.DataFrame(result["queries"]) |
| method_bootstrap_rows = bootstrap_rows( |
| method_name=method_name, |
| pair_df=method_pair_df, |
| query_df=method_query_df, |
| bootstrap_samples=args.bootstrap_samples, |
| bootstrap_seed=args.bootstrap_seed, |
| ) |
| all_bootstrap_rows.extend(method_bootstrap_rows) |
| detailed_results[method_name] = { |
| "feature_table": source_path, |
| "aggregate": result["aggregate"], |
| "bootstrap": method_bootstrap_rows, |
| } |
|
|
| aggregate_df = pd.DataFrame(aggregate_rows).sort_values( |
| ["mean_top1_hit_rate", "mean_mrr", "mean_top5_hit_rate"], |
| ascending=False, |
| ).reset_index(drop=True) |
| pair_df = pd.DataFrame(pair_rows).sort_values(["method", "query_slot", "target_slot"]).reset_index(drop=True) |
| query_df = pd.DataFrame(query_rows).sort_values( |
| ["method", "query_slot", "target_slot", "archive_scope_label", "date"] |
| ).reset_index(drop=True) |
| bootstrap_df = pd.DataFrame(all_bootstrap_rows).sort_values( |
| ["bootstrap_unit", "top1_hit_rate_point_estimate", "mrr_point_estimate", "top5_hit_rate_point_estimate"], |
| ascending=[True, False, False, False], |
| ).reset_index(drop=True) |
|
|
| aggregate_df.to_csv(output_dir / "aggregate_summary.csv", index=False) |
| pair_df.to_csv(output_dir / "pair_summary.csv", index=False) |
| query_df.to_csv(output_dir / "query_summary.csv", index=False) |
| bootstrap_df.to_csv(output_dir / "bootstrap_summary.csv", index=False) |
|
|
| summary: dict[str, Any] = { |
| "feature_table": release_path(root, feature_table_path), |
| "output_dir": release_path(root, output_dir), |
| "files": { |
| "aggregate_summary_csv": release_path(root, output_dir / "aggregate_summary.csv"), |
| "pair_summary_csv": release_path(root, output_dir / "pair_summary.csv"), |
| "query_summary_csv": release_path(root, output_dir / "query_summary.csv"), |
| "bootstrap_summary_csv": release_path(root, output_dir / "bootstrap_summary.csv"), |
| }, |
| "max_slot_gap": int(args.max_slot_gap), |
| "min_dates_per_pair": int(args.min_dates_per_pair), |
| "archive_scope": args.archive_scope, |
| "bootstrap_samples": int(args.bootstrap_samples), |
| "bootstrap_seed": int(args.bootstrap_seed), |
| "slot_pairs": [f"{src}->{dst}" for src, dst in slot_pairs], |
| "rows": int(len(anchor_df)), |
| "date_count": int(anchor_df["date"].nunique()), |
| "slot_count_distribution": { |
| str(key): int(value) |
| for key, value in anchor_df.groupby("date")["dawn_slot_id"].max().value_counts().sort_index().to_dict().items() |
| }, |
| "aggregate_rows": aggregate_df.to_dict(orient="records"), |
| "bootstrap_rows": bootstrap_df.to_dict(orient="records"), |
| "pair_rows": pair_df.to_dict(orient="records"), |
| "detailed_results": detailed_results, |
| } |
| (output_dir / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8") |
| write_markdown(output_dir / "summary.md", summary) |
| print( |
| json.dumps( |
| { |
| "output_dir": summary["output_dir"], |
| "archive_scope": summary["archive_scope"], |
| "max_slot_gap": summary["max_slot_gap"], |
| "aggregate_rows": summary["aggregate_rows"], |
| }, |
| ensure_ascii=False, |
| indent=2, |
| ) |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
