auto-sync 2026-07-03T18:06:14Z workspace (part 4)

workspace/scripts/audit_action_bounds.py

@@ -167,6 +167,19 @@ class _Accumulator:
         self.max_base_action_excess = 0.0
         self.action_excesses: list[float] = []
         self.base_action_excesses: list[float] = []
+        self.action_dim = 0
+        self.action_value_count = 0
+        self.base_action_value_count = 0
+        self.base_branch_value_count = 0
+        self.action_abs_sum: np.ndarray | None = None
+        self.base_action_abs_sum: np.ndarray | None = None
+        self.base_branch_abs_sum: np.ndarray | None = None
+        self.action_abs_max: np.ndarray | None = None
+        self.base_action_abs_max: np.ndarray | None = None
+        self.base_branch_abs_max: np.ndarray | None = None
+        self.action_dim_violations: np.ndarray | None = None
+        self.base_action_dim_violations: np.ndarray | None = None
+        self.base_branch_dim_violations: np.ndarray | None = None
 
     def add(
         self,
@@ -183,6 +196,28 @@ class _Accumulator:
         base_excess = _max_bound_excess(base_action, low=low, high=high)
         action_violation = action_excess > tolerance
         base_violation = base_excess > tolerance
+        self._add_dim_stats(
+            action,
+            attr_prefix="action",
+            low=low,
+            high=high,
+            tolerance=tolerance,
+        )
+        self._add_dim_stats(
+            base_action,
+            attr_prefix="base_action",
+            low=low,
+            high=high,
+            tolerance=tolerance,
+        )
+        if is_base:
+            self._add_dim_stats(
+                action,
+                attr_prefix="base_branch",
+                low=low,
+                high=high,
+                tolerance=tolerance,
+            )
         self.rows += 1
         self.charts.add(chart_id)
         self.action_violations += int(action_violation)
@@ -217,9 +252,85 @@ class _Accumulator:
             "max_base_action_bound_excess": self.max_base_action_excess,
             "p95_action_bound_excess": _percentile(self.action_excesses, 95),
             "p95_base_action_bound_excess": _percentile(self.base_action_excesses, 95),
+            "per_dim": {
+                "action": self._dim_payload("action"),
+                "base_action": self._dim_payload("base_action"),
+                "base_branch": self._dim_payload("base_branch"),
+            },
+            "suggested_global_scale_all_action_max": _safe_inverse(self._max_abs("action")),
+            "suggested_global_scale_all_base_branch_max": _safe_inverse(
+                self._max_abs("base_branch")
+            ),
         }
         return payload
 
