File size: 6,910 Bytes
c399dd1 | 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 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 | """Batched reduced-order model (ROM) for nominal and test-randomized (TR) evaluation. Sim2Sim only.
Plant = release GoalEnv.step (util-free copy): kinematic bicycle with car_length=1.0 m, steering scale 0.7 rad,
motor torque map with tau0/omega0, speed clipped to [0, 5] m/s, dt = 0.1 s, state cast to float32 each step.
Success = first post-step distance < 3 m; time = (step index + 1) * 0.1 s (release logger is one step early).
Each episode carries its own perturbation parameters (one row in `params`). Nominal ROM = all defaults.
Command path for every step: policy -> steering-rate limiter -> actuation delay -> start hold -> additive noise -> plant.
Common random numbers: all policies see the same params and noise for the same episode index.
"""
import numpy as np
import torch
from common import DT, MAX_STEPS, GOAL_RADIUS
DEFAULTS = dict(
tau0=1000.0, omega0=2600.0, # powertrain (release nominal)
sig_thr=0.0, sig_steer=0.0, # per-step additive Gaussian sd on normalized throttle/steering
delay=0, # actuation delay (control steps of 0.1 s)
steer_rate=np.inf, # max |change| of normalized steering per control step
hold=0, # start hold (control steps with zero command and zero speed)
wheelbase=1.0, # ROM car_length (m)
vmax=5.0, # ROM speed cap (m/s)
x0=0.0, y0=0.0, yaw0=0.0, v0=0.0, # initial state
gx_scale=1.0, g_rot=0.0, # goal radius scale and bearing rotation (rad), applied to the base goal
obs_pos_sig=0.0, # sd of observation noise on relative goal position (m), per step
)
R_WHEEL, I_WHEEL, GAMMA, C1, C0, STEER_SCALE = 0.47, 6.69, 1.0 / 3.0, 1e-4, 0.02, 0.7
def default_params(n):
return {k: np.full(n, v, dtype=np.float64) for k, v in DEFAULTS.items()}
def simulate(actor, goals_xy, params, noise_seed, device='cpu', max_steps=MAX_STEPS, keep_traj=False):
"""Run len(goals_xy) episodes for one policy. Returns dict of per-episode arrays.
goals_xy: (N,2) base goals. params: dict name -> (N,) arrays (missing keys use defaults).
noise_seed: seed of the per-step noise stream (same seed -> same noise for every policy).
"""
n = len(goals_xy)
P = default_params(n)
for k, v in params.items():
P[k] = np.broadcast_to(np.asarray(v, dtype=np.float64), (n,)).copy()
t = lambda a: torch.as_tensor(a, dtype=torch.float64, device=device)
tau0, omega0, wb, vmax = t(P['tau0']), t(P['omega0']), t(P['wheelbase']), t(P['vmax'])
sig = torch.stack([t(P['sig_thr']), t(P['sig_steer'])], 1)
rate = t(P['steer_rate'])
hold = torch.as_tensor(P['hold'].astype(np.int64), device=device)
delay = P['delay'].astype(np.int64)
dmax = int(delay.max()) if n else 0
# goal perturbation (radius scale and bearing rotation about the start point)
g = np.asarray(goals_xy, dtype=np.float64)
c, s = np.cos(P['g_rot']), np.sin(P['g_rot'])
gx = P['gx_scale'] * (c * g[:, 0] - s * g[:, 1])
gy = P['gx_scale'] * (s * g[:, 0] + c * g[:, 1])
gx, gy = t(gx), t(gy)
f32 = lambda a: a.to(torch.float32).to(torch.float64)
x, y, yaw, v = f32(t(P['x0'])), f32(t(P['y0'])), f32(t(P['yaw0'])), f32(t(P['v0']))
gen = torch.Generator(device=device).manual_seed(int(noise_seed))
obs_sig = t(P['obs_pos_sig'])
prev_steer = torch.zeros(n, dtype=torch.float64, device=device)
buf = torch.zeros((dmax + 1, n, 2), dtype=torch.float64, device=device) # ring buffer for delay
didx = torch.as_tensor(delay, device=device)
done = torch.zeros(n, dtype=torch.bool, device=device)
hit_step = torch.full((n,), -1, dtype=torch.int64, device=device)
min_d = torch.full((n,), np.inf, dtype=torch.float64, device=device)
traj = [] if keep_traj else None
ar = torch.arange(n, device=device)
for k in range(max_steps):
# observation (release relative_state_to_goal), optional position noise
cth, sth = torch.cos(yaw), torch.sin(yaw)
dx, dy = gx - x, gy - y
rx, ry = cth * dx + sth * dy, -sth * dx + cth * dy
if bool((obs_sig > 0).any()):
rx = rx + obs_sig * torch.randn(n, generator=gen, device=device, dtype=torch.float64)
ry = ry + obs_sig * torch.randn(n, generator=gen, device=device, dtype=torch.float64)
obs = torch.stack([rx, ry, torch.atan2(ry, rx), v], 1).to(torch.float32)
a = actor(obs).to(torch.float64)
# steering-rate limiter (as in the release Chrono loop)
d = a[:, 1] - prev_steer
lim = torch.where(d.abs() > rate, prev_steer + rate * torch.sign(d), a[:, 1])
prev_steer = lim
cmd = torch.stack([a[:, 0], lim], 1)
# actuation delay: write at slot k, read slot k - delay (zeros before the first command)
buf[k % (dmax + 1)] = cmd
cmd_d = buf[(k - didx) % (dmax + 1), ar]
cmd_d = torch.where((k - didx >= 0)[:, None], cmd_d, torch.zeros_like(cmd_d))
# start hold: zero command and braked vehicle
held = k < hold
cmd_d = torch.where(held[:, None], torch.zeros_like(cmd_d), cmd_d)
# additive noise (release: added after the policy, not clipped again); drawn for all episodes every step
z = torch.randn((n, 2), generator=gen, device=device, dtype=torch.float64)
alpha, beta = (cmd_d + sig * z).unbind(1)
# plant (release GoalEnv.step)
omega_m = v / (R_WHEEL * GAMMA)
T = alpha * (-tau0 * omega_m / omega0 + tau0) - C1 * omega_m - C0
v_dot = T * GAMMA / I_WHEEL * R_WHEEL
nx = x + torch.cos(yaw) * v * DT
ny = y + torch.sin(yaw) * v * DT
nyaw = yaw + v * torch.tan(beta * STEER_SCALE) / wb * DT
nv = torch.clamp(v + v_dot * DT, min=torch.zeros_like(vmax), max=vmax)
nv = torch.where(held, torch.zeros_like(nv), nv)
nx, ny, nyaw, nv = f32(nx), f32(ny), f32(nyaw), f32(nv)
live = ~done
x, y, yaw, v = (torch.where(live, nx, x), torch.where(live, ny, y), torch.where(live, nyaw, yaw), torch.where(live, nv, v))
dist = torch.sqrt((x - gx) ** 2 + (y - gy) ** 2)
min_d = torch.where(live, torch.minimum(min_d, dist), min_d)
newhit = live & (dist < GOAL_RADIUS)
hit_step = torch.where(newhit, torch.full_like(hit_step, k), hit_step)
done = done | newhit
if keep_traj:
traj.append(torch.stack([x, y, yaw, v], 1).cpu().numpy().astype(np.float32))
if bool(done.all()):
break
hs = hit_step.cpu().numpy()
out = dict(success=hs >= 0, time_s=np.where(hs >= 0, (hs + 1) * DT, np.nan),
terminal_distance_m=torch.sqrt((x - gx) ** 2 + (y - gy) ** 2).cpu().numpy(),
min_distance_m=min_d.cpu().numpy())
if keep_traj:
out['traj'] = np.stack(traj, 1)
return out
|