Add Longest6v1 eval and Alpasim eval. Reduce overspeed reward to similar magnitude as comfort,

README.md

@@ -266,7 +266,7 @@ To add a metric to the report: add its key to `TREND_METRICS` /
 | `reward_vel_align` | `1.0` | Speed matching road limit |
 | `reward_lane_center` | `0.0038` | Lane centering |
 | `reward_stop_line` | `1.0` | Stop line penalty |
-| `reward_overspeed` | `0.05` | Speeding penalty |
+| `reward_overspeed` | `0.005` | Speeding penalty |
 
 ### `train` — PPO
 

data_utils/datasets.yaml

@@ -62,3 +62,15 @@ nuplan_val:
     CC BY-NC-SA 4.0 (nuPlan, Motional) — non-commercial use only, attribution
     required, share-alike. Redistribute only under this same license and keep
     this notice with any copy.
+
+carla_128_affine_zones_stop:
+  s3_uri: s3://pufferdrive-bins/carla/0.3.2/128_affine_zones_stop/
+  size: ~106 MB, 128 bins
+  public: true
+  description: >-
+    CARLA Towns 01-07/10HD as PufferDrive bins with 16 affine augmentations
+    each (flips, shears, scales), per-lane speed zones, stop signs and the
+    0.1 polyline tolerance (123Drive mapforge at v0.3.2-19). The training set
+    behind the k_scaled_004x runs.
+  license: >-
+    CARLA assets are CC BY 4.0 — attribution required.

notebooks/01_observations.py

@@ -69,6 +69,8 @@
     obs_slots_traffic_controls_n=env.obs_slots_traffic_controls_n,
     obs_dropout_lane=env.obs_dropout_lane,
     obs_dropout_boundary=env.obs_dropout_boundary,
+    obs_partner_relative_velocity=env.obs_partner_relative_velocity,
+    obs_lane_speed_limit=env.obs_lane_speed_limit,
 )
 print(f"ego: {ego.shape} = {ego}")
 print(f"target: {target.shape}")
@@ -283,6 +285,8 @@
     obs_slots_traffic_controls_n=env.obs_slots_traffic_controls_n,
     obs_dropout_lane=env.obs_dropout_lane,
     obs_dropout_boundary=env.obs_dropout_boundary,
+    obs_partner_relative_velocity=env.obs_partner_relative_velocity,
+    obs_lane_speed_limit=env.obs_lane_speed_limit,
     obs_lane_stride=env.obs_lane_stride,
     obs_boundary_stride=env.obs_boundary_stride,
     obs_goal_lane_distance=env.obs_goal_lane_distance,

notebooks/05_inference.py

@@ -205,6 +205,8 @@ def run_rollout(env, policy, action_selection=ACTION_SELECT_SAMPLE, horizon=HORI
     obs_slots_boundary_n=env.obs_slots_boundary_n,
     obs_dropout_lane=env.obs_dropout_lane,
     obs_dropout_boundary=env.obs_dropout_boundary,
+    obs_partner_relative_velocity=env.obs_partner_relative_velocity,
+    obs_lane_speed_limit=env.obs_lane_speed_limit,
     obs_lane_stride=env.obs_lane_stride,
     obs_boundary_stride=env.obs_boundary_stride,
     obs_slots_traffic_controls_n=env.obs_slots_traffic_controls_n,
@@ -241,6 +243,8 @@ def run_rollout(env, policy, action_selection=ACTION_SELECT_SAMPLE, horizon=HORI
         obs_slots_boundary_n=env.obs_slots_boundary_n,
         obs_dropout_lane=env.obs_dropout_lane,
         obs_dropout_boundary=env.obs_dropout_boundary,
+        obs_partner_relative_velocity=env.obs_partner_relative_velocity,
+        obs_lane_speed_limit=env.obs_lane_speed_limit,
         obs_slots_traffic_controls_n=env.obs_slots_traffic_controls_n,
     )
     ego_features_over_time.append(ego)
@@ -290,6 +294,8 @@ def run_rollout(env, policy, action_selection=ACTION_SELECT_SAMPLE, horizon=HORI
     obs_slots_boundary_n=env.obs_slots_boundary_n,
     obs_dropout_lane=env.obs_dropout_lane,
     obs_dropout_boundary=env.obs_dropout_boundary,
+    obs_partner_relative_velocity=env.obs_partner_relative_velocity,
+    obs_lane_speed_limit=env.obs_lane_speed_limit,
     obs_slots_traffic_controls_n=env.obs_slots_traffic_controls_n,
 )
 
@@ -364,6 +370,8 @@ def layer_stats(name, arr):
     "sim_speed_signed",
     "seconds_stopped",
 ]