+    def _ensure_dim(self, dim: int) -> None:
+        if dim <= 0:
+            raise ValueError("action dimension must be positive")
+        if self.action_dim == 0:
+            self.action_dim = dim
+            for prefix in ("action", "base_action", "base_branch"):
+                setattr(self, f"{prefix}_abs_sum", np.zeros(dim, dtype=np.float64))
+                setattr(self, f"{prefix}_abs_max", np.zeros(dim, dtype=np.float64))
+                setattr(self, f"{prefix}_dim_violations", np.zeros(dim, dtype=np.int64))
+            return
+        if dim != self.action_dim:
+            raise ValueError(f"mixed action dimensions in accumulator: {dim} vs {self.action_dim}")
+
+    def _add_dim_stats(
+        self,
+        values: np.ndarray,
+        *,
+        attr_prefix: str,
+        low: float,
+        high: float,
+        tolerance: float,
+    ) -> None:
+        matrix = np.asarray(values, dtype=np.float32).reshape(-1, values.shape[-1])
+        self._ensure_dim(int(matrix.shape[-1]))
+        abs_values = np.abs(matrix).astype(np.float64, copy=False)
+        below = np.maximum(float(low) - matrix, 0.0)
+        above = np.maximum(matrix - float(high), 0.0)
+        violations = np.maximum(below, above) > float(tolerance)
+        count_attr = f"{attr_prefix}_value_count"
+        setattr(self, count_attr, int(getattr(self, count_attr)) + int(matrix.shape[0]))
+        abs_sum = getattr(self, f"{attr_prefix}_abs_sum")
+        abs_max = getattr(self, f"{attr_prefix}_abs_max")
+        dim_violations = getattr(self, f"{attr_prefix}_dim_violations")
+        if abs_sum is None or abs_max is None or dim_violations is None:
+            raise RuntimeError("dimension accumulators were not initialized")
+        abs_sum += np.sum(abs_values, axis=0)
+        np.maximum(abs_max, np.max(abs_values, axis=0), out=abs_max)
+        dim_violations += np.sum(violations, axis=0).astype(np.int64)
+
+    def _dim_payload(self, attr_prefix: str) -> dict[str, Any]:
+        count = int(getattr(self, f"{attr_prefix}_value_count"))
+        abs_sum = getattr(self, f"{attr_prefix}_abs_sum")
+        abs_max = getattr(self, f"{attr_prefix}_abs_max")
+        dim_violations = getattr(self, f"{attr_prefix}_dim_violations")
+        if count == 0 or abs_sum is None or abs_max is None or dim_violations is None:
+            return {
+                "value_count": count,
+                "mean_abs": [],
+                "max_abs": [],
+                "violation_rate": [],
+            }
+        return {
+            "value_count": count,
+            "mean_abs": (abs_sum / float(count)).tolist(),
+            "max_abs": abs_max.tolist(),
+            "violation_rate": (dim_violations / float(count)).tolist(),
+            "suggested_per_dim_scale_to_unit_max": [
+                _safe_inverse(float(value)) for value in abs_max.tolist()
+            ],
+        }
+
+    def _max_abs(self, attr_prefix: str) -> float:
+        abs_max = getattr(self, f"{attr_prefix}_abs_max")
+        if abs_max is None or not np.size(abs_max):
+            return float("nan")
+        return float(np.max(abs_max))
+
 
 def _max_bound_excess(values: np.ndarray, *, low: float, high: float) -> float:
     below = np.maximum(float(low) - values, 0.0)
@@ -277,6 +388,28 @@ def _report(payload: dict[str, Any]) -> str:
             f"{_fmt(row['max_action_bound_excess'])} | "
             f"{_fmt(row['p95_action_bound_excess'])} |"
         )
