auto-sync 2026-07-04T07:48:09Z workspace (part 4)

workspace/scripts/build_selector_diagnostic_sweep.py

@@ -18,6 +18,7 @@ PROJECT_ROOT = Path(__file__).resolve().parents[1]
 
 DEFAULT_PATTERNS = (
     "runs/ctt_base_context_obs_learned_dominance_chartcompat_obs_utility_task_envclip_k16_train_to_test/metrics.json",
+    "runs/ctt_base_context_obs_learned_dominance_*bundle*_envclip_k16_train_to_test/metrics.json",
     "runs/ctt_base_context_obs_dominance_envclip_k16_train_to_test/metrics.json",
     "runs/ctt_base_context_obs_dominance_envclip_k16_train_to_test_tau0/metrics.json",
     "runs/ctt_dominance_utility_energy_val_to_test_seed*/metrics.json",

workspace/scripts/eval_learned_dominance_selector.py

@@ -92,12 +92,37 @@ SCORE_SHAPE_NAMES = [
     "candidate_score_percentile",
     "candidate_score_top_margin",
 ]
+BUNDLE_CONSENSUS_NAMES = [
+    "bundle_num_candidates_log",
+    "bundle_neighbor_count_r020",
+    "bundle_neighbor_count_r040",
+    "bundle_neighbor_frac_r020",
+    "bundle_neighbor_frac_r040",
+    "bundle_mean_peer_rms",
+    "bundle_min_peer_rms",
+    "bundle_medoid_rms",
+    "bundle_is_medoid",
+    "bundle_peer_score_mean_r020",
+    "bundle_peer_score_max_r020",
+    "bundle_peer_score_mean_r040",
+    "bundle_peer_score_max_r040",
+    "bundle_unique_source_count_r040",
+    "bundle_unique_source_frac_r040",
+    "bundle_unique_task_count_r040",
+    "bundle_same_source_frac_r040",
+    "bundle_score_density_r040",
+    "bundle_rank_density_r040",
+]
 FEATURE_SET_CHOICES = (
     "basic",
     "tangent",
     "context",
     "context_tangent",
     "score_context",
+    "bundle_consensus",
+    "score_bundle_consensus",
+    "context_bundle_consensus",
+    "context_tangent_bundle_consensus",
     "source_evidence",
     "tangent_source_evidence",
     "context_source_evidence",
@@ -106,8 +131,11 @@ FEATURE_SET_CHOICES = (
     "chart_tangent_compat",
     "score_chart_compat",
     "score_context_chart_compat",
+    "chart_bundle_consensus",
+    "score_chart_bundle_consensus",
     "chart_source_compat",
     "chart_tangent_source_compat",
+    "chart_source_bundle_consensus",
 )
 
 
@@ -456,6 +484,7 @@ def _candidate_dataset(
         score_mean = sum(scores) / len(scores)
         score_std = math.sqrt(sum((score - score_mean) ** 2 for score in scores) / len(scores)) + 1.0e-6
         score_shape = _score_shape_matrix(scores)
+        bundle_consensus = _bundle_consensus_matrix(tangents, scores, source_chart_ids, source_task_ids)
         for candidate_index, score in enumerate(scores):
             source_chart_id = str(source_chart_ids[candidate_index]) if candidate_index < len(source_chart_ids) else ""
             tangent = np.asarray(
@@ -489,6 +518,7 @@ def _candidate_dataset(
                     chart_feature_mode=selector_chart_feature_mode,
                 ),
                 score_shape=score_shape[candidate_index],
+                bundle_consensus=bundle_consensus[candidate_index],
                 num_candidates=len(scores),
                 feature_set=feature_set,
             )
@@ -554,6 +584,8 @@ def _feature_names(feature_set: str) -> list[str]:
         names.extend(SOURCE_EVIDENCE_NAMES)
     if _uses_chart_compat(feature_set):
         names.extend(CHART_COMPAT_NAMES)
+    if _uses_bundle_consensus(feature_set):
+        names.extend(BUNDLE_CONSENSUS_NAMES)
     if feature_set in FEATURE_SET_CHOICES:
         return names
     raise ValueError(f"unknown feature_set: {feature_set}")
@@ -574,6 +606,7 @@ def _candidate_feature(
     source_evidence: np.ndarray | None = None,
     chart_compat: np.ndarray | None = None,
     score_shape: np.ndarray | None = None,
+    bundle_consensus: np.ndarray | None = None,
 ) -> np.ndarray:
     tangent = np.asarray(tangent, dtype=float).reshape(-1)
     if tangent.size < 21:
@@ -616,6 +649,10 @@ def _candidate_feature(
         if chart_compat is None:
             chart_compat = np.zeros(len(CHART_COMPAT_NAMES), dtype=float)
         parts.append(np.asarray(chart_compat, dtype=float).reshape(-1))
+    if _uses_bundle_consensus(feature_set):
+        if bundle_consensus is None:
+            bundle_consensus = np.zeros(len(BUNDLE_CONSENSUS_NAMES), dtype=float)
+        parts.append(np.asarray(bundle_consensus, dtype=float).reshape(-1))
     if feature_set in FEATURE_SET_CHOICES:
         return np.concatenate(parts)
     raise ValueError(f"unknown feature_set: {feature_set}")
@@ -629,6 +666,8 @@ def _uses_context(feature_set: str) -> bool:
         "context_tangent_source_evidence",
         "score_context",
         "score_context_chart_compat",
+        "context_bundle_consensus",
+        "context_tangent_bundle_consensus",
     }
 
 
@@ -637,6 +676,8 @@ def _uses_score_shape(feature_set: str) -> bool:
         "score_context",
         "score_chart_compat",
         "score_context_chart_compat",
+        "score_bundle_consensus",
+        "score_chart_bundle_consensus",
     }
 
 
@@ -648,6 +689,7 @@ def _uses_tangent(feature_set: str) -> bool:
         "context_tangent_source_evidence",
         "chart_tangent_compat",
         "chart_tangent_source_compat",
+        "context_tangent_bundle_consensus",
     }
 
 
@@ -659,6 +701,7 @@ def _uses_source_evidence(feature_set: str) -> bool:
         "context_tangent_source_evidence",
         "chart_source_compat",
         "chart_tangent_source_compat",
+        "chart_source_bundle_consensus",
     }
 
 