+if env.obs_partner_relative_velocity:
+    partner_labels += ["rel_vx", "rel_vy"]
 for p in range(min(int(n_visible), 5)):
     vals = ", ".join(f"{partner_labels[j]}={partners[p, j]:.3f}" for j in range(env.partner_features))
     print(f"  [{p}] {vals}")
@@ -477,6 +485,8 @@ def unpack_all_timesteps(bufs, agent_idx):
             obs_slots_boundary_n=env.obs_slots_boundary_n,
             obs_dropout_lane=env.obs_dropout_lane,
             obs_dropout_boundary=env.obs_dropout_boundary,
+            obs_partner_relative_velocity=env.obs_partner_relative_velocity,
+            obs_lane_speed_limit=env.obs_lane_speed_limit,
             obs_slots_traffic_controls_n=env.obs_slots_traffic_controls_n,
         )
         egos.append(ego)
@@ -554,6 +564,8 @@ def unpack_all_timesteps(bufs, agent_idx):
         obs_slots_boundary_n=env.obs_slots_boundary_n,
         obs_dropout_lane=env.obs_dropout_lane,
         obs_dropout_boundary=env.obs_dropout_boundary,
+        obs_partner_relative_velocity=env.obs_partner_relative_velocity,
+        obs_lane_speed_limit=env.obs_lane_speed_limit,
         obs_slots_traffic_controls_n=env.obs_slots_traffic_controls_n,
     )
     dists = np.sqrt(part[:, 0] ** 2 + part[:, 1] ** 2)
@@ -581,6 +593,8 @@ def unpack_all_timesteps(bufs, agent_idx):
     obs_slots_boundary_n=env.obs_slots_boundary_n,
     obs_dropout_lane=env.obs_dropout_lane,
     obs_dropout_boundary=env.obs_dropout_boundary,
+    obs_partner_relative_velocity=env.obs_partner_relative_velocity,
+    obs_lane_speed_limit=env.obs_lane_speed_limit,
     obs_slots_traffic_controls_n=env.obs_slots_traffic_controls_n,
 )
 
@@ -644,7 +658,7 @@ def unpack_all_timesteps(bufs, agent_idx):
 for i in range(partners.shape[0]):
     if np.allclose(partners[i], 0):
         continue
-    rx, ry, rz, length, width, hc, hs, speed, _ = partners[i]
+    rx, ry, rz, length, width, hc, hs, speed = partners[i][:8]
     heading = np.arctan2(hs, hc)
     rect = Rectangle(
         (-length / 2, -width / 2), length, width, facecolor="orange", edgecolor="black", alpha=0.6, zorder=9
@@ -791,6 +805,8 @@ def unpack_all_timesteps(bufs, agent_idx):
     "sim_speed_signed",
     "seconds_stopped",
 ]
+if env.obs_partner_relative_velocity:
+    partner_labels += ["rel_vx", "rel_vy"]
 obs_slots_partners_n = env.obs_slots_partners_n
 pf = env.partner_features
 

pufferlib/config/evaluation/benchmark.yaml

@@ -12,7 +12,7 @@ env:
   reward_stop_line: 1.0
   reward_ade: 0.0
   reward_goal: 1.0
-  reward_overspeed: 0.05
+  reward_overspeed: 0.1  # training-range max (REWARD_BOUNDS)
   reward_comfort: 0.05
   reward_velocity: 0.0025
   reward_lane_align: 0.025