+    lines.extend(
+        [
+            "",
+            "## Scale Diagnostics",
+            "",
+            "| Split | Action max scale | Base-branch max scale | Action per-dim max | Base-branch per-dim max | Action per-dim violation | Base-branch per-dim violation |",
+            "| --- | ---: | ---: | --- | --- | --- | --- |",
+        ]
+    )
+    for row in payload["rows"]:
+        per_dim = row.get("per_dim", {})
+        action = per_dim.get("action", {})
+        base_branch = per_dim.get("base_branch", {})
+        lines.append(
+            f"| {row['split']} | "
+            f"{_fmt(row.get('suggested_global_scale_all_action_max'))} | "
+            f"{_fmt(row.get('suggested_global_scale_all_base_branch_max'))} | "
+            f"{_fmt_list(action.get('max_abs'))} | "
+            f"{_fmt_list(base_branch.get('max_abs'))} | "
+            f"{_fmt_list(action.get('violation_rate'))} | "
+            f"{_fmt_list(base_branch.get('violation_rate'))} |"
+        )
     lines.extend(
         [
             "",
@@ -321,6 +454,20 @@ def _fmt(value: Any) -> str:
     return f"{float(value):.4f}"
 
 
+def _fmt_list(values: Any) -> str:
+    if not isinstance(values, list):
+        return "n/a"
+    return "[" + ", ".join(_fmt(value) for value in values) + "]"
+
+
+def _safe_inverse(value: Any) -> float | None:
+    if not isinstance(value, (int, float)) or not math.isfinite(float(value)):
+        return None
+    if float(value) <= 0.0:
+        return None
+    return 1.0 / float(value)
+
+
 def _tex(value: Any) -> str:
     return str(value).replace("_", "\\_").replace("%", "\\%").replace("&", "\\&")
 

workspace/scripts/eval_ctt_generated_rollout.py

@@ -74,6 +74,17 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--render-backend", default=None)
     parser.add_argument("--restore-tolerance", type=float, default=1.0e-5)
     parser.add_argument("--delta-scale", type=float, default=1.0)
+    parser.add_argument(
+        "--execution-action-scale",
+        type=float,
+        default=1.0,
+        help=(
+            "Multiply the full base/generated action chunk before action-bound "
+            "diagnostics, optional clipping, and simulator execution. This is a "
+            "diagnostic for action-representation scale mismatch; keep the default "
+            "1.0 for the unscaled deployment convention."
+        ),
+    )
     parser.add_argument(
         "--disable-action-clipping",
         action="store_true",
@@ -106,6 +117,8 @@ def main(argv: list[str] | None = None) -> int:
         parser.error("--max-target-charts must be positive")
     if args.restore_tolerance <= 0.0:
         parser.error("--restore-tolerance must be positive")
+    if args.execution_action_scale <= 0.0:
+        parser.error("--execution-action-scale must be positive")
 
     out_dir = args.out_dir
     out_dir.mkdir(parents=True, exist_ok=True)
@@ -212,6 +225,7 @@ def main(argv: list[str] | None = None) -> int:
         render_backend=args.render_backend,
         restore_tolerance=args.restore_tolerance,
         clip_actions=not args.disable_action_clipping,
+        execution_action_scale=args.execution_action_scale,
         log_path=log_path,
     )
     _append_log(log_path, f"rollout complete rows={len(rows)}")
@@ -236,6 +250,7 @@ def main(argv: list[str] | None = None) -> int:
             "source_code": "spline_tangent_code stores start/mid/end residual keyframes",
             "lossless": False,
             "delta_scale": args.delta_scale,
+            "execution_action_scale": args.execution_action_scale,
             "action_clipping_enabled": not args.disable_action_clipping,
         },
         "rows": rows,
@@ -525,6 +540,7 @@ def rollout_generated_cases(
     render_backend: str | None,
     restore_tolerance: float,
     clip_actions: bool,
+    execution_action_scale: float = 1.0,
     log_path: Path | None = None,
 ) -> list[dict[str, Any]]:
     archives: dict[Path, dict[str, Any]] = {}
@@ -565,6 +581,7 @@ def rollout_generated_cases(
                         archives=archives,
                         restore_tolerance=restore_tolerance,
                         clip_actions=clip_actions,
+                        execution_action_scale=execution_action_scale,
                         log_path=log_path,
                     )
                 )
@@ -595,13 +612,14 @@ def rollout_generated_cases(
                     action_groups.append(np.stack(group_actions, axis=0))
                 candidate_values = np.stack(action_groups, axis=0).astype(np.float32)
                 candidate_values = _adapt_action_dim_4d(candidate_values, env_dim)
+                candidate_values = _scale_actions_4d(candidate_values, execution_action_scale)
                 safety = _action_bound_diagnostics_4d(candidate_values, env)
                 if clip_actions:
                     candidate_values = _clip_to_action_space_4d(candidate_values, env)
                 _append_log(
                     log_path,
                     f"execute task={task_id} start={start} shape={candidate_values.shape} "
-                    f"clip_actions={clip_actions}",
+                    f"clip_actions={clip_actions} execution_action_scale={execution_action_scale}",
                 )
                 _after_state, rewards, successes, restore_error = execute_grouped_action_lattice_batch(
                     base_env,
@@ -643,6 +661,7 @@ def rollout_generated_cases(
                                 count=valid,
                             ),
                             restore_error=float(restore_error),
+                            execution_action_scale=execution_action_scale,
                         )
                     )
             finally:
@@ -662,6 +681,7 @@ def _rollout_cpu_sequential_batch(
     archives: dict[Path, dict[str, Any]],
     restore_tolerance: float,
     clip_actions: bool,
+    execution_action_scale: float,
     log_path: Path | None,
 ) -> list[dict[str, Any]]:
     rows: list[dict[str, Any]] = []
@@ -691,6 +711,7 @@ def _rollout_cpu_sequential_batch(
                     1, 1, *action.shape
                 )
                 candidate_values = _adapt_action_dim_4d(candidate_values, env_dim)
