sync dominance feature mode code 2026-07-03

workspace/scripts/eval_dominance_selector.py

@@ -79,8 +79,15 @@ def main(argv: list[str] | None = None) -> int:
     calibrator = _DominanceScorer(args.checkpoint_template, score_source=args.score_source)
     calibration_rows = _rows(json.loads(args.calibration_input.read_text()))
     eval_rows = _rows(json.loads(args.eval_input.read_text()))
-    calibration_charts, calibration_index = _chart_map(args.calibration_target_index)
-    eval_charts, eval_index = _chart_map(args.eval_target_index)
+    chart_feature_mode = calibrator.chart_feature_mode(_first_train_seed(calibration_rows + eval_rows))
+    calibration_charts, calibration_index = _chart_map(
+        args.calibration_target_index,
+        chart_feature_mode=chart_feature_mode,
+    )
+    eval_charts, eval_index = _chart_map(
+        args.eval_target_index,
+        chart_feature_mode=chart_feature_mode,
+    )
 
     calibration_cases = [
         _dominance_case(row, calibration_charts, scorer=calibrator, k=args.k)
@@ -135,6 +142,7 @@ def main(argv: list[str] | None = None) -> int:
         "tau": tau,
         "tau_mode": args.tau,
         "score_source": args.score_source,
+        "chart_feature_mode": chart_feature_mode,
         "checkpoint_template": args.checkpoint_template,
         "residual_quantile": residual_quantile,
         "calibration_input": str(args.calibration_input),
@@ -183,9 +191,16 @@ class _DominanceScorer:
         self.checkpoint_template = checkpoint_template
         self.score_source = score_source
         self._models: dict[str, tuple[ChartEncoder, UtilityEnergy, TangentNormalizer, int]] = {}
+        self._feature_modes: dict[str, str] = {}
         self._encoded_chart_cache: dict[tuple[str, str], torch.Tensor] = {}
         self._base_score_cache: dict[tuple[str, str], float] = {}
 
+    def chart_feature_mode(self, seed: str) -> str:
+        if self.score_source == "row":
+            return "base"
+        self._model(seed)
+        return self._feature_modes.get(seed, "base")
+
     def base_score(self, row: dict[str, Any], chart: Any) -> float:
         if "base_predicted_score" in row:
             return float(row["base_predicted_score"])
@@ -249,6 +264,7 @@ class _DominanceScorer:
             chart_feature_dim = int(checkpoint["feature_dim"])
             chart_dim = int(checkpoint.get("chart_dim", 64))
             tangent_dim = int(checkpoint["tangent_dim"])
+        self._feature_modes[seed] = str(checkpoint.get("chart_feature_mode", "base"))
         encoder = ChartEncoder(chart_feature_dim, output_dim=chart_dim)
         utility_energy = UtilityEnergy(chart_dim=chart_dim, tangent_dim=tangent_dim)
         encoder.load_state_dict(checkpoint["chart_encoder"])
@@ -380,17 +396,25 @@ def _conformal_quantile(values: list[float], *, alpha: float) -> float:
     return clean[index]
 
 
-def _chart_map(index_path: Path) -> tuple[dict[str, Any], dict[str, Any]]:
+def _chart_map(index_path: Path, *, chart_feature_mode: str = "base") -> tuple[dict[str, Any], dict[str, Any]]:
     charts, index = load_chart_items(
         index_path,
         max_charts=None,
         require_positive=True,
         include_hidden=True,
         include_metadata=True,
+        chart_feature_mode=chart_feature_mode,
     )
     return {chart.chart_id: chart for chart in charts}, index
 
 
+def _first_train_seed(rows: list[dict[str, Any]]) -> str:
+    for row in rows:
+        if row.get("train_seed") is not None:
+            return str(row.get("train_seed"))
+    return "0"
+
+
 def _rows(payload: Any) -> list[dict[str, Any]]:
     rows = payload.get("rows", payload) if isinstance(payload, dict) else payload
     if not isinstance(rows, list):