@@ -28,7 +28,9 @@ env:
   obs_dropout_lane: 0.0
   obs_dropout_boundary: 0.0
   partner_blindness_prob: 0.0
+  partner_blindness_prob_min: 0.0
   partner_blindness_trigger_prob: 0.0
+  partner_blindness_time_fraction_max: 0.0
   phantom_braking_prob: 0.0
   phantom_braking_trigger_prob: 0.0
   use_neighbor_cache: true

pufferlib/config/puffer_drive.yaml

@@ -57,19 +57,19 @@ env:
   # Speed cap when reward_randomization is off (eval); null = base_max_speed_mps. Sets C_vel = max_speed_mps / base_max_speed_mps (training range [1/a, a] below)
   max_speed_mps: null
   # Training C_vel ~ X(a) = 0.5 U(1/a, 1) + 0.5 U(1, a): speed cap = base_max_speed_mps * [1/a, a]; 1.5 = paper (13.3-30 m/s), 2.0 = 10-40 m/s
-  conditioning_speed_scale: 1.5
+  conditioning_speed_scale: 2.0
   # Optional nonzero launch speed for gigaflow random spawns
   spawn_initial_speed: 0.0
   # Gigaflow spawn pose noise: lateral offset as a fraction of half the lane width, heading offset in degrees
   spawn_lateral_offset_max_frac: 1.0
   spawn_heading_max_deg: 30.0
   # Gigaflow dynamics randomization: per-step brownian pose buffeting (std in meters / degrees); 0 disables
-  pose_noise_xy_m: 0.0
-  pose_noise_yaw_deg: 0.0
+  pose_noise_xy_m: 0.025
+  pose_noise_yaw_deg: 0.25
   # Speed-limit randomization (needs SPDZONE1 maps): per episode, with this probability every speed zone shifts its
   # posted limit by one uniform offset in +-delta, clipped to [min, max]; junction lanes inherit the min over entries.
   # m/s: 9.72 = 35 km/h, 1.39 = 5 km/h, 36.11 = 130 km/h. 0 disables.
-  speed_limit_random_prob: 0.0
+  speed_limit_random_prob: 1.0
   speed_limit_random_delta_mps: 9.72
   speed_limit_random_min_mps: 1.39
   speed_limit_random_max_mps: 36.11
@@ -83,7 +83,7 @@ env:
   stop_sign_behavior: stop
   # Traffic controls observed and enforced; stop-sign runs are detected as in CaRL's RunStopSign2 (reward_stop_line)
   traffic_lights_enabled: true
-  stop_signs_enabled: false
+  stop_signs_enabled: true
   yield_signs_enabled: false
   # Skip red light violation detection (metrics, reward, behavior)
   disable_red_light_infractions: false
@@ -94,13 +94,13 @@ env:
   # Share static map geometry (roads/grid/lane-graph) across envs using the same map
   use_map_cache: true
   # Load all configured maps before fork so workers inherit shared geometry
-  preload_map_cache: false
+  preload_map_cache: true
   # Precompute neighboring road entities for observation queries
   use_neighbor_cache: true
   # Number of steps before reset; keep it off multiples of train.bptt_horizon so episode ends don't all land on the unused last buffer slot
-  scenario_length: 2500
+  scenario_length: 1200
   # Frequency of resampling scenario (in steps), 0 to disable
-  resample_frequency: 256000
+  resample_frequency: 0
   # End the episode early when too many agents are inactive; otherwise use scenario_length
   termination_mode: true
   # Ratio of inactive agents (stopped/removed) that triggers early reset
@@ -152,9 +152,9 @@ env:
   # Maximum speed at final waypoint to count goal reward
   goal_speed: 3.0
   # true: goal-speed coef ~ U(0, 20) per agent under reward_randomization; false: pinned to goal_speed (GIGAFLOW v_goal = 3)
