File size: 4,276 Bytes
0c3dd1d | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 | """Shared paths, goal sets, policy loading and hashing for Case 2 (Sim2Sim only).
Policies are read from checkpoint zips: the 24 trained policies in policies/<config>_s<seed>/ckpt_4.zip and the
four released checkpoints of the original hmmwv_goal_reach repository in policies/released/ppo_<k>.zip.
"""
import hashlib
import io
import json
import zipfile
from pathlib import Path
import numpy as np
import torch
BASE = Path(__file__).resolve().parent
POLICY_DIR = BASE / 'policies'
RELEASED_DIR = POLICY_DIR / 'released' # copies of hmmwv_goal_reach/data/rl_model/ppo_<k>.zip (BSD-3-Clause)
RESULTS = BASE / 'results'
DT = 0.1 # control period, ROM integration step (s)
MAX_STEPS = 400 # 40 s horizon, as in training and the release ROM evaluation
HORIZON_S = 40.0 # common horizon for ROM and Chrono; failure score = horizon
GOAL_RADIUS = 3.0 # release evaluation success radius (m)
# Goal sets. Set A = exploration (TR design), set B = held-out evaluation. Different seeds, never mixed.
GOAL_SET_SEEDS = {'A': 2026110401, 'B': 2026110499}
GOAL_RANGES = {'id': (10.0, 20.0), 'ood': (20.0, 40.0)}
def sha256(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def make_goal_set(name, n_per_range):
"""Uniform radius in each range, uniform bearing. Returns list of dicts."""
rng = np.random.default_rng(GOAL_SET_SEEDS[name])
goals = []
for label, (lo, hi) in GOAL_RANGES.items():
r = rng.uniform(lo, hi, n_per_range)
b = rng.uniform(-np.pi, np.pi, n_per_range)
for i in range(n_per_range):
goals.append(dict(goal_id=f'{name}_{label}_{i:03d}', goal_set=name, goal_range=label,
x=float(r[i] * np.cos(b[i])), y=float(r[i] * np.sin(b[i])),
radius_m=float(r[i]), bearing_rad=float(b[i])))
return goals
def rel_path(path):
"""Path relative to the package directory (as stored in the registry and the ROM manifests)."""
return Path(path).resolve().relative_to(BASE).as_posix()
def policy_registry():
"""name -> dict(path, origin, config, seed, step). Released checkpoints + trained ones. Paths are absolute."""
reg = {}
for k in range(1, 5):
reg[f'rel{k}'] = dict(path=str(RELEASED_DIR / f'ppo_{k}.zip'), origin='released',
config='release (single PPO run)', seed=None, step=k * 500_000)
meta = POLICY_DIR / 'registry.json'
if meta.exists():
for name, entry in json.loads(meta.read_text()).items():
reg[name] = dict(entry, path=str(BASE / entry['path']))
return reg
class Actor(torch.nn.Module):
"""Deterministic SB3 PPO actor: 4 ReLU layers, linear action head, clip to the action box."""
def __init__(self, zip_path):
super().__init__()
with zipfile.ZipFile(zip_path) as archive:
state = torch.load(io.BytesIO(archive.read('policy.pth')), map_location='cpu', weights_only=True)
self.layers = []
i = 0
while f'mlp_extractor.policy_net.{i}.weight' in state:
self.layers.append((state[f'mlp_extractor.policy_net.{i}.weight'], state[f'mlp_extractor.policy_net.{i}.bias']))
i += 2
self.head = (state['action_net.weight'], state['action_net.bias'])
self.low = torch.tensor([0.2, -1.0])
self.high = torch.tensor([0.5, 1.0])
@torch.no_grad()
def forward(self, obs):
x = torch.as_tensor(obs, dtype=torch.float32)
for w, b in self.layers:
x = torch.relu(torch.nn.functional.linear(x, w, b))
a = torch.nn.functional.linear(x, *self.head)
return torch.clamp(a, self.low, self.high)
def to_device(self, device):
self.layers = [(w.to(device), b.to(device)) for w, b in self.layers]
self.head = tuple(t.to(device) for t in self.head)
self.low, self.high = self.low.to(device), self.high.to(device)
return self
def relative_obs(x, y, theta, v, gx, gy):
"""Release relative_state_to_goal, vectorized (float64 in, float32 out)."""
c, s = np.cos(theta), np.sin(theta)
dx, dy = gx - x, gy - y
rx = c * dx + s * dy
ry = -s * dx + c * dy
return np.stack([rx, ry, np.arctan2(ry, rx), v], axis=-1).astype(np.float32)
|