Update FlowMo-WM code and static flow protocol

.gitattributes

@@ -259,3 +259,6 @@ experiments/reports/paper_planning/gifs/image_planning_flowmo_inferred_triangle_
 experiments/reports/paper_planning/gifs/image_planning_tdmpc2_inferred_triangle_passive_to_active_ep000.gif filter=lfs diff=lfs merge=lfs -text
 experiments/reports/paper_planning/gifs/image_planning_pid_los_controller_inferred_triangle_reach_uniform_ep000.gif filter=lfs diff=lfs merge=lfs -text
 experiments/reports/paper_planning/gifs/image_planning_tdmpc2_inferred_triangle_counterflow_ep002.gif filter=lfs diff=lfs merge=lfs -text
+experiments/reports/figures/flow_family_atlas.png filter=lfs diff=lfs merge=lfs -text
+experiments/reports/figures/flow_family_panels/clean/random_fourier.png filter=lfs diff=lfs merge=lfs -text
+experiments/reports/figures/flow_family_panels/labeled/random_fourier.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,36 @@
+__pycache__/
+*.pyc
+.pytest_cache/
+
+# Legacy and generated experiment artifacts
+outputs/
+logs/
+external/
+configs/
+scripts/
+docs/
+
+# Large generated datasets and image caches
+data/*.npz
+!data/paper/
+!data/paper/*.npz
+experiments/shared/result/image_cache*/
+experiments/shared/result/image_observation_sweep/
+experiments/shared/result/image_scale_sweep/
+
+# Checkpoints are generated by smoke and full training runs
+experiments/*/checkpoint/*.pt
+experiments/*/result/*.json
+experiments/*/result/*.jsonl
+
+# Per-run planning GIF/JSON outputs are regenerated by the pipeline
+experiments/reports/image_paper_160_v2p5_planning/
+experiments/reports/image_paper_160_v2p5_planning_smoke/
+experiments/reports/*.json
+experiments/reports/*.md
+!experiments/reports/README.md
+experiments/gifs/*.gif
+experiments/figures/*.png
+experiments/figures/*.pdf
+experiments/tables/*.md
+!experiments/tables/README.md

.hfignore

@@ -8,6 +8,21 @@ outputs/
 external/
 flowmo_remote_outputs/
 
+data/*.npz
+data/paper/*.npz
+experiments/*/checkpoint/*.pt
+experiments/*/result/*.json
+experiments/*/result/*.jsonl
+experiments/reports/*.json
+experiments/reports/*.md
+!experiments/reports/README.md
+experiments/reports/paper_planning/
+experiments/gifs/*.gif
+experiments/figures/*.png
+experiments/figures/*.pdf
+experiments/tables/*.md
+!experiments/tables/README.md
+
 experiments/shared/result/image_cache*/
 experiments/shared/result/image_observation_sweep/
 experiments/shared/result/image_scale_sweep/

README.md

@@ -13,7 +13,7 @@ tags:
 
 FlowMo is a clean-image world-model benchmark for surface vehicles under hidden water drift. The proposed model separates short-history endogenous state and momentum from long-history exogenous drift context, then evaluates whether that factorization improves rollout prediction and closed-loop planning.
 
-This repository currently contains the public code, tests, configuration, and canonical paper datasets. Official checkpoints, generated GIFs, tables, and full experiment reports will be uploaded after the paper-scale training and evaluation runs finish.
+This repository contains the public code, tests, configuration, canonical paper datasets, checkpoints, generated GIFs, tables, and experiment reports.
 
 ## Paper Pipeline
 
@@ -26,15 +26,14 @@ python -m experiments.run_paper_image_pipeline
 The default command trains all learned world models, evaluates prediction, runs FlowMo latent probes, evaluates planning on all configured tasks and boat morphologies, generates GIFs, and writes:
 
 ```text
-experiments/reports/paper_prediction_seen_flow_diagnostic.json
-experiments/reports/paper_prediction_unseen_flow.json
-experiments/reports/paper_prediction_unseen_boat_params.json
+experiments/reports/paper_prediction.json
 experiments/reports/paper_flowmo_latent_probes.json
 experiments/reports/paper_planning/
 experiments/reports/paper_report.md
 ```
 
 Images are rendered online from simulator states. Model inputs are clean top-down RGB frames with no flow arrows, no goal markers, no velocity vectors, and no trajectory overlays.
+The train split, test split, and final planning evaluation use the same paper flow-family set.
 
 ## Compared Methods
 

data/paper/dataset_card.md

@@ -9,39 +9,58 @@ suffixes; when the dataset is regenerated, these files are replaced in place.
 | File | Role |
 | --- | --- |
 | `train.npz` | Training split shared by all learned world models. |
-| `test_unseen_flow.npz` | Primary split with unseen flow families. |
-| `test_unseen_boat_params.npz` | Primary split with unseen boat dynamics. |
-| `diagnostic_seen_flow.npz` | Seen-flow-family diagnostic split used only for optimization sanity checks. |
+| `test.npz` | Evaluation split shared by prediction, probes, and downstream planning protocol design. |
 
 ## Sizes
 
 | File | Episodes | Steps per episode |
 | --- | ---: | ---: |
 | `train.npz` | 2400 | 300 |
-| `diagnostic_seen_flow.npz` | 480 | 300 |
-| `test_unseen_flow.npz` | 480 | 300 |
-| `test_unseen_boat_params.npz` | 480 | 300 |
+| `test.npz` | 480 | 300 |
 
 ## Stored Arrays
 
 Each `.npz` stores low-dimensional simulator state and metadata. Image-input
 models receive clean rendered images generated online from the same states.
 The image observation contains only the boat and clean workspace; flow vectors,
-velocity arrows, and visualization overlays are not part of the model input.
+velocity arrows, goal markers, and visualization overlays are not part of the
+model input.
 
 All learned world models use the same split files, the same window sampling
 rules, the same image renderer, and the same train/evaluation budgets.
 
 ## Flow Families
 
-The training split and seen-flow-family diagnostic split use `noflow`, `uniform`,
-`slowly_varying`, `vortex_center`, `gradient`, and `turbulent_patch` flows.
-The unseen-flow split uses `noflow`, `shear`, `moving_vortex`, and
-`random_fourier` flows. The unseen-boat-dynamics split uses the training flow
-families with held-out boat mass, drag, inertia, and actuator-delay ranges.
+The train split, test split, and final planning evaluation use the same paper
+flow-family set:
 
-All splits use the fixed paper flow-strength constants in `driftwm/sim/flow.py`,
-both boat morphologies, and clean image observations without flow overlays.
+```text
+noflow
+uniform
+vortex_center
+double_gyre
+source_sink
+source_sink_pair
+gradient
+shear
+turbulent_patch
+random_fourier
+```
+
+The test split uses independently sampled episodes and hidden flow conditions,
+but the paper reports a single flow-regime evaluation rather than separate
+flow-family categories.
 `flow_pool_size=80` means that each nonzero flow family is represented by 80
 hidden flow conditions before trajectories are sampled; it is a dataset
 diversity constant, not a model input or experiment mode.
+
+`uniform` is spatially constant. The other nonzero families contain spatial
+structure: shear, affine gradients, fixed vortices, explicit double-gyre
+recirculation, source/sink radial currents, localized turbulent patches, and
+divergence-free random Fourier currents. All paper flow fields are static:
+their velocity at a fixed position is independent of time.
+
+Localized structures are sampled near common task routes and waypoint corridors
+rather than uniformly over the whole workspace. This keeps hidden-flow
+variation relevant to the boat trajectories instead of placing most structure
+in regions the vehicle rarely visits.

data/paper/diagnostic_seen_flow.npz

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e8366dd25e98b81b3b159a600e4e158b8b719e0ad41a0e3fbc915b6af34ce924
-size 6601980

data/paper/generation_config.json

@@ -3,13 +3,17 @@
     "twin",
     "triangle"
   ],
-  "train_flow_types": [
+  "flow_families": [
     "noflow",
     "uniform",
-    "slowly_varying",
     "vortex_center",
+    "double_gyre",
+    "source_sink",
+    "source_sink_pair",
     "gradient",
-    "turbulent_patch"
+    "shear",
+    "turbulent_patch",
+    "random_fourier"
   ],
   "trajectory_types": [
     "noflow_random_action",
@@ -20,18 +24,14 @@
   ],
   "episodes": {
     "train": 2400,
-    "diagnostic_seen_flow": 480,
-    "test_unseen_flow": 480,
-    "test_unseen_boat_params": 480
+    "test": 480
   },
   "steps": 300,
   "flow_pool_size": 80,
   "boundary": "terminate",
   "seeds": {
     "train": 4301,
-    "diagnostic_seen_flow": 4302,
-    "test_unseen_flow": 4303,
-    "test_unseen_boat_params": 4304
+    "test": 4302
   },
   "image_size": 160,
   "visual_scale": 2.5,
@@ -40,10 +40,5 @@
     10.0,
     0.0,
     10.0
-  ],
-  "unseen_flow_types": [
-    "shear",
-    "moving_vortex",
-    "random_fourier"
   ]
 }

data/paper/test_unseen_boat_params.npz

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:fa4161b8917935a7a159f3e1604d4551c455f55160d8dd83b234bd726fc154a4
-size 6400836

data/paper/test_unseen_flow.npz

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3beab06303edd2a81c802972d1055fed3ceffa54ac90f4686b11b08479682b87
-size 6493086

