auto-sync 2026-07-03T18:45:41Z workspace (part 3)

workspace/scripts/eval_ctt_generated_rollout.py

@@ -85,6 +85,25 @@ def main(argv: list[str] | None = None) -> int:
             "1.0 for the unscaled deployment convention."
         ),
     )
+    parser.add_argument(
+        "--execution-action-scale-vector",
+        default="",
+        help=(
+            "Optional comma-separated per-action-dimension positive scale vector "
+            "applied after --execution-action-scale and before the execution "
+            "transform. This diagnoses dimension-wise action representation mismatch."
+        ),
+    )
+    parser.add_argument(
+        "--execution-action-transform",
+        choices=("identity", "tanh"),
+        default="identity",
+        help=(
+            "Action-convention transform applied before action-bound diagnostics, "
+            "optional clipping, and simulator execution. 'identity' preserves "
+            "decoded controls; 'tanh' smoothly maps controls into finite env bounds."
+        ),
+    )
     parser.add_argument(
         "--disable-action-clipping",
         action="store_true",
@@ -119,6 +138,12 @@ def main(argv: list[str] | None = None) -> int:
         parser.error("--restore-tolerance must be positive")
     if args.execution_action_scale <= 0.0:
         parser.error("--execution-action-scale must be positive")
+    try:
+        execution_action_scale_vector = _parse_execution_action_scale_vector(
+            args.execution_action_scale_vector
+        )
+    except ValueError as exc:
+        parser.error(str(exc))
 
     out_dir = args.out_dir
     out_dir.mkdir(parents=True, exist_ok=True)
@@ -226,6 +251,8 @@ def main(argv: list[str] | None = None) -> int:
         restore_tolerance=args.restore_tolerance,
         clip_actions=not args.disable_action_clipping,
         execution_action_scale=args.execution_action_scale,
+        execution_action_scale_vector=execution_action_scale_vector,
+        execution_action_transform=args.execution_action_transform,
         log_path=log_path,
     )
     _append_log(log_path, f"rollout complete rows={len(rows)}")
@@ -251,6 +278,12 @@ def main(argv: list[str] | None = None) -> int:
             "lossless": False,
             "delta_scale": args.delta_scale,
             "execution_action_scale": args.execution_action_scale,
+            "execution_action_scale_vector": (
+                None
+                if execution_action_scale_vector is None
+                else execution_action_scale_vector.astype(float).tolist()
+            ),
+            "execution_action_transform": args.execution_action_transform,
             "action_clipping_enabled": not args.disable_action_clipping,
         },
         "rows": rows,
@@ -541,6 +574,8 @@ def rollout_generated_cases(
     restore_tolerance: float,
     clip_actions: bool,
     execution_action_scale: float = 1.0,
+    execution_action_scale_vector: np.ndarray | None = None,
+    execution_action_transform: str = "identity",
     log_path: Path | None = None,
 ) -> list[dict[str, Any]]:
     archives: dict[Path, dict[str, Any]] = {}
@@ -582,6 +617,8 @@ def rollout_generated_cases(
                         restore_tolerance=restore_tolerance,
                         clip_actions=clip_actions,
                         execution_action_scale=execution_action_scale,
+                        execution_action_scale_vector=execution_action_scale_vector,
+                        execution_action_transform=execution_action_transform,
                         log_path=log_path,
                     )
                 )
@@ -612,14 +649,21 @@ 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)
+                candidate_values = _prepare_actions_for_execution_4d(
+                    candidate_values,
+                    env,
+                    execution_action_scale=execution_action_scale,
+                    execution_action_scale_vector=execution_action_scale_vector,
+                    execution_action_transform=execution_action_transform,
+                )
                 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} execution_action_scale={execution_action_scale}",
+                    f"clip_actions={clip_actions} execution_action_scale={execution_action_scale} "
+                    f"execution_action_transform={execution_action_transform}",
                 )
                 _after_state, rewards, successes, restore_error = execute_grouped_action_lattice_batch(
                     base_env,
@@ -662,6 +706,8 @@ def rollout_generated_cases(
                             ),
                             restore_error=float(restore_error),
                             execution_action_scale=execution_action_scale,
+                            execution_action_scale_vector=execution_action_scale_vector,
+                            execution_action_transform=execution_action_transform,
                         )
                     )
             finally:
@@ -682,6 +728,8 @@ def _rollout_cpu_sequential_batch(
     restore_tolerance: float,
     clip_actions: bool,
     execution_action_scale: float,
+    execution_action_scale_vector: np.ndarray | None,
+    execution_action_transform: str,
     log_path: Path | None,
 ) -> list[dict[str, Any]]:
     rows: list[dict[str, Any]] = []
@@ -711,7 +759,13 @@ 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)
+                candidate_values = _prepare_actions_for_execution_4d(
+                    candidate_values,
+                    env,
+                    execution_action_scale=execution_action_scale,
+                    execution_action_scale_vector=execution_action_scale_vector,
+                    execution_action_transform=execution_action_transform,
+                )
                 safety = _action_bound_diagnostics_4d(candidate_values, env)
                 if clip_actions:
                     candidate_values = _clip_to_action_space_4d(candidate_values, env)