-  goal_speed_randomization: true
+  goal_speed_randomization: false
   # true: the final goal is only consumed below goal speed (GIGAFLOW R_goal); false: consumed on entry, reward gated
-  goal_reach_requires_speed: false
+  goal_reach_requires_speed: true
   # Number of target waypoints in the observation (including goal)
   num_goals: 3
   # Waypoint spacing range in meters when building path
@@ -179,7 +179,7 @@ env:
   reward_velocity: 0.0025
   reward_reverse: 0.005
   reward_timestep: 2.5e-05
-  reward_overspeed: 0.05
+  reward_overspeed: 0.005
   # m/s above the lane limit before the overspeed penalty fires
   overspeed_tolerance_mps: 0.0
   reward_ade: 0.0
@@ -195,18 +195,20 @@ env:
   obs_slots_boundary_n: 50
   obs_slots_partners_n: 20
   # Append the partner's velocity relative to ego (ego frame, 2 floats) to every partner row (GIGAFLOW observes velocity)
-  obs_partner_relative_velocity: false
+  obs_partner_relative_velocity: true
   # Ego lane-angle slot: true = signed heading error theta_f / pi (GIGAFLOW B.1), false = cos(theta_f)
-  obs_lane_heading_signed: false
+  obs_lane_heading_signed: true
   # Append each lane segment's speed limit (/ obs_norm_speed_mps) to its lane row so limit changes ahead are visible
-  obs_lane_speed_limit: false
+  obs_lane_speed_limit: true
   obs_slots_traffic_controls_n: 4
   # Fraction of segment observation slots to drop (reduces obs size)
   obs_dropout_lane: 0.5
   obs_dropout_boundary: 0.4
   # Stride for lane and boundary segments; 1 means use every segment, 2 means use every other segment, etc.
   obs_lane_stride: 2
   obs_boundary_stride: 1
+  # true: strided-out segments merge into one chord so polylines stay connected; false = pre-2026-10-12 gaps
+  obs_stride_merge_segments: true
   # --- Observation normalization ---
   obs_norm_speed_mps: 60.0
   # num_goals * max_goal_spacing; goals beyond this collapse to a unit direction vector
@@ -219,6 +221,8 @@ env:
   obs_norm_z_m: 10.0
   # --- Eval-only ---
   eval_perceived_size_margin_m: 0.1
+  # Eval-only: partners longer than this (m) are observed as ceil(length / this) touching pieces (training max 7.0). 0 disables.
+  obs_partner_split_length_m: 0.0
   # Eval-only: while standing exactly still, |longitudinal jerk| below this (m/s^3) is zeroed
   # so leftover mean-action jerk cannot creep the car. 0 disables.
   eval_standstill_jerk_deadband_mps3: 0.0
@@ -230,12 +234,18 @@ env:
   obs_range_traffic_control_m: 200.0
   # --- Robustness features---
   # Erratic agents are selected once per episode; masked out of the PPO rollout buffer.
-  # Upper bound of the per-episode blind-agent rate; each episode draws its rate uniformly from [0, this]
+  # Upper bound of the per-episode blind-agent rate; each episode draws its rate uniformly from [partner_blindness_prob_min, this]
   partner_blindness_prob: 0.05
-  # Per-step probability that a flagged blind-partner agent zeros out its partner observations
-  partner_blindness_trigger_prob: 0.03
+  # Lower bound of the per-episode blind-agent rate
+  partner_blindness_prob_min: 0.05
+  # Per-step probability that a flagged blind-partner agent restricts its partner observations
+  partner_blindness_trigger_prob: 1.0
   # Duration in seconds of partner blindness once triggered
   partner_blindness_duration_seconds: 3.0
+  # Blind agents keep the partners in their forward corridor (false: they see no partners at all, pre-2026-10-12 rule)
+  partner_blindness_corridor: false
+  # 0 disables; else each blind agent draws its share of time spent blind uniformly from [share set by trigger prob and duration, this]; 1.0 = blind every step
+  partner_blindness_time_fraction_max: 0.0
   # Upper bound of the per-episode phantom-braker rate; each episode draws its rate uniformly from [0, this]
   phantom_braking_prob: 0.1
   # Per-step probability that a flagged phantom-braker actually initiates a brake window
