File size: 5,354 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 | """ROM evaluation conditions: nominal ROM and test-randomization (TR) variants. Sim2Sim only.
Each variant = per-episode parameter distributions + number of trials K per goal.
Distributions: ('const', v), ('normal', mu, sd), ('uniform', lo, hi), ('loguniform', lo, hi), ('choice', [values]).
Parameters (see rom_batch.DEFAULTS): tau0, omega0, sig_thr, sig_steer, delay, steer_rate, hold, wheelbase, vmax,
x0, y0, yaw0, v0, gx_scale, g_rot, obs_pos_sig.
Every exploration variant tried on goal set A is listed here and in results/exploration_report.md.
Condition names also seed the random streams (run_rom.seed_of), so they are kept unchanged; 'paper_tr' is the
noise-only TR (action and powertrain noise).
"""
import numpy as np
PI = float(np.pi)
REL = dict(tau0=('normal', 1000.0, 50.0), omega0=('normal', 2600.0, 100.0),
sig_thr=('const', 0.05), sig_steer=('const', 0.05)) # noise-only TR (noise of the release training script)
def scaled_release(c):
return dict(tau0=('normal', 1000.0, 50.0 * c), omega0=('normal', 2600.0, 100.0 * c),
sig_thr=('const', 0.05 * c), sig_steer=('const', 0.05 * c))
def agnostic(c):
return dict(wheelbase=('loguniform', 1.0 / c, 1.0 * c), tau0=('loguniform', 1000.0 / c, 1000.0 * c),
omega0=('loguniform', 2600.0 / c, 2600.0 * c), vmax=('loguniform', 5.0 / c, 5.0 * c),
sig_thr=('const', 0.05), sig_steer=('const', 0.05))
EXPLORE = {
# baseline
'nominal': (1, {}),
# family 1: noise-only TR and scaled versions
'paper_tr': (20, REL),
'paper_tr_x2': (20, scaled_release(2)),
'paper_tr_x4': (20, scaled_release(4)),
# family 2: action noise only
'act_0.1': (20, dict(sig_thr=('const', 0.1), sig_steer=('const', 0.1))),
'act_0.2': (20, dict(sig_thr=('const', 0.2), sig_steer=('const', 0.2))),
'act_0.3': (20, dict(sig_thr=('const', 0.3), sig_steer=('const', 0.3))),
# family 3: actuation delay (0.1 s steps)
'delay_1': (1, dict(delay=('const', 1))),
'delay_2': (1, dict(delay=('const', 2))),
'delay_3': (1, dict(delay=('const', 3))),
'delay_rand03': (20, dict(delay=('choice', [0, 1, 2, 3]))),
# family 4: steering-rate limit and start hold (deployment-loop details, deterministic)
'rate_0.1': (1, dict(steer_rate=('const', 0.1))),
'rate_rand': (20, dict(steer_rate=('loguniform', 0.05, 0.5))),
'hold_1s': (1, dict(hold=('const', 10))),
'loop_rate_hold': (1, dict(steer_rate=('const', 0.1), hold=('const', 10))),
# family 5: powertrain parameters (broad) and speed cap
'tau0_logu': (20, dict(tau0=('loguniform', 100.0, 1000.0))),
'vmax_u': (20, dict(vmax=('uniform', 5.0, 15.0))),
'powertrain_speed': (20, dict(tau0=('loguniform', 100.0, 1000.0), vmax=('uniform', 5.0, 15.0))),
# family 6: steering authority (ROM wheelbase)
'wb_2': (1, dict(wheelbase=('const', 2.0))),
'wb_3.4': (1, dict(wheelbase=('const', 3.378))),
'wb_u1_4': (20, dict(wheelbase=('uniform', 1.0, 4.0))),
'wb_logu1_8': (20, dict(wheelbase=('loguniform', 1.0, 8.0))),
# family 7: initial pose and goal shift
'pose_release': (20, dict(x0=('uniform', -1.0, 1.0), y0=('uniform', -1.0, 1.0), yaw0=('uniform', -PI, PI))),
'yaw_45': (20, dict(yaw0=('uniform', -PI / 4, PI / 4))),
'goal_far': (20, dict(gx_scale=('uniform', 1.0, 2.0))),
'goal_rot': (20, dict(g_rot=('uniform', -PI / 6, PI / 6))),
# family 8: observation noise
'obs_0.5': (20, dict(obs_pos_sig=('const', 0.5))),
# family 9: agnostic parameter TR. Every ROM model parameter x LogUniform(1/c, c) around its nominal value,
# plus the action noise of the noise-only TR. No direction of model error is assumed.
'agn_c2': (20, agnostic(2.0)),
'agn_c4': (20, agnostic(4.0)),
'agn_c8': (20, agnostic(8.0)),
'agn_c4_loop': (20, {**agnostic(4.0), 'steer_rate': ('const', 0.1), 'hold': ('const', 10)}),
'agn_c8_loop': (20, {**agnostic(8.0), 'steer_rate': ('const', 0.1), 'hold': ('const', 10)}),
# family 10: deterministic "calibrated" ROM baselines (not TR): HMMWV wheelbase and/or the deployment loop
'calib_wb_loop': (1, dict(wheelbase=('const', 3.378), steer_rate=('const', 0.1), hold=('const', 10))),
# family 11 (added after a first analysis of the set-A results): actuator TR = random steering-rate limit and
# random delay, alone and with the noise-only TR
'act_rate_delay': (20, dict(steer_rate=('loguniform', 0.05, 0.5), delay=('choice', [0, 1, 2, 3]))),
'act_rate_delay_paper': (20, {**REL, 'steer_rate': ('loguniform', 0.05, 0.5), 'delay': ('choice', [0, 1, 2, 3])}),
'rate_rand_paper': (20, {**REL, 'steer_rate': ('loguniform', 0.05, 0.5)}),
}
def sample(spec, n, rng):
"""spec: dict param -> distribution. Returns dict param -> (n,) array."""
out = {}
for k, d in spec.items():
kind = d[0]
if kind == 'const':
out[k] = np.full(n, float(d[1]))
elif kind == 'normal':
out[k] = rng.normal(d[1], d[2], n)
elif kind == 'uniform':
out[k] = rng.uniform(d[1], d[2], n)
elif kind == 'loguniform':
out[k] = np.exp(rng.uniform(np.log(d[1]), np.log(d[2]), n))
elif kind == 'choice':
out[k] = rng.choice(np.asarray(d[1], dtype=np.float64), n)
else:
raise ValueError(kind)
return out
|