README: strip idea-revealing framing; load-only

README.md

@@ -1,32 +1,19 @@
-# Spatial-memory checkpoints (5 visual conditions)
+# spatial-memory-checkpoints
 
-Frozen post-training DD-PPO PointNav agents on Habitat for five visual sensor
-conditions on a shared ResNet-18 + 3-layer LSTM (512-d) backbone. Hidden
-state `h_2` (top LSTM layer) is the canonical 512-d cognitive-map readout.
+DD-PPO PointNav checkpoints (Habitat, GPS-PointGoal task), full training
+trajectory from initialisation to convergence.
 
-| folder              | encoder                                                | # ckpts | frames per ckpt | converged ckpt |
-| ------------------- | ------------------------------------------------------ | ------- | --------------- | -------------- |
-| `blind/`            | no visual encoder                                      | 35 (`0..34`) | 10.06 M         | `ckpt.34.pth` (~342 M frames) |
-| `coarse/`           | 48 x 48 RGB, 1 x 1 encoder feature map                 | 50 (`0..49`) | 5.0 M           | `ckpt.49.pth` (250 M frames)  |
-| `foveated/`         | 256 x 256 RGB, eccentricity Gaussian blur, 4 x 4 map   | 50 (`0..49`) | 5.0 M           | `ckpt.49.pth` (250 M frames)  |
-| `foveated_logpolar/`| 64 x 64 log-polar resampled, ~2 x 2 map                | 50 (`0..49`) | 5.0 M           | `ckpt.49.pth` (250 M frames)  |
-| `uniform/`          | 256 x 256 RGB, no blur, 4 x 4 map                      | 50 (`0..49`) | 5.0 M           | `ckpt.49.pth` (250 M frames)  |
+| folder               | # checkpoints | frames per checkpoint |
+| -------------------- | ------------- | --------------------- |
+| `blind/`             | 35 (`0..34`)  | 10.06 M               |
+| `coarse/`            | 50 (`0..49`)  |  5.0 M                |
+| `foveated/`          | 50 (`0..49`)  |  5.0 M                |
+| `foveated_logpolar/` | 50 (`0..49`)  |  5.0 M                |
+| `uniform/`           | 50 (`0..49`)  |  5.0 M                |
 
-The **full training trajectory** is included for every condition (one
-checkpoint per DD-PPO save event). Note that `frames per ckpt` differs
-across conditions, so to align across conditions at the same training-step
-anchor, convert ckpt index to absolute frame count first:
-
-```python
-FRAMES_PER_CKPT_M = {
-    "blind":             10.06,
-    "coarse":             5.0,
-    "foveated":           5.0,
-    "foveated_logpolar":  5.0,
-    "uniform":            5.0,
-}
-# blind ckpt.20 ~= coarse ckpt.40 (both ~200 M frames trained)
-```
+`frames per ckpt` differs across folders, so to align at the same training
+step, convert ckpt index to absolute frame count (`blind/ckpt.20.pth` ≈
+`coarse/ckpt.40.pth` ≈ 200 M frames).
 
 ## Load a checkpoint
 
@@ -34,30 +21,24 @@ FRAMES_PER_CKPT_M = {
 import torch
 from huggingface_hub import hf_hub_download
 
-cond = "foveated"          # or: blind | coarse | uniform | foveated_logpolar
 ckpt_path = hf_hub_download(
     repo_id="alunxu/spatial-memory-checkpoints",
-    filename=f"{cond}/ckpt.49.pth",
+    filename="foveated/ckpt.49.pth",
 )
-
 ckpt = torch.load(ckpt_path, map_location="cpu", weights_only=False)
-state_dict = ckpt["state_dict"]              # actor-critic policy weights
-config     = ckpt["config"]                  # habitat-baselines OmegaConf
+state_dict = ckpt["state_dict"]
+config     = ckpt["config"]
 ```
 
 Each `.pth` is a habitat-baselines checkpoint with keys `state_dict`,
-`config`, and `extra_state` (training step counters).
+`config`, and `extra_state`.
 
-## Rebuild the policy and read `h_2`
+## Rebuild the policy and run rollouts
 
 ```python
 from habitat_baselines.common.baseline_registry import baseline_registry
 
-# 1. Build the same env the policy was trained on (for obs/action spaces).
-env_config = config.habitat                  # already inside ckpt
-# ... construct the eval env from env_config (see code repo) ...
-
-# 2. Instantiate the policy class registered for this config and load weights.
+# Build env from ckpt's config (env_config = config.habitat).
 policy_cls = baseline_registry.get_policy(
     config.habitat_baselines.rl.policy.name)
 policy = policy_cls.from_config(
@@ -68,11 +49,9 @@ policy = policy_cls.from_config(
 policy.load_state_dict(state_dict)
 policy.eval()
 
-# 3. Run a rollout. The recurrent hidden state has shape
-#    (num_envs, num_layers=3, hidden=512). h_2 is the top layer:
-#       h_2 = recurrent_hidden_states[:, 2, :]
-#    Pass `recurrent_hidden_states` back into `policy.act(...)` each step.
+# policy.act(...) returns (action, recurrent_hidden_states) where
+# recurrent_hidden_states has shape (num_envs, num_layers, hidden_dim).
+# Pass it back at the next step to keep the recurrent state.
 ```
 
-Code, configs, and the deterministic-rollout probing pipeline that produced
-this release: <https://github.com/alunxu/foveated-cog-map>.
+Code: <https://github.com/alunxu/foveated-cog-map>.