@@ -255,7 +265,7 @@ policy:
   # Encoder activation - options: "relu", "tanh", "gelu"
   encoder_activation: relu
   encoder_layer_norm: true
-  mask_padded_features: false
+  mask_padded_features: true
   # Shared backbone layer
   backbone_hidden_size: 1024
   backbone_num_layers: 3
@@ -271,7 +281,9 @@ policy:
   critic_num_layers: 1
   critic_head_layer_norm: false
   # Run the actor/critic heads in float32 under bf16 autocast (backbone stays bf16)
-  fp32_heads: false
+  fp32_heads: true
+  # Fused Triton kernels for the per-slot encoders and their max-pool (same bf16 math, fewer activation bytes)
+  fused_slot_encoder: true
   # Dual or shared actor-critic backbone
   shared_network: false
   action_type: discrete
@@ -297,7 +309,7 @@ train:
   anneal_lr: true
   precision: bfloat16
   # false: pure float32 matmuls/convs (no TensorFloat-32); requires precision float32
-  tf32: true
+  tf32: false
   rollout_dtype: float32
   total_timesteps: 500000000000
   learning_rate: 0.0005
@@ -333,7 +345,7 @@ train:
   # Accumulate gradients above this size
   max_minibatch_size: 65536
   bptt_horizon: 128
-  compile: false
+  compile: true
   compile_mode: default
   compile_fullgraph: false
   vtrace_rho_clip: 1
@@ -349,6 +361,10 @@ train:
   # Rendering options
   render: false
   render_interval: 1000
+  # Training maps per render pass, a seeded random subset; null renders every map
+  render_num_maps: null
+  # Stop after this many epochs in this process (debug/render runs); null runs to total_timesteps
+  stop_after_epochs: null
 sweep:
   method: Protein
   metric: score

pufferlib/config_schema.py

@@ -336,6 +336,7 @@ class DriveEnvConfig:
     obs_dropout_boundary: float = _constrained_field(PROBABILITY_CONSTRAINT)
     obs_lane_stride: int = _constrained_field(POSITIVE_INT_CONSTRAINT)
     obs_boundary_stride: int = _constrained_field(POSITIVE_INT_CONSTRAINT)
+    obs_stride_merge_segments: bool = MISSING
     obs_norm_speed_mps: float = _constrained_field(POSITIVE_NUMBER_CONSTRAINT)
     obs_norm_goal_offset_m: float = _constrained_field(POSITIVE_NUMBER_CONSTRAINT)
     obs_norm_xy_offset_m: float = _constrained_field(POSITIVE_NUMBER_CONSTRAINT)
@@ -345,15 +346,19 @@ class DriveEnvConfig:
     obs_norm_road_seg_width_m: float = _constrained_field(POSITIVE_NUMBER_CONSTRAINT)
     obs_norm_z_m: float = _constrained_field(POSITIVE_NUMBER_CONSTRAINT)
     eval_perceived_size_margin_m: float = _constrained_field(NONNEGATIVE_NUMBER_CONSTRAINT)
+    obs_partner_split_length_m: float = _constrained_field(NONNEGATIVE_NUMBER_CONSTRAINT)
     eval_standstill_jerk_deadband_mps3: float = _constrained_field(NONNEGATIVE_NUMBER_CONSTRAINT)
     obs_range_road_front_m: float = _constrained_field(POSITIVE_NUMBER_CONSTRAINT)
     obs_range_road_behind_m: float = _constrained_field(POSITIVE_NUMBER_CONSTRAINT)
     obs_range_road_side_m: float = _constrained_field(POSITIVE_NUMBER_CONSTRAINT)
     obs_range_partner_m: float = _constrained_field(POSITIVE_NUMBER_CONSTRAINT)
     obs_range_traffic_control_m: float = _constrained_field(POSITIVE_NUMBER_CONSTRAINT)
     partner_blindness_prob: float = _constrained_field(PROBABILITY_CONSTRAINT)