data/paper/train.npz

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3632528ec850fd526e028f49bf1641d8f9f9399dc6c07e495b9351df29f76f2a
-size 32273806

driftwm/data/generate.py

@@ -17,13 +17,13 @@ ID_TO_BOAT = {v: k for k, v in BOAT_TO_ID.items()}
 FLOW_TO_ID = {
     "noflow": 0,
     "uniform": 1,
-    "slowly_varying": 2,
-    "vortex": 3,
-    "vortex_center": 4,
-    "gradient": 5,
-    "turbulent_patch": 6,
+    "vortex_center": 2,
+    "double_gyre": 3,
+    "source_sink": 4,
+    "source_sink_pair": 5,
+    "gradient": 6,
     "shear": 7,
-    "moving_vortex": 8,
+    "turbulent_patch": 8,
     "random_fourier": 9,
 }
 ID_TO_FLOW = {v: k for k, v in FLOW_TO_ID.items()}
@@ -103,7 +103,6 @@ def generate_dataset(
     boundary: str = "terminate",
     randomize_params: bool = True,
     flow_pool_size: int = PAPER_FLOW_POOL_SIZE,
-    unseen_boat_params: bool = False,
 ) -> None:
     rng = np.random.default_rng(seed)
     out = Path(out)
@@ -134,7 +133,9 @@ def generate_dataset(
         if traj_type.startswith("noflow"):
             flow_type = "noflow"
         else:
-            available = [ft for ft in flow_types if ft != "noflow"] or ["uniform"]
+            available = [ft for ft in flow_types if ft != "noflow"]
+            if not available:
+                raise ValueError("flow_types must include at least one nonzero flow family")
             flow_type = available[int(rng.integers(0, len(available)))]
         flow_template = flow_pool[flow_type][int(rng.integers(0, len(flow_pool[flow_type])))]
         flow = copy.deepcopy(flow_template)
@@ -146,14 +147,6 @@ def generate_dataset(
             random_velocity=random_velocity,
             randomize_params=randomize_params,
         )
-        if unseen_boat_params:
-            for key in list(env.params):
-                if key in {"mass", "inertia", "actuator_tau"}:
-                    factor = rng.choice([rng.uniform(0.55, 0.72), rng.uniform(1.45, 1.85)])
-                else:
-                    factor = rng.choice([rng.uniform(0.45, 0.70), rng.uniform(1.45, 1.90)])
-                env.params[key] = float(env.params[key] * factor)
-
         if traj_type == "noflow_random_action":
             planned_actions = smooth_random_actions(rng, steps, env.action_dim, scale=1.0)
         elif traj_type == "noflow_action_then_zero":
@@ -214,7 +207,6 @@ def generate_dataset(
         "seed": seed,
         "max_action_dim": 3,
         "flow_pool_size": flow_pool_size,
-        "unseen_boat_params": bool(unseen_boat_params),
     }
     np.savez_compressed(
         out,
@@ -240,8 +232,8 @@ def main() -> None:
     parser.add_argument("--out", required=True)
     parser.add_argument("--seed", type=int, default=0)
     parser.add_argument("--boundary", choices=["terminate", "bounce", "clip"], default="terminate")
+    parser.add_argument("--flow-pool-size", type=int, default=PAPER_FLOW_POOL_SIZE)
     parser.add_argument("--no-randomize-params", action="store_true")
-    parser.add_argument("--unseen-boat-params", action="store_true")
     args = parser.parse_args()
     generate_dataset(
         boats=args.boats,
@@ -251,8 +243,8 @@ def main() -> None:
         out=args.out,
         seed=args.seed,
         boundary=args.boundary,
+        flow_pool_size=args.flow_pool_size,
         randomize_params=not args.no_randomize_params,
-        unseen_boat_params=args.unseen_boat_params,
     )
 
 

driftwm/sim/env.py

@@ -121,7 +121,6 @@ class SurfaceBoatEnv:
             self.config.workspace,
             self.config.boundary,
         )
-        self.flow.step(self.config.dt, self.rng)
         self.t += 1
         self.time += self.config.dt
         timeout = self.t >= self.config.episode_steps

driftwm/sim/flow.py

@@ -9,20 +9,29 @@ import numpy as np
 PAPER_FLOW = {
     "uniform_min": 0.03,
     "uniform_max": 0.24,
-    "slow_max": 0.26,
-    "slow_noise": 0.0035,
-    "vortex_base_max": 0.12,
-    "vortex_gamma": 0.14,
-    "vortex_max": 0.34,
-    "gradient_base_min": 0.01,
-    "gradient_base_max": 0.16,
-    "gradient_matrix_std": 0.022,
+    "vortex_base_max": 0.05,
+    "vortex_gamma_min": 0.12,
+    "vortex_gamma_max": 0.24,
+    "vortex_max": 0.36,
+    "gradient_base_min": 0.00,
+    "gradient_base_max": 0.08,
+    "gradient_matrix_min": 0.018,
+    "gradient_matrix_max": 0.040,
     "gradient_max": 0.34,
-    "turbulent_base_max": 0.12,
-    "turbulent_vector_std": 0.075,
+    "turbulent_base_max": 0.05,
+    "turbulent_vector_std": 0.105,
     "turbulent_max": 0.34,
+    "shear_min": 0.035,
+    "shear_max_rate": 0.085,
     "shear_max": 0.38,
-    "moving_vortex_max": 0.38,
+    "double_gyre_amp_min": 0.20,
+    "double_gyre_amp_max": 0.34,
+    "double_gyre_max": 0.36,
+    "source_base_max": 0.03,
+    "source_strength_min": 0.16,
+    "source_strength_max": 0.30,
+    "source_max": 0.36,
+    "random_fourier_amp_std": 0.045,
     "random_fourier_max": 0.38,
 }
 
@@ -35,9 +44,6 @@ class Flow:
     def velocity(self, pos: np.ndarray, t: float = 0.0) -> np.ndarray:
         raise NotImplementedError
 
-    def step(self, dt: float, rng: np.random.Generator) -> None:
-        return None
-
     def metadata(self) -> dict[str, Any]:
         return {"flow_type": self.name, "flow_id": int(self.flow_id)}
 
@@ -68,45 +74,6 @@ class UniformFlow(Flow):
         out["vector"] = self.vector.astype(float).tolist()
         return out
 
-
-@dataclass
-class SlowlyVaryingFlow(Flow):
-    vector: np.ndarray
-    rho: float
-    noise_std: float
-    max_speed: float
-
-    def __init__(
-        self,
-        vector: np.ndarray,
-        flow_id: int,
-        rho: float = 0.995,
-        noise_std: float = 0.005,
-        max_speed: float = 0.35,
-    ):
-        super().__init__("slowly_varying", flow_id)
-        self.vector = np.asarray(vector, dtype=np.float32)
-        self.rho = float(rho)
-        self.noise_std = float(noise_std)
-        self.max_speed = float(max_speed)
-
-    def velocity(self, pos: np.ndarray, t: float = 0.0) -> np.ndarray:
-        pos = np.asarray(pos, dtype=np.float32)
-        return np.broadcast_to(self.vector, pos.shape).astype(np.float32)
-
-    def step(self, dt: float, rng: np.random.Generator) -> None:
-        noise = rng.normal(0.0, self.noise_std, size=2).astype(np.float32)
-        self.vector = self.rho * self.vector + np.sqrt(max(0.0, 1.0 - self.rho**2)) * noise
-        speed = float(np.linalg.norm(self.vector))
-        if speed > self.max_speed:
-            self.vector = self.vector / speed * self.max_speed
-
-    def metadata(self) -> dict[str, Any]:
-        out = super().metadata()
-        out.update({"vector": self.vector.astype(float).tolist(), "rho": self.rho})
-        return out
-
-
 @dataclass
 class VortexFlow(Flow):
     base: np.ndarray
@@ -178,7 +145,13 @@ class GradientFlow(Flow):
 
     def metadata(self) -> dict[str, Any]:
         out = super().metadata()
-        out.update({"base": self.base.astype(float).tolist(), "matrix": self.matrix.astype(float).tolist()})
+        out.update(
+            {
+                "base": self.base.astype(float).tolist(),
+                "center": self.center.astype(float).tolist(),
+                "matrix": self.matrix.astype(float).tolist(),
+            }
+        )
         return out
 
 
@@ -251,39 +224,91 @@ class ShearFlow(Flow):
 
 
 @dataclass
-class MovingVortexFlow(VortexFlow):
-    center_velocity: np.ndarray
+class DoubleGyreFlow(Flow):
+    amp: float
+    phase: float
     workspace: tuple[float, float, float, float]
+    max_speed: float
 
     def __init__(
         self,
-        base: np.ndarray,
-        center: np.ndarray,
-        gamma: float,
-        center_velocity: np.ndarray,
+        amp: float,
+        phase: float,
         flow_id: int,
         workspace: tuple[float, float, float, float],
-        radius_eps: float = 0.35,
-        max_speed: float = 0.60,
+        max_speed: float = 0.50,
     ):
-        super().__init__(base=base, center=center, gamma=gamma, flow_id=flow_id, radius_eps=radius_eps, max_speed=max_speed, name="moving_vortex")
-        self.center_velocity = np.asarray(center_velocity, dtype=np.float32)
+        super().__init__("double_gyre", flow_id)
+        self.amp = float(amp)
+        self.phase = float(phase)
         self.workspace = workspace
+        self.max_speed = float(max_speed)
 
-    def step(self, dt: float, rng: np.random.Generator) -> None:
-        del rng
-        self.center = self.center + dt * self.center_velocity
+    def velocity(self, pos: np.ndarray, t: float = 0.0) -> np.ndarray:
+        pos = np.asarray(pos, dtype=np.float32)
         xmin, xmax, ymin, ymax = self.workspace
-        if self.center[0] < xmin + 1.0 or self.center[0] > xmax - 1.0:
-            self.center_velocity[0] *= -1.0
-        if self.center[1] < ymin + 1.0 or self.center[1] > ymax - 1.0:
-            self.center_velocity[1] *= -1.0
-        self.center[0] = np.clip(self.center[0], xmin + 1.0, xmax - 1.0)
-        self.center[1] = np.clip(self.center[1], ymin + 1.0, ymax - 1.0)
+        x = (pos[..., 0] - xmin) / max(xmax - xmin, 1e-6)
+        y = (pos[..., 1] - ymin) / max(ymax - ymin, 1e-6)
+        sx = np.sin(np.pi * x + self.phase)
+        cx = np.cos(np.pi * x + self.phase)
+        sy = np.sin(2.0 * np.pi * y)
+        cy = np.cos(2.0 * np.pi * y)
+        vel = np.stack([self.amp * sx * cy, -0.5 * self.amp * cx * sy], axis=-1)
+        speed = np.linalg.norm(vel, axis=-1, keepdims=True)
+        scale = np.minimum(1.0, self.max_speed / np.maximum(speed, 1e-6))
+        return (vel * scale).astype(np.float32)
+
+    def metadata(self) -> dict[str, Any]:
+        out = super().metadata()
+        out.update({"amp": self.amp, "phase": self.phase})
+        return out
+
+
+@dataclass
+class SourceSinkFlow(Flow):
+    base: np.ndarray
+    centers: np.ndarray
+    strengths: np.ndarray
+    radius_eps: float
+    max_speed: float
+
+    def __init__(
+        self,
+        name: str,
+        base: np.ndarray,
+        centers: np.ndarray,
+        strengths: np.ndarray,
+        flow_id: int,
+        radius_eps: float = 0.45,
+        max_speed: float = 0.50,
+    ):
+        super().__init__(name, flow_id)
+        self.base = np.asarray(base, dtype=np.float32)
+        self.centers = np.asarray(centers, dtype=np.float32)
+        self.strengths = np.asarray(strengths, dtype=np.float32)
+        self.radius_eps = float(radius_eps)
+        self.max_speed = float(max_speed)
+
+    def velocity(self, pos: np.ndarray, t: float = 0.0) -> np.ndarray:
+        pos = np.asarray(pos, dtype=np.float32)
+        rel = pos[..., None, :] - self.centers
+        denom = np.sum(rel * rel, axis=-1, keepdims=True) + self.radius_eps**2
+        strength_shape = (1,) * (rel.ndim - 2) + (self.strengths.shape[0], 1)
+        radial = np.sum(self.strengths.reshape(strength_shape) * rel / denom, axis=-2)
+        vel = self.base + radial
+        speed = np.linalg.norm(vel, axis=-1, keepdims=True)
+        scale = np.minimum(1.0, self.max_speed / np.maximum(speed, 1e-6))
+        return (vel * scale).astype(np.float32)
 
     def metadata(self) -> dict[str, Any]:
         out = super().metadata()
-        out["center_velocity"] = self.center_velocity.astype(float).tolist()
+        out.update(
+            {
+                "base": self.base.astype(float).tolist(),
+                "centers": self.centers.astype(float).tolist(),
+                "strengths": self.strengths.astype(float).tolist(),
+            }
+        )
         return out
 
 
@@ -293,7 +318,6 @@ class RandomFourierFlow(Flow):
     k: np.ndarray
     amp: np.ndarray
     phase: np.ndarray
-    temporal: np.ndarray
     max_speed: float
 
     def __init__(
@@ -302,7 +326,6 @@ class RandomFourierFlow(Flow):
         k: np.ndarray,
         amp: np.ndarray,
         phase: np.ndarray,
-        temporal: np.ndarray,
         flow_id: int,
         max_speed: float = 0.60,
     ):
@@ -311,13 +334,12 @@ class RandomFourierFlow(Flow):
         self.k = np.asarray(k, dtype=np.float32)
         self.amp = np.asarray(amp, dtype=np.float32)
         self.phase = np.asarray(phase, dtype=np.float32)
-        self.temporal = np.asarray(temporal, dtype=np.float32)
         self.max_speed = float(max_speed)
 
     def velocity(self, pos: np.ndarray, t: float = 0.0) -> np.ndarray:
         pos = np.asarray(pos, dtype=np.float32)
         flat = pos.reshape(-1, 2)
-        arg = flat @ self.k.T + self.phase[None, :] + float(t) * self.temporal[None, :]
+        arg = flat @ self.k.T + self.phase[None, :]
         # Divergence-free field via stream function psi: v=(dpsi/dy, -dpsi/dx).
         coeff = self.amp[None, :] * np.cos(arg)
         vx = np.sum(coeff * self.k[None, :, 1], axis=1)
@@ -339,6 +361,59 @@ def _sample_uniform_vector(rng: np.random.Generator, min_speed: float = 0.05, ma
     return np.array([speed * np.cos(direction), speed * np.sin(direction)], dtype=np.float32)
 
 
+def _sample_signed_uniform(rng: np.random.Generator, min_abs: float, max_abs: float) -> float:
+    sign = -1.0 if rng.random() < 0.5 else 1.0
+    return float(sign * rng.uniform(min_abs, max_abs))
+
+
+def _route_anchors(workspace: tuple[float, float, float, float]) -> np.ndarray:
+    xmin, xmax, ymin, ymax = workspace
+    w = xmax - xmin
+    h = ymax - ymin
+    points = np.array(
+        [
+            [0.20, 0.20],
+            [0.35, 0.35],
+            [0.50, 0.50],
+            [0.65, 0.65],
+            [0.80, 0.80],
+            [0.20, 0.80],
+            [0.35, 0.65],
+            [0.50, 0.50],
+            [0.65, 0.35],
+            [0.80, 0.20],
+            [0.50, 0.25],
+            [0.50, 0.75],
+            [0.25, 0.50],
+            [0.75, 0.50],
+        ],
+        dtype=np.float32,
+    )
+    points[:, 0] = xmin + points[:, 0] * w
+    points[:, 1] = ymin + points[:, 1] * h
+    return points
+
+
+def _sample_route_center(
+    rng: np.random.Generator,
+    workspace: tuple[float, float, float, float],
+    jitter: float = 0.65,
+) -> np.ndarray:
+    xmin, xmax, ymin, ymax = workspace
+    anchors = _route_anchors(workspace)
+    center = anchors[int(rng.integers(0, len(anchors)))] + rng.normal(0.0, jitter, size=2).astype(np.float32)
+    return np.array([np.clip(center[0], xmin + 1.2, xmax - 1.2), np.clip(center[1], ymin + 1.2, ymax - 1.2)], dtype=np.float32)
+
+
+def _sample_route_centers(
+    rng: np.random.Generator,
+    workspace: tuple[float, float, float, float],
+    count: int,
+    jitter: float = 0.65,
+) -> np.ndarray:
+    return np.stack([_sample_route_center(rng, workspace, jitter=jitter) for _ in range(count)], axis=0).astype(np.float32)
+
+
 def sample_flow(
     flow_type: str,
     rng: np.random.Generator,
@@ -351,77 +426,74 @@ def sample_flow(
         return NoFlow(flow_id=0)
     if flow_type == "uniform":
         return UniformFlow(_sample_uniform_vector(rng, profile["uniform_min"], profile["uniform_max"]), flow_id=flow_id)
-    if flow_type in {"slow", "slowly_varying", "ou"}:
-        return SlowlyVaryingFlow(
-            _sample_uniform_vector(rng, profile["uniform_min"], profile["uniform_max"]),
-            flow_id=flow_id,
-            noise_std=profile["slow_noise"],
-            max_speed=profile["slow_max"],
-        )
-    if flow_type in {"vortex", "vortex_center"}:
-        xmin, xmax, ymin, ymax = workspace
-        if flow_type == "vortex_center":
-            center = np.array([(xmin + xmax) / 2.0, (ymin + ymax) / 2.0], dtype=np.float32)
-        else:
-            center = np.array([rng.uniform(xmin + 2.0, xmax - 2.0), rng.uniform(ymin + 2.0, ymax - 2.0)], dtype=np.float32)
+    if flow_type == "vortex_center":
+        center = _sample_route_center(rng, workspace, jitter=0.45)
         base = _sample_uniform_vector(rng, 0.0, profile["vortex_base_max"])
-        gamma = float(rng.uniform(-profile["vortex_gamma"], profile["vortex_gamma"]))
+        gamma = _sample_signed_uniform(rng, profile["vortex_gamma_min"], profile["vortex_gamma_max"])
         return VortexFlow(base=base, center=center, gamma=gamma, flow_id=flow_id, max_speed=profile["vortex_max"], name=flow_type)
-    if flow_type in {"gradient", "gradient_flow"}:
-        xmin, xmax, ymin, ymax = workspace
-        center = np.array([(xmin + xmax) / 2.0, (ymin + ymax) / 2.0], dtype=np.float32)
+    if flow_type == "gradient":
+        center = _sample_route_center(rng, workspace, jitter=0.35)
         base = _sample_uniform_vector(rng, profile["gradient_base_min"], profile["gradient_base_max"])
-        mat = rng.normal(0.0, profile["gradient_matrix_std"], size=(2, 2)).astype(np.float32)
+        scale = rng.uniform(profile["gradient_matrix_min"], profile["gradient_matrix_max"])
+        mat = rng.normal(0.0, 1.0, size=(2, 2)).astype(np.float32)
+        mat = mat / max(float(np.linalg.norm(mat)), 1e-6) * scale
         return GradientFlow(base=base, center=center, matrix=mat, flow_id=flow_id, max_speed=profile["gradient_max"])
-    if flow_type in {"turbulent", "turbulent_patch", "patch"}:
-        xmin, xmax, ymin, ymax = workspace
+    if flow_type == "turbulent_patch":
         base = _sample_uniform_vector(rng, 0.0, profile["turbulent_base_max"])
-        centers = np.stack(
-            [
-                rng.uniform([xmin + 1.0, ymin + 1.0], [xmax - 1.0, ymax - 1.0])
-                for _ in range(5)
-            ],
-            axis=0,
-        ).astype(np.float32)
+        centers = _sample_route_centers(rng, workspace, count=5, jitter=0.85)
         vectors = rng.normal(0.0, profile["turbulent_vector_std"], size=(5, 2)).astype(np.float32)
         return TurbulentPatchFlow(base=base, centers=centers, vectors=vectors, flow_id=flow_id, max_speed=profile["turbulent_max"])
-    if flow_type in {"shear", "shear_flow"}:
+    if flow_type == "shear":
         xmin, xmax, ymin, ymax = workspace
         base = _sample_uniform_vector(rng, 0.0, profile["turbulent_base_max"])
         center_y = 0.5 * (ymin + ymax)
-        shear = float(rng.uniform(-0.08, 0.08))
+        shear = _sample_signed_uniform(rng, profile["shear_min"], profile["shear_max_rate"])
         return ShearFlow(base=base, center_y=center_y, shear=shear, flow_id=flow_id, max_speed=profile["shear_max"])
-    if flow_type in {"moving_vortex", "moving-vortex"}:
-        xmin, xmax, ymin, ymax = workspace
-        center = np.array([rng.uniform(xmin + 2.0, xmax - 2.0), rng.uniform(ymin + 2.0, ymax - 2.0)], dtype=np.float32)
-        base = _sample_uniform_vector(rng, 0.0, profile["vortex_base_max"])
-        gamma = float(rng.uniform(-profile["vortex_gamma"], profile["vortex_gamma"]))
-        center_velocity = _sample_uniform_vector(rng, 0.02, 0.08)
-        return MovingVortexFlow(
+    if flow_type == "double_gyre":
+        amp = float(rng.uniform(profile["double_gyre_amp_min"], profile["double_gyre_amp_max"]))
+        phase = float(rng.uniform(0.0, 2.0 * np.pi))
+        return DoubleGyreFlow(amp=amp, phase=phase, flow_id=flow_id, workspace=workspace, max_speed=profile["double_gyre_max"])
+    if flow_type == "source_sink":
+        base = _sample_uniform_vector(rng, 0.0, profile["source_base_max"])
+        center = _sample_route_centers(rng, workspace, count=1, jitter=0.65)
+        strength = np.array([_sample_signed_uniform(rng, profile["source_strength_min"], profile["source_strength_max"])], dtype=np.float32)
+        return SourceSinkFlow(
+            name="source_sink",
+            base=base,
+            centers=center,
+            strengths=strength,
+            flow_id=flow_id,
+            max_speed=profile["source_max"],
+        )
+    if flow_type == "source_sink_pair":
+        base = _sample_uniform_vector(rng, 0.0, profile["source_base_max"])
+        centers = _sample_route_centers(rng, workspace, count=2, jitter=0.75)
+        strength = float(rng.uniform(profile["source_strength_min"], profile["source_strength_max"]))
+        if rng.random() < 0.5:
+            strength = -strength
+        strengths = np.array([strength, -strength], dtype=np.float32)
+        return SourceSinkFlow(
+            name="source_sink_pair",
             base=base,
-            center=center,
-            gamma=gamma,
-            center_velocity=center_velocity,
+            centers=centers,
+            strengths=strengths,
             flow_id=flow_id,
-            workspace=workspace,
-            max_speed=profile["moving_vortex_max"],
+            max_speed=profile["source_max"],
         )
-    if flow_type in {"random_fourier", "fourier", "divfree"}:
+    if flow_type == "random_fourier":
         base = _sample_uniform_vector(rng, 0.0, profile["turbulent_base_max"])
         modes = 8
         k = rng.integers(1, 5, size=(modes, 2)).astype(np.float32)
         signs = rng.choice([-1.0, 1.0], size=(modes, 2)).astype(np.float32)
         k = signs * k * (2.0 * np.pi / 10.0)
-        amp_std = 0.028
+        amp_std = profile["random_fourier_amp_std"]
         amp = rng.normal(0.0, amp_std, size=(modes,)).astype(np.float32)
         phase = rng.uniform(0.0, 2.0 * np.pi, size=(modes,)).astype(np.float32)
-        temporal = rng.normal(0.0, 0.12, size=(modes,)).astype(np.float32)
         return RandomFourierFlow(
             base=base,
             k=k,
             amp=amp,
             phase=phase,
-            temporal=temporal,
             flow_id=flow_id,
             max_speed=profile["random_fourier_max"],
         )

driftwm/sim/sanity.py

@@ -68,7 +68,7 @@ def run_sanity(
 def main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument("--boat", choices=["twin", "triangle"], default="twin")
-    parser.add_argument("--flow", choices=["noflow", "uniform", "slowly_varying", "vortex"], default="noflow")
+    parser.add_argument("--flow", choices=["noflow", "uniform", "vortex_center", "double_gyre", "source_sink", "source_sink_pair", "gradient", "shear", "turbulent_patch", "random_fourier"], default="noflow")
     parser.add_argument("--scenario", choices=["auto", "slide", "drift", "thruster", "random"], default="auto")
     parser.add_argument("--steps", type=int, default=200)
     parser.add_argument("--seed", type=int, default=0)

experiments/EXPERIMENT_MATRIX.md

@@ -12,14 +12,16 @@ Image size: 160 x 160
 Visual scale: 2.5
 Forbidden image cues: flow arrows, velocity vectors, trajectory overlays, goal marker
 Train split: data/paper/train.npz
-Primary unseen-flow split: data/paper/test_unseen_flow.npz
-Primary unseen-boat-dynamics split: data/paper/test_unseen_boat_params.npz
-Diagnostic seen-flow-family split: data/paper/diagnostic_seen_flow.npz
+Test split: data/paper/test.npz
+Flow families: noflow, uniform, vortex_center, double_gyre, source_sink, source_sink_pair, gradient, shear, turbulent_patch, random_fourier
 Config: experiments/shared/config/paper_image.json
 Checkpoint: paper.pt
 Intermediate checkpoints: paper_step_XXXXXX.pt
 ```
 
+All flow fields are static. Localized flow structures are sampled near the
+route corridors used by the training controllers and final planning tasks.
+
 Formal training budget:
 
 ```text
@@ -32,6 +34,8 @@ steps: 20000
 checkpoint_interval: 2000
 num_workers: 4
 render_mode: device
+training_parallel_jobs: 2
+planning_parallel_jobs: 3
 ```
 
 Precision policy:
@@ -53,12 +57,10 @@ Purpose: measure world-model quality directly. The key question is whether FlowM
 | `planet` | RSSM WM baseline | Whether generic recurrent latent memory can represent momentum and drift without a separate context factor. |
 | `tdmpc2` | Compact latent-dynamics WM baseline | Whether a compact action-conditioned latent transition matches FlowMo under equal supervision. |
 
-Prediction datasets:
+Prediction dataset:
 
 ```text
-test_unseen_flow
-test_unseen_boat_params
-diagnostic_seen_flow
+test
 ```
 
 Prediction metrics:
@@ -115,10 +117,8 @@ Traditional non-WM controllers:
 Planning tasks:
 
 ```text
-reach_uniform
-counterflow
+reach_target
 station_keeping
-passive_to_active
 waypoint_square
 waypoint_zigzag
 ```
@@ -130,6 +130,21 @@ twin
 triangle
 ```
 
+Flow families:
+
+```text
+noflow
+uniform
+vortex_center
+double_gyre
+source_sink
+source_sink_pair
+gradient
+shear
+turbulent_patch
+random_fourier
+```
+
 Planning metrics:
 
 ```text

experiments/README.md

@@ -62,7 +62,8 @@ Formal clean-image configuration:
 image_size=160
 visual_scale=2.5
 train=data/paper/train.npz
-test=data/paper/test_unseen_flow.npz and data/paper/test_unseen_boat_params.npz
+test=data/paper/test.npz
+flow_families=noflow, uniform, vortex_center, double_gyre, source_sink, source_sink_pair, gradient, shear, turbulent_patch, random_fourier
 ```
 
 Full paper-facing image pipeline:
@@ -72,6 +73,7 @@ python -m experiments.run_paper_image_pipeline
 ```
 
 The default command runs the paper configuration end to end: train all learned world models, evaluate long rollout prediction, run FlowMo latent probes, evaluate closed-loop planning against traditional controllers, generate GIFs, and write the final report. Images are rendered online from simulator states, so no separate image-cache preparation step is required.
+All flow fields are static. Localized flow structures are sampled near task routes so that boat trajectories encounter non-uniform current in the shared train/test/final protocol.
 
 Manual image training:
 
@@ -79,6 +81,6 @@ Manual image training:
 python -m experiments.train_image_world_models
 python -m experiments.evaluate_image_world_models
 python -m experiments.evaluate_flowmo_latent_probes
-python -m experiments.evaluate_image_planning --task reach_uniform --boat twin
+python -m experiments.evaluate_image_planning --task reach_target --boat twin
 python -m experiments.summarize_paper_image_results
 ```

experiments/TASK_PLAN.md

@@ -12,8 +12,10 @@ Shared setup:
 Input: clean top-down boat images plus action history
 No image cues: no flow arrows, no velocity vector, no goal marker
 Training data: data/paper/train.npz
-Primary evaluation data: data/paper/test_unseen_flow.npz, data/paper/test_unseen_boat_params.npz
-Diagnostic data: data/paper/diagnostic_seen_flow.npz
+Evaluation data: data/paper/test.npz
+Flow families: noflow, uniform, vortex_center, double_gyre, source_sink, source_sink_pair, gradient, shear, turbulent_patch, random_fourier
+All flow fields are static. Localized flow structures are sampled near common
+task routes so the boat encounters non-uniform current during rollout.
 Training budget: shared optimizer, batch size, rollout horizon, step count, and checkpoint schedule
 Training precision: BF16 model autocast, FP32 losses and metrics
 Prediction precision: BF16 model autocast, FP32 metrics
@@ -46,9 +48,7 @@ experiments/<method>/checkpoint/paper.pt
 experiments/<method>/checkpoint/paper_step_*.pt
 experiments/<method>/result/parameter_count.json
 experiments/<method>/result/paper_training.json
-experiments/reports/paper_prediction_seen_flow_diagnostic.json
-experiments/reports/paper_prediction_unseen_flow.json
-experiments/reports/paper_prediction_unseen_boat_params.json
+experiments/reports/paper_prediction.json
 experiments/reports/paper_flowmo_latent_probes.json
 ```
 
@@ -56,7 +56,7 @@ Core A conclusions:
 
 ```text
 1. Whether FlowMo has lower long-horizon rollout error.
-2. Whether the gain is strongest under unseen flow families and unseen boat dynamics.
+2. Whether the gain holds across the full paper flow-family set.
 3. Whether explicit drift context helps beyond ordinary recurrent history.
 4. Whether the same architecture works for both twin and triangle boats.
 5. Whether frozen linear probes recover object momentum from `z_t` and ambient drift from `c_t`.
@@ -87,10 +87,8 @@ Compared methods:
 Planning tasks:
 
 ```text
-reach_uniform
-counterflow
+reach_target
 station_keeping
-passive_to_active
 waypoint_square
 waypoint_zigzag
 ```
@@ -102,6 +100,21 @@ twin
 triangle
 ```
 
+Flow families:
+
+```text
+noflow
+uniform
+vortex_center
+double_gyre
+source_sink
+source_sink_pair
+gradient
+shear
+turbulent_patch
+random_fourier
+```
+
 Required B outputs:
 
 ```text

experiments/docs/EXPERIMENT_PROTOCOL.md

@@ -36,13 +36,20 @@ All methods use the same splits:
 
 ```text
 train: data/paper/train.npz
-unseen_flow_test: data/paper/test_unseen_flow.npz
-unseen_boat_dynamics_test: data/paper/test_unseen_boat_params.npz
-seen_flow_diagnostic: data/paper/diagnostic_seen_flow.npz
+test: data/paper/test.npz
 dataset_card: data/paper/dataset_card.md
 generation_config: data/paper/generation_config.json
 ```
 
+The train split, test split, and final planning evaluation use the same paper
+flow-family set: `noflow`, `uniform`, `vortex_center`, `double_gyre`,
+`source_sink`, `source_sink_pair`, `gradient`, `shear`, `turbulent_patch`, and
+`random_fourier`.
+
+All paper flow fields are static. Localized structures are sampled near common
+task routes and waypoint corridors so that non-uniform flow is encountered by
+the boat during both training trajectories and final planning tasks.
+
 Observation protocol:
 
 ```text
@@ -64,6 +71,8 @@ steps: 20000
 checkpoint_interval: 2000
 num_workers: 4
 render_mode: device
+training_parallel_jobs: 2
+planning_parallel_jobs: 3
 ```
 
 Precision policy:
@@ -78,12 +87,10 @@ The precision split is intentional: BF16 speeds up image encoding and latent rol
 
 ## Prediction Evaluation
 
-Datasets:
+Dataset:
 
 ```text
-test_unseen_flow
-test_unseen_boat_params
-diagnostic_seen_flow
+test
 ```
 
 Metrics:
@@ -139,10 +146,8 @@ oracle_flow_mpc
 Tasks:
 
 ```text
-reach_uniform
-counterflow
+reach_target
 station_keeping
-passive_to_active
 waypoint_square
 waypoint_zigzag
 ```
@@ -154,6 +159,21 @@ twin
 triangle
 ```
 
+Flow families:
+
+```text
+noflow
+uniform
+vortex_center
+double_gyre
+source_sink
+source_sink_pair
+gradient
+shear
+turbulent_patch
+random_fourier
+```
+
 Metrics:
 
 ```text
@@ -179,9 +199,7 @@ experiments/<method>/result/paper_training_trace.jsonl
 Evaluation outputs:
 
 ```text
-experiments/reports/paper_prediction_unseen_flow.json
-experiments/reports/paper_prediction_unseen_boat_params.json
-experiments/reports/paper_prediction_seen_flow_diagnostic.json
+experiments/reports/paper_prediction.json
 experiments/reports/paper_flowmo_latent_probes.json
 experiments/reports/paper_planning/*.json
 experiments/reports/paper_planning/gifs/*.gif

experiments/evaluate_flowmo_latent_probes.py

@@ -203,9 +203,7 @@ def main() -> None:
     parser.add_argument("--train-episodes", type=int, default=2400)
     parser.add_argument("--train-windows", type=int, default=32768)
     parser.add_argument("--eval-splits", nargs="+", default=[
-        "unseen_flow:data/paper/test_unseen_flow.npz:480",
-        "unseen_boat_params:data/paper/test_unseen_boat_params.npz:480",
-        "seen_flow_diagnostic:data/paper/diagnostic_seen_flow.npz:480",
+        "test:data/paper/test.npz:480",
     ])
     parser.add_argument("--eval-windows", type=int, default=8192)
     parser.add_argument("--history-len", type=int, default=32)

experiments/evaluate_image_planning.py

@@ -13,7 +13,7 @@ import torch
 import torch.nn.functional as F
 
 from driftwm.sim.env import SurfaceBoatEnv
-from driftwm.sim.flow import UniformFlow, sample_flow
+from driftwm.sim.flow import sample_flow
 from driftwm.sim.render import render_frame, save_gif
 from experiments.shared.src.methods import PAPER_LEARNED_METHODS, TRADITIONAL_METHODS
 from experiments.shared.src.vision.clean_renderer import render_clean_boat_array
@@ -56,31 +56,23 @@ def task_goals(task: str, rng: np.random.Generator) -> np.ndarray:
         return np.array([[2.5, 7.0], [4.2, 3.0], [5.8, 7.0], [7.5, 3.0]], dtype=np.float32)
     if task == "station_keeping":
         return np.array([[5.0, 5.0]], dtype=np.float32)
-    if task == "counterflow":
-        return np.array([[8.4, 5.0]], dtype=np.float32)
     return np.array([[8.0, 8.0]], dtype=np.float32)
 
 
+def set_task_state(env: SurfaceBoatEnv, state: np.ndarray) -> None:
+    env.state[:6] = np.asarray(state, dtype=np.float32)
+    env.last_flow_velocity = env.flow_at(env.state[:2]).astype(np.float32)
+
+
 def reset_task(env: SurfaceBoatEnv, task: str, flow_type: str, rng: np.random.Generator) -> None:
-    if task == "counterflow":
-        env.reset(
-            flow_type="uniform",
-            flow=UniformFlow(np.array([-0.22, 0.0], dtype=np.float32), flow_id=7001),
-            random_velocity=False,
-        )
-        env.state[:6] = np.array([2.0, 5.0, 0.0, 0.0, 0.0, 0.0], dtype=np.float32)
-        return
     if task == "station_keeping":
-        env.reset(
-            flow_type="uniform",
-            flow=UniformFlow(np.array([0.16, 0.10], dtype=np.float32), flow_id=7002),
-            random_velocity=False,
-        )
-        env.state[:6] = np.array([5.0, 5.0, 0.3, 0.0, 0.0, 0.0], dtype=np.float32)
+        flow = sample_flow(flow_type, rng, flow_id=10_000 + int(rng.integers(1, 1_000_000)), workspace=env.workspace)
+        env.reset(flow_type=flow_type, flow=flow, random_velocity=False)
+        set_task_state(env, np.array([5.0, 5.0, 0.3, 0.0, 0.0, 0.0], dtype=np.float32))
         return
     flow = sample_flow(flow_type, rng, flow_id=10_000 + int(rng.integers(1, 1_000_000)), workspace=env.workspace)
     env.reset(flow_type=flow_type, flow=flow, random_velocity=False)
-    env.state[:6] = np.array([2.0, 2.0, float(rng.uniform(-np.pi, np.pi)), 0.0, 0.0, 0.0], dtype=np.float32)
+    set_task_state(env, np.array([2.0, 2.0, float(rng.uniform(-np.pi, np.pi)), 0.0, 0.0, 0.0], dtype=np.float32))
 
 
 def rollout_latent(model, z: torch.Tensor, c: torch.Tensor, actions: torch.Tensor) -> torch.Tensor:
@@ -420,16 +412,11 @@ def evaluate_one_method(method: str, args) -> dict:
             energy = 0.0
             reached_times: list[int] = []
             min_goal_dists = np.full((len(goals),), np.inf, dtype=np.float32)
-            passive_steps = args.passive_steps if args.task == "passive_to_active" else 0
             planned = None
             learned_plan_mean = None
             for t in range(args.max_steps):
                 goal = goals[goal_idx]
-                if t < passive_steps:
-                    action = np.zeros((env.action_dim,), dtype=np.float32)
-                    planned = None
-                    learned_plan_mean = None
-                elif learned:
+                if learned:
                     action, planned, learned_plan_mean = learned_plan(
                         model,
                         image_history,
@@ -532,12 +519,11 @@ def summarize(method: str, args, results: list[dict]) -> dict:
 def main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument("--methods", nargs="+", default=LEARNED_METHODS + TRADITIONAL_METHODS)
-    parser.add_argument("--task", choices=["reach_uniform", "counterflow", "station_keeping", "passive_to_active", "waypoint_square", "waypoint_zigzag"], default="reach_uniform")
+    parser.add_argument("--task", choices=["reach_target", "station_keeping", "waypoint_square", "waypoint_zigzag"], default="reach_target")
     parser.add_argument("--boat", choices=["twin", "triangle"], default="twin")
-    parser.add_argument("--flow-type", choices=["uniform", "slowly_varying", "vortex_center", "gradient", "turbulent_patch"], default="uniform")
+    parser.add_argument("--flow-type", choices=["noflow", "uniform", "vortex_center", "double_gyre", "source_sink", "source_sink_pair", "gradient", "shear", "turbulent_patch", "random_fourier"], default="uniform")
     parser.add_argument("--episodes", type=int, default=50)
     parser.add_argument("--max-steps", type=int, default=420)
-    parser.add_argument("--passive-steps", type=int, default=25)
     parser.add_argument("--history-len", type=int, default=32)
     parser.add_argument("--image-size", type=int, default=160)
     parser.add_argument("--visual-scale", type=float, default=2.5)

experiments/evaluate_image_world_models.py

@@ -199,7 +199,7 @@ def summarize(pos_mean: np.ndarray, heading_mean: np.ndarray, steps: list[int])
 def main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument("--methods", nargs="+", default=METHODS)
-    parser.add_argument("--test-source", default="data/paper/test_unseen_flow.npz")
+    parser.add_argument("--test-source", default="data/paper/test.npz")
     parser.add_argument("--test-episodes", type=int, default=256)
     parser.add_argument("--history-len", type=int, default=32)
     parser.add_argument("--horizon", type=int, default=60)

experiments/flowmo/checkpoint/paper.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ee9afdebdb83b911c66c0c7fe11d04c710325b59699bf2315cb6429be3cb8048
-size 2668751

experiments/flowmo/checkpoint/paper_step_002000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:926b64053ac63c43dd5d5e8e814bcd11d3fb3144ed856bf348c21294c1d75891
-size 2671607

experiments/flowmo/checkpoint/paper_step_004000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:81a1748bb45882ec85e6259e086b9bb99133bceadfcb506b79c7bafe581af7a8
-size 2671607

experiments/flowmo/checkpoint/paper_step_006000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f2866a920b5f48b2278b62205707c40edfed673bfabe18a76163679cee286e27
-size 2671607

experiments/flowmo/checkpoint/paper_step_008000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:24359235bc7b043c31206b1abadabd2359ac4c352ac4531dcc675239f5028e7b
-size 2671607

experiments/flowmo/checkpoint/paper_step_010000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4038685bebbe8eedac78242618e6da2d8a36c63f0287dd454e97568977e53b3d
-size 2671607

experiments/flowmo/checkpoint/paper_step_012000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0f5e3047f0a82d16701d743aeb76b8f9746e1ee3f1d74ea4c6a93b9d3f222c6e
-size 2671607

experiments/flowmo/checkpoint/paper_step_014000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:091dd0aab8b72fc075279dfc5efce56965c8c9d998ec814042c115a8347a61b9
-size 2671607

experiments/flowmo/checkpoint/paper_step_016000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:22f284b27e461ff1abde23bd22cd2f13c38fe3144dedeeb88614bf805679c085
-size 2671607

experiments/flowmo/checkpoint/paper_step_018000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:797b2df1d7a20bf54d65059726f4f722cf878374a276c6239a9160a54bea0522
-size 2671607

experiments/flowmo/checkpoint/paper_step_020000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:78c1bd5c1e5d4663c12e105b243d406eecea5f2e65201e5ee2445ea477818e0f
-size 2671607

experiments/flowmo/result/paper_training.json

@@ -1,43 +0,0 @@
-{
-  "method": "flowmo",
-  "steps": 20000,
-  "batch_size": 256,
-  "train_samples": 5120000,
-  "final_train_loss": 0.004372047260403633,
-  "total_parameters": 663964,
-  "target_mode": "absolute_normalized",
-  "position_scale": 5.0,
-  "heading_weight": 2.0,
-  "current_pose_weight": 1.0,
-  "motion_weight": 0.5,
-  "precision": "bf16",
-  "checkpoint_name": "paper.pt",
-  "final_checkpoint": "paper.pt",
-  "intermediate_checkpoints": [
-    "paper_step_002000.pt",
-    "paper_step_004000.pt",
-    "paper_step_006000.pt",
-    "paper_step_008000.pt",
-    "paper_step_010000.pt",
-    "paper_step_012000.pt",
-    "paper_step_014000.pt",
-    "paper_step_016000.pt",
-    "paper_step_018000.pt",
-    "paper_step_020000.pt"
-  ],
-  "checkpoint_interval": 2000,
-  "prediction": {
-    "pos1": 0.07179122391001631,
-    "heading1": 0.045128354569897056,
-    "pos3": 0.07811223280926545,
-    "heading3": 0.04785821299689511,
-    "pos6": 0.08915455282355349,
-    "heading6": 0.05167978972895071,
-    "pos8": 0.09605406736955047,
-    "heading8": 0.054166459323217474,
-    "pos10": 0.10336457837062578,
-    "heading10": 0.05640091137805333,
-    "pos20": 0.1460142444508771,
-    "heading20": 0.06746077448284875
-  }
-}

experiments/flowmo/result/paper_training_trace.jsonl

@@ -1,100 +0,0 @@
-{"method": "flowmo", "step": 200, "loss": 2.5686612129211426}
-{"method": "flowmo", "step": 400, "loss": 2.5599124431610107}
-{"method": "flowmo", "step": 600, "loss": 2.1556336879730225}
-{"method": "flowmo", "step": 800, "loss": 1.8842406272888184}
-{"method": "flowmo", "step": 1000, "loss": 1.8033578395843506}
-{"method": "flowmo", "step": 1200, "loss": 1.6628687381744385}
-{"method": "flowmo", "step": 1400, "loss": 1.5624256134033203}
-{"method": "flowmo", "step": 1600, "loss": 1.4740279912948608}
-{"method": "flowmo", "step": 1800, "loss": 1.3885352611541748}
-{"method": "flowmo", "step": 2000, "loss": 1.324019193649292}
-{"method": "flowmo", "step": 2200, "loss": 1.0553849935531616}
-{"method": "flowmo", "step": 2400, "loss": 0.6030915975570679}
-{"method": "flowmo", "step": 2600, "loss": 0.20210689306259155}
-{"method": "flowmo", "step": 2800, "loss": 0.14605776965618134}
-{"method": "flowmo", "step": 3000, "loss": 0.09821392595767975}
-{"method": "flowmo", "step": 3200, "loss": 0.07479490339756012}
-{"method": "flowmo", "step": 3400, "loss": 0.059080999344587326}
-{"method": "flowmo", "step": 3600, "loss": 0.051076825708150864}
-{"method": "flowmo", "step": 3800, "loss": 0.042308710515499115}
-{"method": "flowmo", "step": 4000, "loss": 0.040146660059690475}
-{"method": "flowmo", "step": 4200, "loss": 0.03381121903657913}
-{"method": "flowmo", "step": 4400, "loss": 0.033231284469366074}
-{"method": "flowmo", "step": 4600, "loss": 0.028457675129175186}
-{"method": "flowmo", "step": 4800, "loss": 0.029077233746647835}
-{"method": "flowmo", "step": 5000, "loss": 0.02207356132566929}
-{"method": "flowmo", "step": 5200, "loss": 0.020034978166222572}
-{"method": "flowmo", "step": 5400, "loss": 0.019785162061452866}
-{"method": "flowmo", "step": 5600, "loss": 0.018391719087958336}
-{"method": "flowmo", "step": 5800, "loss": 0.02175654098391533}
-{"method": "flowmo", "step": 6000, "loss": 0.015171783976256847}
-{"method": "flowmo", "step": 6200, "loss": 0.01452728919684887}
-{"method": "flowmo", "step": 6400, "loss": 0.013214356265962124}
-{"method": "flowmo", "step": 6600, "loss": 0.051673468202352524}
-{"method": "flowmo", "step": 6800, "loss": 0.018827352672815323}
-{"method": "flowmo", "step": 7000, "loss": 0.012735347263514996}
-{"method": "flowmo", "step": 7200, "loss": 0.011451991274952888}
-{"method": "flowmo", "step": 7400, "loss": 0.010433687828481197}
-{"method": "flowmo", "step": 7600, "loss": 0.010923548601567745}
-{"method": "flowmo", "step": 7800, "loss": 0.010971073061227798}
-{"method": "flowmo", "step": 8000, "loss": 0.009853748604655266}
-{"method": "flowmo", "step": 8200, "loss": 0.09088479727506638}
-{"method": "flowmo", "step": 8400, "loss": 0.034223418682813644}
-{"method": "flowmo", "step": 8600, "loss": 0.014456425793468952}
-{"method": "flowmo", "step": 8800, "loss": 0.009422067552804947}
-{"method": "flowmo", "step": 9000, "loss": 0.00858109537512064}
-{"method": "flowmo", "step": 9200, "loss": 0.00857796985656023}
-{"method": "flowmo", "step": 9400, "loss": 0.008296442218124866}
-{"method": "flowmo", "step": 9600, "loss": 0.008247998543083668}
-{"method": "flowmo", "step": 9800, "loss": 0.008240980096161366}
-{"method": "flowmo", "step": 10000, "loss": 0.008153271861374378}
-{"method": "flowmo", "step": 10200, "loss": 0.012404488399624825}
-{"method": "flowmo", "step": 10400, "loss": 0.013864593580365181}
-{"method": "flowmo", "step": 10600, "loss": 0.01010044477880001}
-{"method": "flowmo", "step": 10800, "loss": 0.00767604261636734}
-{"method": "flowmo", "step": 11000, "loss": 0.007007307838648558}
-{"method": "flowmo", "step": 11200, "loss": 0.0070138657465577126}
-{"method": "flowmo", "step": 11400, "loss": 0.007243836764246225}
-{"method": "flowmo", "step": 11600, "loss": 0.006900576408952475}
-{"method": "flowmo", "step": 11800, "loss": 0.0068667978048324585}
-{"method": "flowmo", "step": 12000, "loss": 0.006599605083465576}
-{"method": "flowmo", "step": 12200, "loss": 0.007158435881137848}
-{"method": "flowmo", "step": 12400, "loss": 0.045721929520368576}
-{"method": "flowmo", "step": 12600, "loss": 0.006790271960198879}
-{"method": "flowmo", "step": 12800, "loss": 0.0060927667655050755}
-{"method": "flowmo", "step": 13000, "loss": 0.005786360241472721}
-{"method": "flowmo", "step": 13200, "loss": 0.00602421211078763}
-{"method": "flowmo", "step": 13400, "loss": 0.005942641757428646}
-{"method": "flowmo", "step": 13600, "loss": 0.006074435543268919}
-{"method": "flowmo", "step": 13800, "loss": 0.021174009889364243}
-{"method": "flowmo", "step": 14000, "loss": 0.006621338427066803}
-{"method": "flowmo", "step": 14200, "loss": 0.005491666030138731}
-{"method": "flowmo", "step": 14400, "loss": 0.0051383040845394135}
-{"method": "flowmo", "step": 14600, "loss": 0.005117133259773254}
-{"method": "flowmo", "step": 14800, "loss": 0.0053353263065218925}
-{"method": "flowmo", "step": 15000, "loss": 0.00533561734482646}
-{"method": "flowmo", "step": 15200, "loss": 0.005121554713696241}
-{"method": "flowmo", "step": 15400, "loss": 0.005291329696774483}
-{"method": "flowmo", "step": 15600, "loss": 0.00511613953858614}
-{"method": "flowmo", "step": 15800, "loss": 0.005213129799813032}
-{"method": "flowmo", "step": 16000, "loss": 0.005071689374744892}
-{"method": "flowmo", "step": 16200, "loss": 0.0057407282292842865}
-{"method": "flowmo", "step": 16400, "loss": 0.0054640620946884155}
-{"method": "flowmo", "step": 16600, "loss": 0.005037755239754915}
-{"method": "flowmo", "step": 16800, "loss": 0.004956530407071114}
-{"method": "flowmo", "step": 17000, "loss": 0.24728184938430786}
-{"method": "flowmo", "step": 17200, "loss": 0.0358046218752861}
-{"method": "flowmo", "step": 17400, "loss": 0.005404628813266754}
-{"method": "flowmo", "step": 17600, "loss": 0.004861537832766771}
-{"method": "flowmo", "step": 17800, "loss": 0.0046697030775249004}
-{"method": "flowmo", "step": 18000, "loss": 0.00479076337069273}
-{"method": "flowmo", "step": 18200, "loss": 0.0045429919846355915}
-{"method": "flowmo", "step": 18400, "loss": 0.004368708468973637}
-{"method": "flowmo", "step": 18600, "loss": 0.004182927776128054}
-{"method": "flowmo", "step": 18800, "loss": 0.004190036095678806}
-{"method": "flowmo", "step": 19000, "loss": 0.004384973086416721}
-{"method": "flowmo", "step": 19200, "loss": 0.006023879628628492}
-{"method": "flowmo", "step": 19400, "loss": 0.004392072558403015}
-{"method": "flowmo", "step": 19600, "loss": 0.004413294140249491}
-{"method": "flowmo", "step": 19800, "loss": 0.004305647686123848}
-{"method": "flowmo", "step": 20000, "loss": 0.004372047260403633}

experiments/flowmo/result/parameter_count.json

@@ -1,11 +0,0 @@
-{
-  "encoder": 340416,
-  "state_history": 75648,
-  "context_history": 75648,
-  "to_z": 30960,
-  "to_c": 17544,
-  "base_delta": 45808,
-  "residual_delta": 46448,
-  "decoder": 31492,
-  "total": 663964
-}

experiments/leworldmodel/checkpoint/paper.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8837aa8f630fb2cc87f31b47c4df3f0cf207202247e1fffd066d668206fb8b5f
-size 2667147

experiments/leworldmodel/checkpoint/paper_step_002000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8670c6b88de48a2f724e55062f7650b4d47f4481e198a47656555957749c18c3
-size 2669155

experiments/leworldmodel/checkpoint/paper_step_004000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f09493171c08aa2ae742644344e12e1b8cc5515830cdead18bcf0684583d48cc
-size 2669155

experiments/leworldmodel/checkpoint/paper_step_006000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:53fa0a4b771dc3d9443309f449306b28a6175006220ae5a7a7261bf0f8bd0678
-size 2669155

experiments/leworldmodel/checkpoint/paper_step_008000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c7fca57df185e5a6cc9d03fb85c8d229a680a4dc6bbdf83d5a328b11bc073b0d
-size 2669155

experiments/leworldmodel/checkpoint/paper_step_010000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:43d43615527e310c1e29b5c9856a129b6fcd8401e9d55a14d37dfa29c154f4ef
-size 2669155

experiments/leworldmodel/checkpoint/paper_step_012000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8e6ee23f7ba9d61726ff278bef72b5e7ce578884d86acccb441599954dfaa927
-size 2669155

experiments/leworldmodel/checkpoint/paper_step_014000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:86ef98d7c0a6b51735b0d7ab996380b365b910849d824deca60d52cd4138d4d6
-size 2669155

experiments/leworldmodel/checkpoint/paper_step_016000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9670fe4385c12cb1a3411446d546ee1462fe57a1aea29810ee625e2d382a2564
-size 2669155

experiments/leworldmodel/checkpoint/paper_step_018000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:fe55552dc42dc83bcb47872f43b05a1909ea1f69d59f6fe9ba977c1ca9d5140f
-size 2669155

experiments/leworldmodel/checkpoint/paper_step_020000.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:641ef4793bde88c7570d3811bf0d931adae7455cfc9d477dadb0b088878ea37b
-size 2669155

experiments/leworldmodel/result/paper_training.json

@@ -1,43 +0,0 @@
-{
-  "method": "leworldmodel",
-  "steps": 20000,
-  "batch_size": 256,
-  "train_samples": 5120000,
-  "final_train_loss": 0.018198927864432335,
-  "total_parameters": 664612,
-  "target_mode": "absolute_normalized",
-  "position_scale": 5.0,
-  "heading_weight": 2.0,
-  "current_pose_weight": 1.0,
-  "motion_weight": 0.5,
-  "precision": "bf16",
-  "checkpoint_name": "paper.pt",
-  "final_checkpoint": "paper.pt",
-  "intermediate_checkpoints": [
-    "paper_step_002000.pt",
-    "paper_step_004000.pt",
-    "paper_step_006000.pt",
-    "paper_step_008000.pt",
-    "paper_step_010000.pt",
-    "paper_step_012000.pt",
-    "paper_step_014000.pt",
-    "paper_step_016000.pt",
-    "paper_step_018000.pt",
-    "paper_step_020000.pt"
-  ],
-  "checkpoint_interval": 2000,
-  "prediction": {
-    "pos1": 0.10107660254773994,
-    "heading1": 0.0479962204505379,
-    "pos3": 0.11733688049328823,
-    "heading3": 0.054719595277371504,
-    "pos6": 0.14297669551645717,
-    "heading6": 0.0649993756475548,
-    "pos8": 0.1607180543554326,
-    "heading8": 0.07113518511566023,
-    "pos10": 0.1783415130339563,
-    "heading10": 0.07669965278667708,
-    "pos20": 0.25807287978629273,
-    "heading20": 0.0995667139844348
-  }
-}

experiments/leworldmodel/result/paper_training_trace.jsonl

@@ -1,100 +0,0 @@
-{"method": "leworldmodel", "step": 200, "loss": 2.569669246673584}
-{"method": "leworldmodel", "step": 400, "loss": 2.5372421741485596}
-{"method": "leworldmodel", "step": 600, "loss": 2.037346363067627}
-{"method": "leworldmodel", "step": 800, "loss": 1.8627333641052246}
-{"method": "leworldmodel", "step": 1000, "loss": 1.8265268802642822}
-{"method": "leworldmodel", "step": 1200, "loss": 1.7777857780456543}
-{"method": "leworldmodel", "step": 1400, "loss": 1.753949522972107}
-{"method": "leworldmodel", "step": 1600, "loss": 1.7200227975845337}
-{"method": "leworldmodel", "step": 1800, "loss": 1.6717208623886108}
-{"method": "leworldmodel", "step": 2000, "loss": 1.391864538192749}
-{"method": "leworldmodel", "step": 2200, "loss": 0.7442419528961182}
-{"method": "leworldmodel", "step": 2400, "loss": 0.2299843579530716}
-{"method": "leworldmodel", "step": 2600, "loss": 0.13865336775779724}
-{"method": "leworldmodel", "step": 2800, "loss": 0.09015313535928726}
-{"method": "leworldmodel", "step": 3000, "loss": 0.06993035972118378}
-{"method": "leworldmodel", "step": 3200, "loss": 0.05781794339418411}
-{"method": "leworldmodel", "step": 3400, "loss": 0.05077105388045311}
-{"method": "leworldmodel", "step": 3600, "loss": 0.043729424476623535}
-{"method": "leworldmodel", "step": 3800, "loss": 0.040191106498241425}
-{"method": "leworldmodel", "step": 4000, "loss": 0.03818749263882637}
-{"method": "leworldmodel", "step": 4200, "loss": 0.03584111109375954}
-{"method": "leworldmodel", "step": 4400, "loss": 0.03268589824438095}
-{"method": "leworldmodel", "step": 4600, "loss": 0.030512923374772072}
-{"method": "leworldmodel", "step": 4800, "loss": 0.028514141216874123}
-{"method": "leworldmodel", "step": 5000, "loss": 0.026582585647702217}
-{"method": "leworldmodel", "step": 5200, "loss": 0.02657574787735939}
-{"method": "leworldmodel", "step": 5400, "loss": 0.03360811248421669}
-{"method": "leworldmodel", "step": 5600, "loss": 0.024245228618383408}
-{"method": "leworldmodel", "step": 5800, "loss": 0.025151818990707397}
-{"method": "leworldmodel", "step": 6000, "loss": 0.02470393292605877}
-{"method": "leworldmodel", "step": 6200, "loss": 0.022554941475391388}
-{"method": "leworldmodel", "step": 6400, "loss": 0.021832682192325592}
-{"method": "leworldmodel", "step": 6600, "loss": 0.02138935960829258}
-{"method": "leworldmodel", "step": 6800, "loss": 0.021714694797992706}
-{"method": "leworldmodel", "step": 7000, "loss": 0.022361399605870247}
-{"method": "leworldmodel", "step": 7200, "loss": 0.021948281675577164}
-{"method": "leworldmodel", "step": 7400, "loss": 0.023297373205423355}
-{"method": "leworldmodel", "step": 7600, "loss": 0.01953437551856041}
-{"method": "leworldmodel", "step": 7800, "loss": 0.019761236384510994}
-{"method": "leworldmodel", "step": 8000, "loss": 0.018553584814071655}
-{"method": "leworldmodel", "step": 8200, "loss": 0.01823526993393898}
-{"method": "leworldmodel", "step": 8400, "loss": 0.01854352466762066}
-{"method": "leworldmodel", "step": 8600, "loss": 0.019154751673340797}
-{"method": "leworldmodel", "step": 8800, "loss": 0.018928799778223038}
-{"method": "leworldmodel", "step": 9000, "loss": 0.01909957453608513}
-{"method": "leworldmodel", "step": 9200, "loss": 0.018046768382191658}
-{"method": "leworldmodel", "step": 9400, "loss": 0.016244517639279366}
-{"method": "leworldmodel", "step": 9600, "loss": 0.016833283007144928}
-{"method": "leworldmodel", "step": 9800, "loss": 0.01727704517543316}
-{"method": "leworldmodel", "step": 10000, "loss": 0.017903970554471016}
-{"method": "leworldmodel", "step": 10200, "loss": 0.01650647632777691}
-{"method": "leworldmodel", "step": 10400, "loss": 0.015822188928723335}
-{"method": "leworldmodel", "step": 10600, "loss": 0.021761486306786537}
-{"method": "leworldmodel", "step": 10800, "loss": 0.01572641171514988}
-{"method": "leworldmodel", "step": 11000, "loss": 0.014744052663445473}
-{"method": "leworldmodel", "step": 11200, "loss": 0.014771764166653156}
-{"method": "leworldmodel", "step": 11400, "loss": 0.015161859802901745}
-{"method": "leworldmodel", "step": 11600, "loss": 0.015039228834211826}
-{"method": "leworldmodel", "step": 11800, "loss": 0.01450162474066019}
-{"method": "leworldmodel", "step": 12000, "loss": 0.014639433473348618}
-{"method": "leworldmodel", "step": 12200, "loss": 0.014432272873818874}
-{"method": "leworldmodel", "step": 12400, "loss": 0.05746567249298096}
-{"method": "leworldmodel", "step": 12600, "loss": 0.01567252166569233}
-{"method": "leworldmodel", "step": 12800, "loss": 0.013239766471087933}
-{"method": "leworldmodel", "step": 13000, "loss": 0.01337014976888895}
-{"method": "leworldmodel", "step": 13200, "loss": 0.013945686630904675}
-{"method": "leworldmodel", "step": 13400, "loss": 0.013215066865086555}
-{"method": "leworldmodel", "step": 13600, "loss": 0.013161891140043736}
-{"method": "leworldmodel", "step": 13800, "loss": 0.013161612674593925}
-{"method": "leworldmodel", "step": 14000, "loss": 0.013272494077682495}
-{"method": "leworldmodel", "step": 14200, "loss": 0.012501145713031292}
-{"method": "leworldmodel", "step": 14400, "loss": 0.01319703459739685}
-{"method": "leworldmodel", "step": 14600, "loss": 0.01253820862621069}
-{"method": "leworldmodel", "step": 14800, "loss": 0.013268169946968555}
-{"method": "leworldmodel", "step": 15000, "loss": 0.012286090292036533}
-{"method": "leworldmodel", "step": 15200, "loss": 0.012689301744103432}
-{"method": "leworldmodel", "step": 15400, "loss": 0.018598034977912903}
-{"method": "leworldmodel", "step": 15600, "loss": 0.011223368346691132}
-{"method": "leworldmodel", "step": 15800, "loss": 0.011263682506978512}
-{"method": "leworldmodel", "step": 16000, "loss": 0.011280846782028675}
-{"method": "leworldmodel", "step": 16200, "loss": 0.011259369552135468}
-{"method": "leworldmodel", "step": 16400, "loss": 0.012492901645600796}
-{"method": "leworldmodel", "step": 16600, "loss": 0.011446918360888958}
-{"method": "leworldmodel", "step": 16800, "loss": 0.01105540618300438}
-{"method": "leworldmodel", "step": 17000, "loss": 0.010708491317927837}
-{"method": "leworldmodel", "step": 17200, "loss": 0.01076575368642807}
-{"method": "leworldmodel", "step": 17400, "loss": 0.010710487142205238}
-{"method": "leworldmodel", "step": 17600, "loss": 0.010570250451564789}
-{"method": "leworldmodel", "step": 17800, "loss": 0.010576384142041206}
-{"method": "leworldmodel", "step": 18000, "loss": 0.011023864150047302}
-{"method": "leworldmodel", "step": 18200, "loss": 0.010448881424963474}
-{"method": "leworldmodel", "step": 18400, "loss": 0.010450177825987339}
-{"method": "leworldmodel", "step": 18600, "loss": 0.010127122513949871}
-{"method": "leworldmodel", "step": 18800, "loss": 0.010028455406427383}
-{"method": "leworldmodel", "step": 19000, "loss": 0.010146670043468475}
-{"method": "leworldmodel", "step": 19200, "loss": 0.010228784754872322}
-{"method": "leworldmodel", "step": 19400, "loss": 0.009929011575877666}
-{"method": "leworldmodel", "step": 19600, "loss": 0.009595287963747978}
-{"method": "leworldmodel", "step": 19800, "loss": 0.00958178285509348}
-{"method": "leworldmodel", "step": 20000, "loss": 0.018198927864432335}

experiments/leworldmodel/result/parameter_count.json

@@ -1,7 +0,0 @@
-{
-  "encoder": 471584,
-  "to_z": 43328,
-  "transition": 87104,
-  "decoder": 62596,
-  "total": 664612
-}

experiments/planet/checkpoint/paper.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6ad00b1fb32dbdf8bd8e3346f33809449b3e322b2d8c63215122b4d2b6037281
-size 2667969