Buckets:
| # cwm3 stage registry (plan §3, week-1 experiments 1-3). train_cwm3.py --stage S --variant v --seed k | |
| # recipe keys: batch, rows_per_epoch (0 = one full pass), max_epochs, patience, lr, weight_decay, sched (warmcos|none), | |
| # val_rows (all|innovation = slice_tag>0), amp, grad_clip, select_LF (default true; false = L_F excluded from the selection objective, 2026-09-11 P2 | |
| # verdict — new E variants only; absent in old runs -> true, reproducible). lambda: branch loss weights. Selection objective | |
| # (BEST / early stop) = validation chain NLL (+ 0.1 L_F for E) — models/heads.selection_objective. | |
| defaults: | |
| regimes: [manual, engaged] # ONE model for both regimes; mode is an input embedding | |
| seeds: [0, 1, 2] | |
| minutes: 18 # wall budget per GPU-lock acquisition (<= 22 min hard rule) | |
| amp: true | |
| grad_clip: 1.0 | |
| pred_splits: [test, val] | |
| stages: | |
| V0: | |
| branch: V | |
| # rows_per_epoch 800k = cwm2's 400k per regime x 2 regimes (one model): the same per-regime exposure as the can_only_direct reference | |
| # (the first 400k run V0_can4s_s0_rpe400k was still improving at the 40-epoch cap; decisions.md) | |
| recipe: {batch: 1024, rows_per_epoch: 800000, max_epochs: 40, patience: 8, lr: 3.0e-4, weight_decay: 0.01, sched: warmcos, val_rows: innovation} | |
| lambda: {hz: 0.5} | |
| model: {d: 256, hidden: 256, dropout: 0.1} | |
| variants: | |
| can4s: {can_hist: "4s"} # X = t-3.9..t @10 Hz (the s12 grid) | |
| can8s: {can_hist: "8s"} # concat(Xpre, X)[:, 1::2] = t-7.8..t @5 Hz (rows with x8_ok only) | |
| # 2026-09-11 (final-assembly agent, roadmap §三 freeze list): `can4s` verbatim under the float64 statistics (stats_version 2 = the trainer default | |
| # since 2026-09-11); the V base of the final joint model must share the stats-v2 X statistics of the U base (models/cwm3.merge_stats asserts | |
| # equality on overlapping keys; V0_can4s_s<k> carries the pre-fix float32 statistics). Run dirs V0_can4s_s<k>_stats2 (--out); paired vs | |
| # V0_can4s_s<k> on identical rows (tags V0s2_s<k>_stats2_vs_stats1): manual brake / gas / steer_phase must not be WORSE. | |
| can4s_stats2: {can_hist: "4s"} | |
| # 2026-09-12 (GPU-baselines agent, experiment B): can4s_stats2 with the TCN trunk replaced by a parameter-matched (±10 %) GRU / 2-layer causal Transformer | |
| # (models/branches_alt.py; stats v2 default). Run dirs V0_can4s_s<k>_stats2_{gru,tfm} (--out); paired vs V0_can4s_s<k>_stats2 on identical rows. | |
| can4s_stats2_gru: {can_hist: "4s", arch: gru} | |
| can4s_stats2_tfm: {can_hist: "4s", arch: tfm} | |
| experiment: "Exp2: 8 s vs 4 s CAN history; brake/gas/steer_phase onset PR-AUC@3s manual vs can_only_direct 0.333/0.575/0.746" | |
| U0: | |
| branch: U | |
| # kin_predictability.train_variant recipe: GRU(->128) + Linear-GELU-Linear head, AdamW 1e-3 / wd 1e-4, batch 4096, full pass | |
| # per epoch, <= 8 epochs, early stop on val hazard NLL with patience 2, all val rows | |
| # max_epochs 12 = the reference's actual command (`--epochs 12`, run_predictability_train_*_latest.json; its val NLL was still | |
| # improving at epoch 12). The docstring default 8 stopped the first cwm3 run while its objective was still falling (decisions.md). | |
| recipe: {batch: 4096, rows_per_epoch: 0, max_epochs: 12, patience: 2, lr: 1.0e-3, weight_decay: 1.0e-4, sched: none, val_rows: all} | |
| lambda: {K: 0.5} | |
| model: {hid: 128, hidden: 128, dropout: 0.0} | |
| variants: | |
| kin_can: {cabin: none} | |
| kin_can_noK: {cabin: none, lambda: {K: 0.0}} # diagnostic: chains only (exact kin_predictability supervision), no K residual head loss | |
| kin_can_vc: {cabin: vc256} # full-frame cabin PCA-256 (causal) | |
| kin_can_crop: {cabin: crop256} # route-median crop PCA-256 (NON-causal ROI -> diagnostic) | |
| # 2026-09-11 (coordinator, K4 v2 stats arm): recipe keys `kclip` (kinematics clamp; new-run default 8 = X_CLIP, old runs 5) and `u_in_ln` | |
| # (LayerNorm over the 12 kinematics channels at the trunk entry, default false). Run dirs U0_kin_can_noK_s<k>_kcv2_clip8[_ln]. | |
| kin_can_noK_clip8: {cabin: none, lambda: {K: 0.0}, recipe: {kclip: 8}} # noK, clamp 8, no input LN | |
| kin_can_noK_clip8_ln: {cabin: none, lambda: {K: 0.0}, recipe: {kclip: 8, u_in_ln: true}} # noK, clamp 8 + input LayerNorm(12) | |
| # 2026-09-11 (innovation agent, roadmap §二 2 — identity-invariant driver trunk; models/identity.py; baseline = kin_can_noK_clip8_ln on causal v2, stats v2): | |
| # `u_adv: true` + lambda adv: gradient-reversal device-classifier head on the GRU state (dongle id over the TRAIN devices); lambda adv swept {0.1, 0.3}, | |
| # picked on val chain NLL only. `u_devnorm: true`: per-device (per-route) CAUSAL expanding normalisation of the 11 kinematics channels (prior = train-pool | |
| # stats, pseudo-count devnorm_n0 50, sd floor devnorm_sd_floor 0.2 x pool sd). Run dirs U0_kin_can_noK_s<k>_kcv2_clip8_ln_{adv01,adv03,devnorm} (--out). | |
| kin_can_noK_clip8_ln_adv01: {cabin: none, lambda: {K: 0.0, adv: 0.1}, recipe: {kclip: 8, u_in_ln: true, u_adv: true}} | |
| kin_can_noK_clip8_ln_adv03: {cabin: none, lambda: {K: 0.0, adv: 0.3}, recipe: {kclip: 8, u_in_ln: true, u_adv: true}} | |
| kin_can_noK_clip8_ln_devnorm: {cabin: none, lambda: {K: 0.0}, recipe: {kclip: 8, u_in_ln: true, u_devnorm: true, devnorm_n0: 50, devnorm_sd_floor: 0.2}} | |
| # 2026-09-12 (GPU-baselines agent, experiment B — branch-architecture ablation; models/branches_alt.py, results/tables/branch_arch_ablation.md): the survivor | |
| # recipe (causal v2 inputs, stats v2, kclip 8, input LN) with the GRU trunk replaced by a parameter-matched (±10 %) causal TCN / 2-layer causal Transformer | |
| # (variant key `arch`, forwarded by train_cwm3.model_kwargs; absent -> reference module). Run dirs U0_kin_can_noK_s<k>_kcv2_clip8_ln_{tcn,tfm} (--out). | |
| kin_can_noK_clip8_ln_tcn: {cabin: none, lambda: {K: 0.0}, recipe: {kclip: 8, u_in_ln: true}, arch: tcn} | |
| kin_can_noK_clip8_ln_tfm: {cabin: none, lambda: {K: 0.0}, recipe: {kclip: 8, u_in_ln: true}, arch: tfm} | |
| # 2026-09-12 (gaze/robustness agent, roadmap §B3 — `gaze_off` as a driver target chain, the engaged lever): survivor recipe (causal v2 inputs, stats v2, | |
| # kclip 8, input LN) + recipe key `u_gaze_chain: true` (DriverBranch `gaze_head` -> a third 2-state driver chain gaze_off from our own causal face-geometry | |
| # state, results/targets_gaze_causal_routes_v2 = data/build_gaze_targets.py; its NLL chain_gaze_off enters the U loss with lambda G and the selection | |
| # objective) and, for `_gzfc`, `u_face: true` (the 9 causal `lm_*` face-landmark channels + valid bit of results/targets_face_causal_routes_v2 appended to | |
| # every GRU input step; models/branches.DriverBranch n_face). Run dirs U0_kin_can_noK_s<k>_kcv2_clip8_ln_{gz,gzfc} (--out); paired vs | |
| # U0_kin_can_noK_s<k>_kcv2_clip8_ln on identical rows (hand_leave / hand_return / head_turn NOT_WORSE required; results/tables/gaze_chain.md). | |
| kin_can_noK_clip8_ln_gz: {cabin: none, lambda: {K: 0.0, G: 1.0}, recipe: {kclip: 8, u_in_ln: true, u_gaze_chain: true}} | |
| kin_can_noK_clip8_ln_gzfc: {cabin: none, lambda: {K: 0.0, G: 1.0}, recipe: {kclip: 8, u_in_ln: true, u_gaze_chain: true, u_face: true}} | |
| # 2026-09-14 (CAN-arms agent, plan Part A §A.5 — OPTIONAL BATON-side arms on the driver chains; pre-registration docs/decisions.md 2026-09-15T01:48:39Z): the survivor | |
| # recipe (causal v2 inputs, stats v2, kclip 8, input LN, lambda K 0) with ONE opt-in recipe flag each (default off everywhere -> every existing variant byte-identical); | |
| # paired vs U0_kin_can_noK_s<k>_kcv2_clip8_ln on identical rows (hand_leave / hand_return / head_turn_onset PR-AUC@3s + hazard NLL, both regimes; results/tables/can_arms.md). | |
| # `u_nocan: true` : train/batch.prep_U zeroes the 5 standardised CAN columns Kx[..., 12:17] (valid bit + Δt kept, GRU input still 18-wide). Run dir U0_nocan_s<k>_kcv2_clip8_ln (--out). | |
| # `u_can_gate: true`: models/branches.CanReleaseGate — one scalar gate g = σ(a·act + b), a = b = 0 at init (2g = 1: identity), act = mean |one-step Δ| of the standardised | |
| # steer / gasPressed / brakePressed columns of Kx over the last 1 s; λ' = clamp(λ·2g, 1e-5, 1-1e-5) on the four driver-chain hazards | |
| # (models/heads.hazards_gated / driver_loss_gated; the pack's hz_on / hz_off are λ'). Run dir U0_cangate_s<k>_kcv2_clip8_ln (--out). | |
| kin_can_noK_clip8_ln_nocan: {cabin: none, lambda: {K: 0.0}, recipe: {kclip: 8, u_in_ln: true, u_nocan: true}} | |
| kin_can_noK_clip8_ln_cangate: {cabin: none, lambda: {K: 0.0}, recipe: {kclip: 8, u_in_ln: true, u_can_gate: true}} | |
| # --- R2 B1 driver variants --- (2026-09-16, WP4 batch 1 F3 — plan <local-notes>/plans/elegant-dazzling-stallman.md; pre-registration docs/decisions.md 2026-09-16T06:46:35Z): | |
| # `kin_can_noK_clip8_ln_face` = the FINAL U recipe (causal v2 inputs, stats v2, kclip 8, input LN, lambda K 0) + `u_face: true` ONLY (no gaze chain): the 9 causal | |
| # `lm_*` face-landmark channels of results/targets_face_causal_routes_v2 (incl. the landmark-quality channel ear_conf_asym and the state channels gaze_off / | |
| # gaze_off_dwell_s) + the per-step face valid bit appended to every GRU input step (train/batch.prep_U; invalid steps are 0 = train mean with valid = 0). | |
| # Masks: the per-step valid bit IS the missing mask; an 8 s validity-share channel is NOT added because (i) the data layer hands the U branch the last 4 s | |
| # (40 steps) of Fh8 only (cwm3_dataset.load_split `face`), so an 8 s share would need a data-layer change owned elsewhere, and (ii) the 4 s share is a linear | |
| # function of the valid-bit sequence the GRU already reads. Separates the face INPUT effect from the gaze-chain LOSS effect of `_gzfc` (whose rule passed). | |
| # Run dirs U0_kin_can_noK_face_s<k>_kcv2_clip8_ln (--out); joint fine-tunes I1_all_minus_road2drv_s<k>_final_face (FINAL argv, only --base-dir-u swapped). | |
| kin_can_noK_clip8_ln_face: {cabin: none, lambda: {K: 0.0}, recipe: {kclip: 8, u_in_ln: true, u_face: true}} | |
| # --- owner experiment C (2026-09-17; pre-registration docs/decisions.md 2026-09-17T07:00:22Z): Driver-WM-like architecture as the driver branch (main-text Table 3 row) --- | |
| # `kin_can_noK_clip8_ln_udwm` = the FINAL U recipe (causal v2 inputs, stats v2, kclip 8, input LN, lambda K 0; identical targets, batch, epochs, selection) with the GRU trunk | |
| # replaced by the Driver-WM temporal encoder of the AIDE port at its PUBLISHED width (models/u_driverwm.py: Linear tokeniser + step embedding -> one causal pre-norm | |
| # TransformerEncoderLayer(1024, 4 heads, d_ff 4096) -> last state -> residual MLP transition f_int (1024 -> 4096 -> 1024, one latent step) -> LN -> Linear(1024 -> 128) = h_u). | |
| # NOT parameter-matched (encoder ≈ 21.1 M vs GRU 56,832; stated in the table). Same Kx [B,40,18] input, same mode embedding / flat head (paired seed init); the joint model | |
| # reads it through encode_trunk / d_trunk (models/cwm3.py). Run dirs U0_kin_can_noK_s<k>_kcv2_clip8_ln_udwm (--out); joint I1_{indep,all_minus_road2drv}_s<k>_final_udwm = | |
| # the FINAL command line with ONLY --base-u / --base-dir-u swapped (train/queue_udwm_*.txt); pairings eval/run_joint_evals_final_udwm.sh; report eval/report_final_udwm.py. | |
| kin_can_noK_clip8_ln_udwm: {cabin: none, lambda: {K: 0.0}, recipe: {kclip: 8, u_in_ln: true}, arch: driverwm} | |
| experiment: "Exp1: reproduce cwm2 gru_kin_can onset PR-AUC@3s within +/-0.02 per event and regime; then +vc / +crop" | |
| E0: | |
| branch: E | |
| recipe: {batch: 1024, rows_per_epoch: 800000, max_epochs: 40, patience: 8, lr: 3.0e-4, weight_decay: 0.01, sched: warmcos, val_rows: all} | |
| lambda: {F: 0.1} | |
| model: {d: 128, n_layers: 2, n_heads: 4, d_ff: 256, hidden: 256, dropout: 0.1} | |
| variants: | |
| pooled: {tokens: pooled, n_slots: 16} # 1 PCA-256 clip-mean token per 0.5 s slot, 8 s | |
| tok4s: {tokens: region, n_slots: 8} # 4 region PCA-64 tokens per slot, 4 s | |
| tok8s: {tokens: region, n_slots: 16} # 4 region PCA-64 tokens per slot, 8 s | |
| spat256: {tokens: spat256, n_slots: 16} # the 4 region PCA-64 tokens of a slot FLATTENED into one 256-d token (spatial order kept), 8 s; added 2026-09-10 for the pack-v2 re-run (frozen-file rule lifted) | |
| # 2026-09-11 (follow-up agent, Exp3-v2b): `side` = the per-anchor side vector fed through LN -> Linear(d_side -> 128) -> GELU in place of vf256; | |
| # variant-level `recipe` keys MERGE into the stage recipe (train_cwm3.stage_cfg). Both variants: select_LF false (selection = sum of chain NLL, | |
| # F auxiliary), pack v2 (--pack-version v2), stats v2 (train/batch.STATS_VERSION). Run dirs E0_regionpca256_s<k>_rp256_v2 / E0_pooled_s<k>_v2s2. | |
| regionpca256: {tokens: pooled, n_slots: 16, side: regionpca256, recipe: {select_LF: false}} # pooled bank tokens -> same Transformer; side = regionpca256 [512] (results/pack_v2/regionpca256_*) | |
| pooled_lfoff: {tokens: pooled, n_slots: 16, recipe: {select_LF: false}} # = pooled under the new recipe (fair control for regionpca256; dir E0_pooled_s<k>_v2s2) | |
| # 2026-09-11 (coordinator, plan §3 road-pressure output): `p_head: true` adds a second flat head on the E trunk -> the six P chains (ttc, ttc_drop, | |
| # cut_in, lead_braking, lane_excursion, badas; results/targets_pressure, P0/Pvalid), loss weight lambda P = 1, D chains kept for the legacy | |
| # evaluators; selection = D + P chain NLL (select_LF false); pack v2, stats v2. Run dirs E0_pooled_P_s<k>_v2 / E0_regionpca256_P_s<k>_v2. | |
| pooled_P: {tokens: pooled, n_slots: 16, p_head: true, lambda: {F: 0.1, P: 1.0}, recipe: {select_LF: false}} | |
| regionpca256_P: {tokens: pooled, n_slots: 16, side: regionpca256, p_head: true, lambda: {F: 0.1, P: 1.0}, recipe: {select_LF: false}} | |
| # 2026-09-11 (innovation agent, roadmap §二 3 b2 — state-supervised E dynamics; models/identity.py FS_*): `f_state_sup: true` adds Linear(256 -> 10), shared | |
| # over the 5 horizons, on the F head output F_hat(t+k) -> P active bits (6, targets_pressure), R >= 1 / R >= 2 (targets_response), brake / gas pressed at | |
| # t+k (k = 1..5); masked BCE, weight lambda FS; selection unchanged (D + P chain NLL, select_LF false). pooled_P_fs keeps the F cosine (L_F 0.1, "in | |
| # addition"); pooled_P_fsonly drops it (L_F 0, "instead"). Base recipe = pooled_P (pack v2, stats v2). Run dirs E0_pooled_P_fs{,only}_s<k>_v2. | |
| pooled_P_fs: {tokens: pooled, n_slots: 16, p_head: true, lambda: {F: 0.1, P: 1.0, FS: 1.0}, recipe: {select_LF: false, f_state_sup: true}} | |
| pooled_P_fsonly: {tokens: pooled, n_slots: 16, p_head: true, lambda: {F: 0.0, P: 1.0, FS: 1.0}, recipe: {select_LF: false, f_state_sup: true}} | |
| # 2026-09-12 (GPU-baselines agent, experiment B): pooled_P with 1 / 4 causal-Transformer encoder layers (depth ablation; a variant-level `model` REPLACES the | |
| # stage model dict in train_cwm3.stage_cfg, so it is restated in full). Pack v2, stats v2, select_LF false. Run dirs E0_pooled_P_L{1,4}_s<k>_v2 (default naming). | |
| pooled_P_L1: {tokens: pooled, n_slots: 16, p_head: true, lambda: {F: 0.1, P: 1.0}, recipe: {select_LF: false}, model: {d: 128, n_layers: 1, n_heads: 4, d_ff: 256, hidden: 256, dropout: 0.1}} | |
| pooled_P_L4: {tokens: pooled, n_slots: 16, p_head: true, lambda: {F: 0.1, P: 1.0}, recipe: {select_LF: false}, model: {d: 128, n_layers: 4, n_heads: 4, d_ff: 256, hidden: 256, dropout: 0.1}} | |
| # --- R2 B2 road variants --- (2026-09-16, WP4 batch 1 F5b — plan <local-notes>/plans/elegant-dazzling-stallman.md; pre-registration docs/decisions.md 2026-09-16T06:46:35Z; road-side agent): | |
| # the FINAL E recipe (pooled_P: pack v2, stats v2, select_LF false, P head) + the CAN road margins as ANCHOR FEATURES through the side-vector path (d_side stays 256 -> | |
| # no model / joint-trainer code change; the joint trainer forwards `side` / `tokens` from the base config). Side streams by data/build_road_dynamics_targets.py | |
| # (results/targets_road_dyn/, exact list ECAN_NAMES): `vfcan256` = vf256 PCA components 0..215 + 40 standardised (train stats) CAN anchor features = the 10 current margins | |
| # M0 of targets_pressure (ttc_s, headway_s, dRel_m, vRel_mps, aLead_mps2, lat_margin_m, lane_width_m, badas, lead_valid, lane_valid) + 30 summaries of the 8 s CAN road | |
| # history (mean / slope / min / max of lead_dRel, lead_vRel, lead_vLead, lane_center_offset, vEgo; lane_width mean; lead / lane valid fractions; lead target switches; | |
| # minima of ttc / headway / lateral margin / lead acceleration; approaching and excursion fractions) — canspec whitelist columns only (+ badas_risk of the R block, exactly | |
| # as M0). `can256` = 216 zeros + the same 40 features. Run dirs E0_pooled_P_can_s<k>_v2 / E0_pooled_P_canonly_s<k>_v2 (default naming, --pack-version v2); joint | |
| # I1_all_minus_road2drv_s<k>_final_ecan / _ecanonly (+ indep) = the FINAL command line with only --base-e / --base-dir-e swapped (train/queue_r2_e*.txt). | |
| pooled_P_can: {tokens: pooled, n_slots: 16, side: vfcan256, p_head: true, lambda: {F: 0.1, P: 1.0}, recipe: {select_LF: false}} # F5b arm: sensor + vision | |
| pooled_P_canonly: {tokens: none, n_slots: 16, side: can256, p_head: true, lambda: {F: 0.1, P: 1.0}, recipe: {select_LF: false}} # F5b sensor-only control: NO vision tokens (train/batch.prep_E `tokens: none`), side = the 40 CAN features | |
| # post-hoc (2026-09-16, after the first E0 results; labelled sensitivity, NOT pre-registered): the EnvBranch applies LayerNorm over the 256-d side vector, so unit-sd CAN features sit ~6x lower | |
| # after that LN in vfcan256 (mixed with PCA components of sd 0.4-16) than in can256 (216 zeros). `pooled_P_cans` = pooled_P_can with the CAN block x4 (side stream vfcan256s) to separate | |
| # 'vision hurts' from 'CAN under-scaled'. Run dirs E0_pooled_P_cans_s<k>_v2; joint I1_*_final_ecans. | |
| pooled_P_cans: {tokens: pooled, n_slots: 16, side: vfcan256s, p_head: true, lambda: {F: 0.1, P: 1.0}, recipe: {select_LF: false}} # post-hoc scale arm: sensor x4 + vision | |
| experiment: "Exp3: pooled vs tok4s vs tok8s; six demand-family onset PR-AUC@3s vs current_signal_S0; F cosine" | |
Xet Storage Details
- Size:
- 18.5 kB
- Xet hash:
- 538993592b327c79e8c0b6bf7d04bdf49211e63ba02b94d325f763d8359a2d4c
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.