+    partner_blindness_prob_min: float = _constrained_field(PROBABILITY_CONSTRAINT)
     partner_blindness_trigger_prob: float = _constrained_field(PROBABILITY_CONSTRAINT)
     partner_blindness_duration_seconds: float = _constrained_field(POSITIVE_NUMBER_CONSTRAINT)
+    partner_blindness_corridor: bool = MISSING
+    partner_blindness_time_fraction_max: float = _constrained_field(PROBABILITY_CONSTRAINT)
     phantom_braking_prob: float = _constrained_field(PROBABILITY_CONSTRAINT)
     phantom_braking_trigger_prob: float = _constrained_field(PROBABILITY_CONSTRAINT)
     phantom_braking_duration_seconds: float = _constrained_field(POSITIVE_NUMBER_CONSTRAINT)
@@ -386,6 +391,7 @@ class DrivePolicyConfig:
     critic_num_layers: int = _constrained_field(NONNEGATIVE_INT_CONSTRAINT)
     critic_head_layer_norm: bool = MISSING
     fp32_heads: bool = MISSING
+    fused_slot_encoder: bool = False
     shared_network: bool = MISSING
     action_type: ActionType = MISSING
 
@@ -414,7 +420,7 @@ class TrainingConfig:
     tf32: bool = MISSING
     rollout_dtype: RolloutDtype = MISSING
     total_timesteps: int = _constrained_field(POSITIVE_INT_CONSTRAINT)
-    learning_rate: float = _constrained_field(POSITIVE_NUMBER_CONSTRAINT)
+    learning_rate: float = _constrained_field(NONNEGATIVE_NUMBER_CONSTRAINT)
     gamma: float = _constrained_field(PROBABILITY_CONSTRAINT)
     gae_lambda: float = _constrained_field(PROBABILITY_CONSTRAINT)
     update_epochs: int = _constrained_field(POSITIVE_INT_CONSTRAINT)
@@ -454,6 +460,8 @@ class TrainingConfig:
     adv_filter_leak_fraction: float = _constrained_field(PROBABILITY_CONSTRAINT)
     render: bool = MISSING
     render_interval: int = _constrained_field(POSITIVE_INT_CONSTRAINT)
+    render_num_maps: int | None = _constrained_field(POSITIVE_INT_CONSTRAINT)
+    stop_after_epochs: int | None = _constrained_field(POSITIVE_INT_CONSTRAINT)
     # Derived by load_config from rnn_name and intentionally absent from YAML.
     use_rnn: bool = MISSING
 
@@ -610,6 +618,8 @@ def _validate_cross_field_constraints(config, context):
         _raise_config_error(context, "env.spawn_initial_speed", "must not exceed env.base_max_speed_mps")
     if env["min_goal_spacing"] > env["max_goal_spacing"]:
         _raise_config_error(context, "env.min_goal_spacing", "must not exceed env.max_goal_spacing")
+    if env["partner_blindness_prob_min"] > env["partner_blindness_prob"]:
+        _raise_config_error(context, "env.partner_blindness_prob_min", "must not exceed env.partner_blindness_prob")
     if env["preload_map_cache"] and not env["use_map_cache"]:
         _raise_config_error(context, "env.preload_map_cache", "requires env.use_map_cache to be true")
 
@@ -672,6 +682,8 @@ def _validate_cross_field_constraints(config, context):
         not isinstance(evaluation_benchmarks, str) or not evaluation_benchmarks.strip()
     ):
         _raise_config_error(context, "train.evaluation_benchmarks", "must be a non-empty string")
+    if train["render_num_maps"] is not None and train["render_num_maps"] > config["env"]["num_maps"]:
+        _raise_config_error(context, "train.render_num_maps", "must not exceed env.num_maps")
     if not context.startswith("evaluation") and context != "simulation profiling":
         for field_name in ("batch_size", "bptt_horizon"):
             if train[field_name] != "auto":