@@ -719,7 +773,8 @@ 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} execution_action_scale={execution_action_scale}",
+                    f"clip_actions={clip_actions} execution_action_scale={execution_action_scale} "
+                    f"execution_action_transform={execution_action_transform}",
                 )
                 _after_state, rewards, successes, restore_error = execute_grouped_action_lattice_batch(
                     base_env,
@@ -749,6 +804,8 @@ def _rollout_cpu_sequential_batch(
                     action_clip_max_abs=action_clip_max_abs,
                     restore_error=max(restore_errors, default=0.0),
                     execution_action_scale=execution_action_scale,
+                    execution_action_scale_vector=execution_action_scale_vector,
+                    execution_action_transform=execution_action_transform,
                 )
             )
     finally:
@@ -768,6 +825,8 @@ def _measured_row_from_rollout(
     action_clip_max_abs: list[float | None] | None = None,
     restore_error: float,
     execution_action_scale: float = 1.0,
+    execution_action_scale_vector: np.ndarray | None = None,
+    execution_action_transform: str = "identity",
 ) -> dict[str, Any]:
     if safety_violations is None:
         safety_violations = [None] * len(utilities)
@@ -789,6 +848,12 @@ def _measured_row_from_rollout(
         "instruction": target.instruction,
         "candidates_evaluated": True,
         "execution_action_scale": float(execution_action_scale),
+        "execution_action_scale_vector": (
+            None
+            if execution_action_scale_vector is None
+            else execution_action_scale_vector.astype(float).tolist()
+        ),
+        "execution_action_transform": str(execution_action_transform),
         "selected_index": 0,
         "base_utility": base_utility,
         "stored_base_utility": target.stored_base_utility,
@@ -917,12 +982,72 @@ 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:
+def _parse_execution_action_scale_vector(raw: str) -> np.ndarray | None:
+    text = str(raw or "").strip()
+    if not text:
+        return None
+    values = [float(item.strip()) for item in text.split(",") if item.strip()]
+    if not values:
+        return None
+    vector = np.asarray(values, dtype=np.float32)
+    if np.any(~np.isfinite(vector)) or np.any(vector <= 0.0):
+        raise ValueError("--execution-action-scale-vector values must be positive and finite")
+    return vector
+
+
+def _prepare_actions_for_execution_4d(
+    actions: np.ndarray,
+    env: Any,
+    *,
+    execution_action_scale: float,
+    execution_action_scale_vector: np.ndarray | None,
+    execution_action_transform: str,
+) -> np.ndarray:
+    scaled = _scale_actions_4d(
+        actions,
+        execution_action_scale,
+        scale_vector=execution_action_scale_vector,
+    )
+    return _transform_actions_4d(scaled, env, execution_action_transform)
+
+
+def _scale_actions_4d(
+    actions: np.ndarray,
+    scale: float,
+    *,
+    scale_vector: np.ndarray | None = None,
+) -> 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:
+    output = actions.astype(np.float32, copy=False)
+    if float(scale) != 1.0:
+        output = output * float(scale)
+    if scale_vector is not None:
+        vector = np.asarray(scale_vector, dtype=np.float32).reshape(-1)
+        if vector.size != output.shape[-1]:
+            raise ValueError(
+                "execution action scale vector length must match adapted action dimension"
+            )
+        if np.any(~np.isfinite(vector)) or np.any(vector <= 0.0):
+            raise ValueError("execution action scale vector must be positive and finite")
+        output = output * vector.reshape(1, 1, 1, -1)
+    return output.astype(np.float32, copy=False)
+
+
+def _transform_actions_4d(actions: np.ndarray, env: Any, transform: str) -> np.ndarray:
+    value = str(transform or "identity").strip().lower()
+    if value == "identity":
         return actions.astype(np.float32, copy=False)
-    return (actions.astype(np.float32, copy=False) * float(scale)).astype(np.float32, copy=False)
+    if value != "tanh":
+        raise ValueError(f"Unknown execution action transform: {transform}")
+    squashed = np.tanh(actions.astype(np.float32, copy=False))
+    bounds = _action_space_bounds(actions, env)
+    if bounds is None:
+        return squashed.astype(np.float32, copy=False)
+    low_arr, high_arr = bounds
+    center = ((low_arr + high_arr) * 0.5).reshape(1, 1, 1, -1)
+    half_range = ((high_arr - low_arr) * 0.5).reshape(1, 1, 1, -1)
+    return (center + half_range * squashed).astype(np.float32, copy=False)
 
 
 def _clip_to_action_space_4d(actions: np.ndarray, env: Any) -> np.ndarray:

workspace/scripts/slurm/eval_ctt_generated_rollout.sbatch

@@ -37,6 +37,8 @@ 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}"
+EXECUTION_ACTION_SCALE_VECTOR="${EXECUTION_ACTION_SCALE_VECTOR:-}"
+EXECUTION_ACTION_TRANSFORM="${EXECUTION_ACTION_TRANSFORM:-identity}"
 BOOTSTRAP_SAMPLES="${BOOTSTRAP_SAMPLES:-200}"
 INCLUDE_TARGETS_WITHOUT_POSITIVES="${INCLUDE_TARGETS_WITHOUT_POSITIVES:-0}"
 EXCLUDE_SELF_SOURCE="${EXCLUDE_SELF_SOURCE:-0}"
@@ -91,5 +93,7 @@ apptainer exec \
     --restore-tolerance "$RESTORE_TOLERANCE" \
     --delta-scale "$DELTA_SCALE" \
     --execution-action-scale "$EXECUTION_ACTION_SCALE" \
+    --execution-action-scale-vector "$EXECUTION_ACTION_SCALE_VECTOR" \
+    --execution-action-transform "$EXECUTION_ACTION_TRANSFORM" \
     --bootstrap-samples "$BOOTSTRAP_SAMPLES" \
     "${EXTRA_ARGS[@]}"