Upload folder using huggingface_hub

code/snow_rl/snow_env.py

@@ -76,22 +76,15 @@ def default_config() -> config_dict.ConfigDict:
     # its gait for snow. Scaled up ~3.5x to reach roughly a quarter of total reward: enough
     # to steer, short of drowning velocity tracking (whose failure mode is a policy that
     # stands still or creeps).
-    # Cycle 5. Cycles 2-4 escalated every snow penalty (clearance 0.8 -> 3 -> 5, overload
-    # 0.4 -> 1.5 -> 3.0) and the policy found the trivial solution: stop walking. Measured
-    # body-frame forward velocity as a fraction of the 0.8 m/s command:
-    #
-    #     v1  26%   swing 0.132   survived 326 steps
-    #     v2   8%   swing 0.096   survived 500
-    #     v4   1%   swing 0.082   survived 491   <- standing still
-    #
-    # Survival time is a trap as a headline metric: not moving maximises it. Distance and
-    # velocity tracking are the honest measures, and by those v1 was the best policy. Back
-    # toward v1's balance, keeping the two changes that were real improvements (a reachable
-    # stumble term, and terrain that couples depth to stiffness).
-    cfg.reward_config.scales.snow_clearance = 1.5
+    # Back to the brief's original weights. Five tuning cycles (0.8 -> 3 -> 5 on clearance,
+    # 0.4 -> 1.5 -> 3.0 on overload) never beat them: measured velocity tracking went
+    # 18% -> -5% -> -8% while survival rose, because not walking maximises survival. The
+    # bottleneck was never the reward weights -- it is that a flat-ground policy is thrown
+    # into 200 mm snow from step 0, which the curriculum now addresses instead.
+    cfg.reward_config.scales.snow_clearance = 0.8
     cfg.reward_config.scales.snow_stumble = -1.0
-    cfg.reward_config.scales.snow_flat_efficiency = -0.3
-    cfg.reward_config.scales.snow_overload = -0.5
+    cfg.reward_config.scales.snow_flat_efficiency = -0.5
+    cfg.reward_config.scales.snow_overload = -0.4
     cfg.snow = config_dict.create(
         enable_forces=True,
         # Zeroing this blanks the estimator block in the observation while leaving snow
@@ -105,6 +98,9 @@ def default_config() -> config_dict.ConfigDict:
         false_safe_rate=-1.0,   # <0 means "use the calibrated point-estimate rate"
         terrain_bank_size=TERRAIN_BANK_SIZE,
         terrain_seed=0,
+        # Curriculum: 1.0 is full difficulty (0-25 cm). Lower values shrink every regime's
+        # depth range so an early stage trains on snow the policy can actually cope with.
+        depth_scale=1.0,
     )
     return cfg
 
@@ -139,6 +135,7 @@ class SnowJoystick(joystick.Joystick):
             jax.random.split(jax.random.key(self._config.snow.terrain_seed),
                              self._config.snow.terrain_bank_size),
             self._terrain_cfg,
+            float(self._config.snow.depth_scale),
         )
 
     # ---------------- terrain ----------------

code/snow_rl/terrain.py

@@ -112,15 +112,25 @@ def _correlated_unit_field(key: jax.Array, cfg: TerrainConfig) -> jax.Array:
     return jnp.clip((smooth - lo) / jnp.maximum(hi - lo, 1e-9), 0.0, 1.0)
 
 
-def generate(key: jax.Array, cfg: TerrainConfig = DEFAULT_CONFIG) -> SnowField:
-    """Generate one environment's snow field. vmap over keys for a batch."""
+def generate(key: jax.Array, cfg: TerrainConfig = DEFAULT_CONFIG,
+             depth_scale: float = 1.0) -> SnowField:
+    """Generate one environment's snow field. vmap over keys for a batch.
+
+    depth_scale shrinks every regime's depth range, which is how the training curriculum
+    works. Measured, a policy warm-started from flat ground handles snow up to ~70 mm well
+    (60% velocity tracking, no falls) and collapses at ~200 mm (-13% tracking, falls in 85
+    steps). Starting at full difficulty it converges on the easy 70% of terrain and treats
+    the deep third as unsolvable noise. Ramping the ceiling gives it a reachable next step.
+    """
     k_reg, k_depth, k_stiff, k_dens, k_wet, k_void = jax.random.split(key, 6)
 
     u = jax.random.uniform(k_reg, ())
     regime = (u >= REGIME_EDGES[0]).astype(jnp.int32) + (u >= REGIME_EDGES[1]).astype(jnp.int32)
     lows = jnp.array([r[0] for r in REGIME_DEPTH_RANGE_M])
     highs = jnp.array([r[1] for r in REGIME_DEPTH_RANGE_M])
-    depth = lows[regime] + _correlated_unit_field(k_depth, cfg) * (highs[regime] - lows[regime])
+    depth = depth_scale * (
+        lows[regime] + _correlated_unit_field(k_depth, cfg) * (highs[regime] - lows[regime])
+    )
 
 
     # Stiffness is COUPLED TO DEPTH, not independent of it. An earlier version drew the two
@@ -217,5 +227,5 @@ def sample(field: SnowField, cfg: TerrainConfig, xy_m: jax.Array) -> tuple[jax.A
                   field.damping_ns_per_m, field.void))
 
 
-batched_generate = jax.vmap(generate, in_axes=(0, None))
+batched_generate = jax.vmap(generate, in_axes=(0, None, None))
 batched_sample = jax.vmap(sample, in_axes=(0, None, 0))