Datasets:

harryzhang1018
/

TestRandomization

"""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

	"""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