@@ -668,8 +711,23 @@ def _uses_chart_compat(feature_set: str) -> bool:
         "chart_tangent_compat",
         "score_chart_compat",
         "score_context_chart_compat",
+        "chart_bundle_consensus",
+        "score_chart_bundle_consensus",
         "chart_source_compat",
         "chart_tangent_source_compat",
+        "chart_source_bundle_consensus",
+    }
+
+
+def _uses_bundle_consensus(feature_set: str) -> bool:
+    return feature_set in {
+        "bundle_consensus",
+        "score_bundle_consensus",
+        "context_bundle_consensus",
+        "context_tangent_bundle_consensus",
+        "chart_bundle_consensus",
+        "score_chart_bundle_consensus",
+        "chart_source_bundle_consensus",
     }
 
 
@@ -957,6 +1015,111 @@ def _score_shape_matrix(scores: list[float]) -> np.ndarray:
     return np.asarray(rows, dtype=float)
 
 
+def _bundle_consensus_matrix(
+    tangents: Any,
+    scores: list[float],
+    source_chart_ids: Any,
+    source_task_ids: Any,
+) -> np.ndarray:
+    """Deployment-visible CTT bundle self-consistency features.
+
+    These features are computed only from the generated transported tangents,
+    their inference-time scores, and train-source identifiers already present
+    in the candidate row. They deliberately do not inspect target positive or
+    negative tangent sets, measured candidate utilities, or hidden outcomes.
+    """
+
+    num_candidates = len(scores)
+    if num_candidates == 0:
+        return np.zeros((0, len(BUNDLE_CONSENSUS_NAMES)), dtype=float)
+    tangent_matrix = _candidate_tangent_matrix(tangents, num_candidates)
+    score_array = np.asarray(scores, dtype=float).reshape(-1)
+    if score_array.size < num_candidates:
+        score_array = np.pad(score_array, (0, num_candidates - score_array.size))
+    score_array = score_array[:num_candidates]
+    source_ids = _string_list(source_chart_ids, num_candidates)
+    task_ids = _string_list(source_task_ids, num_candidates)
+
+    diff = tangent_matrix[:, None, :] - tangent_matrix[None, :, :]
+    distances = np.sqrt(np.mean(diff * diff, axis=2))
+    nonself = ~np.eye(num_candidates, dtype=bool)
+    peer_denominator = max(1.0, float(num_candidates - 1))
+    peer_distances = np.where(nonself, distances, np.nan)
+    mean_peer = np.nanmean(peer_distances, axis=1) if num_candidates > 1 else np.zeros(num_candidates)
+    min_peer = np.nanmin(peer_distances, axis=1) if num_candidates > 1 else np.zeros(num_candidates)
+    mean_peer = np.nan_to_num(mean_peer, nan=0.0, posinf=0.0, neginf=0.0)
+    min_peer = np.nan_to_num(min_peer, nan=0.0, posinf=0.0, neginf=0.0)
+    medoid_index = int(np.argmin(mean_peer)) if num_candidates else 0
+    medoid_distances = distances[:, medoid_index] if num_candidates else np.zeros(0)
+
+    rows: list[list[float]] = []
+    for index in range(num_candidates):
+        peers_020 = [j for j in range(num_candidates) if j != index and distances[index, j] <= 0.20]
+        peers_040 = [j for j in range(num_candidates) if j != index and distances[index, j] <= 0.40]
+        group_040 = [index, *peers_040]
+        unique_sources = {source_ids[j] for j in group_040 if source_ids[j]}
+        unique_tasks = {task_ids[j] for j in group_040 if task_ids[j]}
+        same_source_peers = [
+            j for j in peers_040 if source_ids[index] and source_ids[j] == source_ids[index]
+        ]
+        score_mean_020, score_max_020 = _score_stats(score_array, peers_020)
+        score_mean_040, score_max_040 = _score_stats(score_array, peers_040)
+        density_weights = np.exp(-np.clip(distances[index], 0.0, 10.0) / 0.40)
+        density_weights[index] = 0.0
+        score_density = float(np.dot(density_weights, score_array) / max(1.0e-12, density_weights.sum()))
+        rank_density = float(sum(1.0 for j in peers_040 if score_array[j] >= score_array[index]))
+        rows.append(
+            [
+                math.log1p(num_candidates),
+                float(len(peers_020)),
+                float(len(peers_040)),
+                float(len(peers_020)) / peer_denominator,
+                float(len(peers_040)) / peer_denominator,
+                float(mean_peer[index]),
+                float(min_peer[index]),
+                float(medoid_distances[index]),
+                float(index == medoid_index),
+                score_mean_020,
+                score_max_020,
+                score_mean_040,
+                score_max_040,
+                float(len(unique_sources)),
+                float(len(unique_sources)) / max(1.0, float(len(group_040))),
+                float(len(unique_tasks)),
+                float(len(same_source_peers)) / max(1.0, float(len(peers_040))),
+                score_density,
+                rank_density / max(1.0, float(len(peers_040))),
+            ]
+        )
+    output = np.asarray(rows, dtype=float)
+    return np.nan_to_num(output, nan=0.0, posinf=0.0, neginf=0.0)
+
+
+def _candidate_tangent_matrix(tangents: Any, num_candidates: int) -> np.ndarray:
+    rows: list[np.ndarray] = []
+    tangent_list = list(tangents or [])
+    for index in range(num_candidates):
+        tangent = np.asarray(tangent_list[index] if index < len(tangent_list) else [], dtype=float).reshape(-1)
+        if tangent.size < 21:
+            tangent = np.pad(tangent, (0, 21 - tangent.size))
+        elif tangent.size > 21:
+            tangent = tangent[:21]
+        rows.append(tangent.astype(float, copy=False))
+    return np.stack(rows, axis=0)
+
+
+def _string_list(values: Any, length: int) -> list[str]:
+    raw = list(values or [])
+    return [str(raw[index]) if index < len(raw) else "" for index in range(length)]
+
+
+def _score_stats(scores: np.ndarray, indices: list[int]) -> tuple[float, float]:
+    if not indices:
+        return 0.0, 0.0
+    values = scores[indices]
+    return float(values.mean()), float(values.max())
+
+
 def _context_feature(context: dict[str, Any]) -> np.ndarray:
     target_task = str(context.get("target_task_id", ""))
     source_task = str(context.get("source_task_id", ""))