| """Probe a model-removed build with per-behavior stock policies, including grids. |
| |
| Unlike the vector collection wrapper, this preserves spatial observations and |
| allows heterogeneous roles. This is a simulation smoke test, not a collector. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| from pathlib import Path |
|
|
| import numpy as np |
| import onnxruntime as ort |
| from mlagents_envs.environment import UnityEnvironment, ActionTuple |
| from mlagents_envs.side_channel.engine_configuration_channel import EngineConfigurationChannel |
| from mlagents_envs.side_channel.stats_side_channel import StatsSideChannel |
|
|
|
|
| class StockPolicy: |
| def __init__(self, path, spec, rng): |
| options = ort.SessionOptions() |
| options.intra_op_num_threads = 1 |
| options.inter_op_num_threads = 1 |
| options.log_severity_level = 3 |
| self.session = ort.InferenceSession(str(path), sess_options=options, |
| providers=["CPUExecutionProvider"]) |
| self.path, self.spec, self.rng = path, spec, rng |
| self.inputs = self.session.get_inputs() |
| self.outputs = {o.name: o for o in self.session.get_outputs()} |
| self.memory = {} |
| self.memory_shape = None |
| self.memory_resets = 0 |
| self.mapping = [] |
| remaining = list(range(len(spec.observation_specs))) |
| for item in self.inputs: |
| if item.name == "action_masks": |
| continue |
| if "recurrent" in item.name: |
| if item.name != "recurrent_in" or "recurrent_out" not in self.outputs: |
| raise ValueError("Unsupported recurrent I/O contract") |
| self.memory_shape = tuple(int(n) for n in item.shape[1:]) |
| continue |
| shape = tuple(int(n) for n in item.shape[1:]) |
| matches = [] |
| for index in remaining: |
| obs_shape = tuple(spec.observation_specs[index].shape) |
| if shape == obs_shape: |
| matches.append((index, False)) |
| elif len(obs_shape) == 3 and shape == (obs_shape[2], obs_shape[0], obs_shape[1]): |
| matches.append((index, True)) |
| if not matches: |
| raise ValueError(f"{path.name}: input {item.name} {shape} does not match " |
| f"live observations {[o.shape for o in spec.observation_specs]}") |
| index, transpose = matches[0] |
| remaining.remove(index) |
| self.mapping.append((item.name, index, transpose)) |
| if remaining: |
| raise ValueError(f"{path.name}: unconsumed live observation sensors {remaining}") |
|
|
| def forget(self, agent_ids): |
| for agent_id in agent_ids: |
| if self.memory.pop(int(agent_id), None) is not None: |
| self.memory_resets += 1 |
|
|
| def act(self, decision): |
| n = len(decision) |
| feeds = {} |
| for name, index, transpose in self.mapping: |
| values = decision.obs[index] |
| if not np.isfinite(values).all(): |
| raise ValueError("Non-finite observation") |
| feeds[name] = (values.transpose(0, 3, 1, 2) if transpose else values).astype(np.float32) |
| for item in self.inputs: |
| if item.name == "action_masks": |
| feeds[item.name] = (np.concatenate([~m for m in decision.action_mask], axis=1) |
| if decision.action_mask is not None else |
| np.ones((n, sum(self.spec.action_spec.discrete_branches)))).astype(np.float32) |
| if self.memory_shape is not None: |
| feeds["recurrent_in"] = np.stack([ |
| self.memory.get(int(agent_id), np.zeros(self.memory_shape, dtype=np.float32)) |
| for agent_id in decision.agent_id |
| ]) |
| names = [name for name in ("continuous_actions", "discrete_actions") if name in self.outputs] |
| if self.memory_shape is not None: |
| names.append("recurrent_out") |
| values = dict(zip(names, self.session.run(names, feeds))) |
| if self.memory_shape is not None: |
| memory = values["recurrent_out"] |
| if memory.shape != (n,) + self.memory_shape or not np.isfinite(memory).all(): |
| raise ValueError(f"Bad recurrent output: {memory.shape}") |
| for agent_id, state in zip(decision.agent_id, memory): |
| self.memory[int(agent_id)] = state.copy() |
| actions = ActionTuple() |
| if self.spec.action_spec.continuous_size: |
| continuous = values["continuous_actions"] |
| if continuous.shape != (n, self.spec.action_spec.continuous_size): |
| raise ValueError(f"Bad continuous action shape {continuous.shape}") |
| if not np.isfinite(continuous).all(): |
| raise ValueError("Non-finite continuous action") |
| actions.add_continuous(np.clip(continuous, -1, 1).astype(np.float32)) |
| branches = self.spec.action_spec.discrete_branches |
| if len(branches): |
| raw = values["discrete_actions"] |
| if raw.shape == (n, len(branches)): |
| discrete = raw.astype(np.int32) |
| elif raw.shape == (n, sum(branches)): |
| columns, offset = [], 0 |
| for branch_index, width in enumerate(branches): |
| logits = raw[:, offset:offset + width].astype(np.float64) |
| if decision.action_mask is not None: |
| logits = np.where(decision.action_mask[branch_index], -np.inf, logits) |
| probabilities = np.exp(logits - logits.max(axis=1, keepdims=True)) |
| probabilities /= probabilities.sum(axis=1, keepdims=True) |
| columns.append([self.rng.choice(width, p=row) for row in probabilities]) |
| offset += width |
| discrete = np.array(columns, dtype=np.int32).T |
| else: |
| raise ValueError(f"Bad discrete action shape {raw.shape}") |
| for column, width in enumerate(branches): |
| if not np.all((discrete[:, column] >= 0) & (discrete[:, column] < width)): |
| raise ValueError("Discrete action out of range") |
| if decision.action_mask is not None and np.any( |
| decision.action_mask[column][np.arange(n), discrete[:, column]] |
| ): |
| raise ValueError("Policy selected a masked action") |
| actions.add_discrete(discrete) |
| return actions |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--build", required=True, type=Path) |
| parser.add_argument("--policies", type=Path, help="External stock policy directory; unused in random mode") |
| parser.add_argument("--report", required=True, type=Path) |
| parser.add_argument("--ticks", type=int, default=1000) |
| parser.add_argument("--worker-id", type=int, default=650) |
| parser.add_argument("--seed", type=int, default=23) |
| parser.add_argument("--random", action="store_true") |
| parser.add_argument("--graphics", action="store_true", help="Show the simulation window") |
| parser.add_argument("--render", action="store_true", help="Render camera sensors in batchmode") |
| parser.add_argument("--time-scale", type=float, default=20.0) |
| args = parser.parse_args() |
| manifest = json.loads((args.build.parent / "simulation-build.json").read_text()) |
| if args.policies is None: |
| args.policies = args.build.parent.parent / "policies" / manifest["environment"] |
| policy_files = {b["name"]: args.policies / Path(b["stockPolicy"]).name |
| for b in manifest["behaviors"]} |
| rng = np.random.default_rng(args.seed) |
| channel = EngineConfigurationChannel() |
| stats_channel = StatsSideChannel() |
| channel.set_configuration_parameters(time_scale=args.time_scale, width=1280, height=720) |
| report = {"build": str(args.build.resolve()), "mode": "random" if args.random else "stock", |
| "rendering": args.graphics or args.render, |
| "seed": args.seed, "behaviors": {}, "ticks": 0, "passed": False} |
| args.report.parent.mkdir(parents=True, exist_ok=True) |
| env = None |
| try: |
| env = UnityEnvironment(file_name=str(args.build), no_graphics=not (args.graphics or args.render), seed=args.seed, |
| worker_id=args.worker_id, side_channels=[channel, stats_channel], timeout_wait=90, |
| additional_args=["-batchmode"] if args.render and not args.graphics else None, |
| log_folder=str(args.report.parent / "player-logs")) |
| env.reset() |
| policies = {} |
| for name, spec in env.behavior_specs.items(): |
| path = policy_files[name.split("?team=")[0]] |
| if not args.random: |
| policies[name] = StockPolicy(path, spec, rng) |
| decision, terminal = env.get_steps(name) |
| report["behaviors"][name] = { |
| "observation_shapes": [list(o.shape) for o in spec.observation_specs], |
| "observation_dimension_properties": [[str(d) for d in o.dimension_property] |
| for o in spec.observation_specs], |
| "observation_ranges": [[None, None] for o in spec.observation_specs], |
| "continuous_size": spec.action_spec.continuous_size, |
| "discrete_branches": [int(x) for x in spec.action_spec.discrete_branches], |
| "initial_agents": len(decision), "decision_rows": 0, "terminals": 0, |
| "interruptions": 0, "agent_reward_sum": 0.0, "group_reward_sum": 0.0, |
| "policy": None if args.random else str(path), |
| "policy_sha256": None if args.random else hashlib.sha256(path.read_bytes()).hexdigest(), |
| } |
| if not report["behaviors"]: |
| raise ValueError("No external ML-Agents behaviors exposed") |
| print(json.dumps(report["behaviors"], indent=2), flush=True) |
| |
| for tick in range(args.ticks + 1): |
| for name, spec in env.behavior_specs.items(): |
| decision, terminal = env.get_steps(name) |
| row = report["behaviors"][name] |
| if not args.random: |
| policies[name].forget(terminal.agent_id) |
| row["terminals"] += int(np.sum(~terminal.interrupted)) |
| row["interruptions"] += int(np.sum(terminal.interrupted)) |
| for steps in (decision, terminal): |
| if not np.isfinite(steps.reward).all() or not np.isfinite(steps.group_reward).all(): |
| raise ValueError("Non-finite reward") |
| row["agent_reward_sum"] += float(np.sum(steps.reward, dtype=np.float64)) |
| row["group_reward_sum"] += float(np.sum(steps.group_reward, dtype=np.float64)) |
| if tick == args.ticks or len(decision) == 0: |
| continue |
| row["decision_rows"] += len(decision) |
| for index, observation in enumerate(decision.obs): |
| minimum, maximum = float(observation.min()), float(observation.max()) |
| old_min, old_max = row["observation_ranges"][index] |
| row["observation_ranges"][index] = [minimum if old_min is None else min(old_min, minimum), |
| maximum if old_max is None else max(old_max, maximum)] |
| actions = spec.action_spec.random_action(len(decision)) if args.random else policies[name].act(decision) |
| env.set_actions(name, actions) |
| if tick == args.ticks: |
| break |
| env.step() |
| report["ticks"] = tick + 1 |
| if (tick + 1) % 200 == 0: |
| print(f"ticks={tick + 1}", flush=True) |
| if not all(b["decision_rows"] > 0 for b in report["behaviors"].values()): |
| raise ValueError("One or more behaviors never accepted an action") |
| for name, policy in policies.items(): |
| report["behaviors"][name]["recurrent_memory_shape"] = policy.memory_shape |
| report["behaviors"][name]["recurrent_memory_resets"] = policy.memory_resets |
| if manifest["environment"] == "GridWorld": |
| if not (args.graphics or args.render): |
| raise ValueError("GridWorld camera observations require --render or --graphics") |
| for row in report["behaviors"].values(): |
| for shape, value_range in zip(row["observation_shapes"], row["observation_ranges"]): |
| if len(shape) == 3 and value_range[1] - value_range[0] <= 1e-6: |
| raise ValueError("GridWorld camera produced constant observations") |
| report["passed"] = True |
| except Exception as error: |
| report["error"] = f"{type(error).__name__}: {error}" |
| raise |
| finally: |
| if env is not None: |
| env.close() |
| args.report.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8") |
| print(json.dumps(report, indent=2), flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