+                candidate_values = _scale_actions_4d(candidate_values, execution_action_scale)
                 safety = _action_bound_diagnostics_4d(candidate_values, env)
                 if clip_actions:
                     candidate_values = _clip_to_action_space_4d(candidate_values, env)
@@ -698,7 +719,7 @@ def _rollout_cpu_sequential_batch(
                     log_path,
                     f"execute sequential task={task_id} chart={target.chart_id} "
                     f"candidate={candidate_index} shape={candidate_values.shape} "
-                    f"clip_actions={clip_actions}",
+                    f"clip_actions={clip_actions} execution_action_scale={execution_action_scale}",
                 )
                 _after_state, rewards, successes, restore_error = execute_grouped_action_lattice_batch(
                     base_env,
@@ -727,6 +748,7 @@ def _rollout_cpu_sequential_batch(
                     safety_violations=safety_violations,
                     action_clip_max_abs=action_clip_max_abs,
                     restore_error=max(restore_errors, default=0.0),
+                    execution_action_scale=execution_action_scale,
                 )
             )
     finally:
@@ -745,6 +767,7 @@ def _measured_row_from_rollout(
     safety_violations: list[bool | None] | None = None,
     action_clip_max_abs: list[float | None] | None = None,
     restore_error: float,
+    execution_action_scale: float = 1.0,
 ) -> dict[str, Any]:
     if safety_violations is None:
         safety_violations = [None] * len(utilities)
@@ -765,6 +788,7 @@ def _measured_row_from_rollout(
         "state_hash": target.state_hash,
         "instruction": target.instruction,
         "candidates_evaluated": True,
+        "execution_action_scale": float(execution_action_scale),
         "selected_index": 0,
         "base_utility": base_utility,
         "stored_base_utility": target.stored_base_utility,
@@ -893,6 +917,14 @@ def _adapt_action_dim_4d(actions: np.ndarray, action_dim: int) -> np.ndarray:
     return np.concatenate([actions.astype(np.float32, copy=False), pad], axis=-1)
 
 
+def _scale_actions_4d(actions: np.ndarray, scale: float) -> np.ndarray:
+    if not math.isfinite(float(scale)) or float(scale) <= 0.0:
+        raise ValueError("execution action scale must be positive and finite")
+    if float(scale) == 1.0:
+        return actions.astype(np.float32, copy=False)
+    return (actions.astype(np.float32, copy=False) * float(scale)).astype(np.float32, copy=False)
+
+
 def _clip_to_action_space_4d(actions: np.ndarray, env: Any) -> np.ndarray:
     bounds = _action_space_bounds(actions, env)
     if bounds is None:

workspace/scripts/slurm/eval_ctt_generated_rollout.sbatch

@@ -36,6 +36,7 @@ SIM_BACKEND="${SIM_BACKEND:-physx_cpu}"
 RENDER_BACKEND="${RENDER_BACKEND:-cpu}"
 RESTORE_TOLERANCE="${RESTORE_TOLERANCE:-1e-5}"
 DELTA_SCALE="${DELTA_SCALE:-1.0}"
+EXECUTION_ACTION_SCALE="${EXECUTION_ACTION_SCALE:-1.0}"
 BOOTSTRAP_SAMPLES="${BOOTSTRAP_SAMPLES:-200}"
 INCLUDE_TARGETS_WITHOUT_POSITIVES="${INCLUDE_TARGETS_WITHOUT_POSITIVES:-0}"
 EXCLUDE_SELF_SOURCE="${EXCLUDE_SELF_SOURCE:-0}"
@@ -89,5 +90,6 @@ apptainer exec \
     --render-backend "$RENDER_BACKEND" \
     --restore-tolerance "$RESTORE_TOLERANCE" \
     --delta-scale "$DELTA_SCALE" \
+    --execution-action-scale "$EXECUTION_ACTION_SCALE" \
     --bootstrap-samples "$BOOTSTRAP_SAMPLES" \
     "${EXTRA_ARGS[@]}"