Make corrected-data epoch-30 FasterWAM current; move previous run under old

LATEST_RESULTS.md

@@ -1,3 +1,13 @@
+# Latest publication — September 19, 2026
+
+Current joint FasterWAM: [job 4414, epoch 30](joint/fasterwam/train90_joint_job4414/README.md), native step 87,930, trained jointly on fruit_pick, dish_utensil, place_cube and push_t. Dataset revision `4ad42310b4408ff08370124e680e3a20ad267b1e` contains the validated corrected place_cube spatial crops. All four task embeddings and joint normalization are included. Sampled validation: loss 0.2390, action L1 0.0042, action L2/MSE 0.0017, PSNR 30.0401, SSIM 0.8902 (rounded log values, not robot success measurements).
+
+This checkpoint was saved before the user-requested time limit. The run was configured for 50 epochs but stopped later at that limit; this publication contains epoch 30 only. The previous job 4247 run is archived under [joint/fasterwam/old/](joint/fasterwam/old/README.md), with its original files preserved.
+
+The following September 16 results are historical and predate the place_cube correction.
+
+---
+
 # Latest completed training results — September 16, 2026
 
 These five runs completed on the canonical 90/10 episode split. Each was trained on four H200 GPUs with global batch 32. This update publishes three inference checkpoints spread across each run, including the final checkpoint. Optimizer state remains local; the tables below report the final checkpoint metrics.

README.md

@@ -20,6 +20,12 @@ Each run includes its original checkpoint format and inference/training metadata
 
 See [CHECKPOINT_UPLOADS.md](CHECKPOINT_UPLOADS.md) for the upload contract and commands, [checkpoint_layout.json](checkpoint_layout.json) for the path schema, and [hf_checkpoint_imports.json](hf_checkpoint_imports.json) for pinned source revisions and file hashes. Imported run READMEs retain their original training and evaluation limitations; these historical runs are not asserted to use the current benchmark split.
 
+## Current joint FasterWAM — September 19, 2026
+
+[Job 4414, epoch 30](joint/fasterwam/train90_joint_job4414/README.md) is the current joint FasterWAM checkpoint, trained on all four datasets with corrected place_cube crops (dataset revision `4ad42310b4408ff08370124e680e3a20ad267b1e`). Native checkpoint: `step_087930.pt`; 8 H200 GPUs; 360 train / 40 held-out episodes. Inference weights and matching config, normalization, task embeddings, source and validation provenance are included. The run stopped at its requested time limit after saving epoch 30; it did not complete the planned 50 epochs.
+
+The previous joint FasterWAM run, job 4247, is preserved under [joint/fasterwam/old/](joint/fasterwam/old/README.md). Its place_cube crops were invalid and it is superseded by job 4414.
+
 ## Imported archives
 
 | Source | Run folder |

hf_local_checkpoint_runs.json

@@ -116,6 +116,82 @@
       "task": "place_cube",
       "training_status": "complete",
       "wandb_run": "https://wandb.ai/aabyaneh/fasterwam-real/runs/ilkye0g0"
+    },
+    {
+      "bytes": 31086341628,
+      "checkpoint_contents": "three inference checkpoints and matching metadata",
+      "checkpoint_epochs": [
+        10,
+        20,
+        30
+      ],
+      "completed_updates": 94160,
+      "ended_utc": "2026-09-17T15:38:29Z",
+      "final_checkpoint_step": 87930,
+      "final_metrics": {},
+      "includes_training_state": false,
+      "last_logged_training_step": 94160,
+      "model": "fasterwam",
+      "native_checkpoint_steps": [
+        29310,
+        58620,
+        87930
+      ],
+      "planned_epochs": 50,
+      "prepared_bundle": "train_out/hf_uploads/fasterwam_joint_train90_joint_job4247",
+      "run_id": "train90_joint_job4247",
+      "source_dir": "fastwam_train/runs/joint_all4_fasterwam/2026-09-17_04-15-26_job4247",
+      "task": "joint",
+      "training_status": "cancelled_by_user",
+      "wandb_run": "https://wandb.ai/aabyaneh/fasterwam-real/runs/pp7o49m6",
+      "verified_commit": "68669a419e3ab75fe9841daebb8642c31ce9ba06",
+      "publication_status": "archived",
+      "repo_prefix": "joint/fasterwam/old/train90_joint_job4247",
+      "archive_reason": "Superseded: trained with invalid place_cube spatial crops",
+      "superseded_by": "joint/fasterwam/train90_joint_job4414"
+    },
+    {
+      "schema_version": 1,
+      "task": "joint",
+      "model": "fasterwam",
+      "run_id": "train90_joint_job4414",
+      "slurm_job": 4414,
+      "native_checkpoint_steps": [
+        87930
+      ],
+      "checkpoint_epochs": [
+        30
+      ],
+      "final_checkpoint_step": 87930,
+      "published_checkpoint_updates": 87930,
+      "last_logged_training_step": 100800,
+      "planned_epochs": 50,
+      "training_status": "time_limit_at_user_requested_deadline",
+      "ended_utc": "2026-09-19T12:01:03Z",
+      "checkpoint_saved_utc": "2026-09-19T10:26:15Z",
+      "includes_training_state": false,
+      "training_gpus": 8,
+      "global_batch_size": 32,
+      "train_episodes": 360,
+      "validation_episodes": 40,
+      "dataset_revision": "4ad42310b4408ff08370124e680e3a20ad267b1e",
+      "code_revision": "19483b8b1b6a72e697091a07e7df7777aa09fd85",
+      "base_model": "Wan-AI/Wan2.2-TI2V-5B",
+      "prompts": {
+        "fruit_pick": "Lift the lid, put it aside, and pick the black plum.",
+        "dish_utensil": "pick the dishes out of the rack and place them on the table, then pick and place the spoon to the gray dish and fork to the pink dish",
+        "place_cube": "place the cube in the bowl",
+        "push_t": "push the T block to the target outline"
+      },
+      "source_dir": "fastwam_train/runs/joint_all4_fasterwam/2026-09-18_23-28-49_job4414",
+      "wandb_run": "https://wandb.ai/aabyaneh/fasterwam-real/runs/bct4y3en",
+      "integrity_inventory": "upload_manifest.json",
+      "robot_evaluation": "not performed",
+      "repo_prefix": "joint/fasterwam/train90_joint_job4414",
+      "publication_status": "published_verified",
+      "prepared_bundle": "train_out/hf_uploads/fasterwam_joint_train90_joint_job4414",
+      "checkpoint_contents": "epoch-30 inference weights, config, normalization, all four task embeddings, code and corrected-data provenance",
+      "verified_upload_commit": "870cf97d4d8ca9bf5c9c6a71eb7f903559617cb6"
     }
   ]
 }

joint/fasterwam/README.md

@@ -1,7 +1,7 @@
-# joint / fasterwam
+# Joint FasterWAM
 
-Checkpoints trained jointly on all four tasks belong here. Publish each joint run once.
+Current: [train90_joint_job4414 — epoch 30](train90_joint_job4414/README.md).
 
-Store each run under `<run_id>/`, with weights under `checkpoints/` and the matching config, normalization, conditioning and run metadata alongside. This README reserves the folder; it does not indicate that weights are available.
+Native weights: [step_087930.pt](train90_joint_job4414/checkpoints/weights/step_087930.pt). Trained jointly on fruit_pick, dish_utensil, place_cube and push_t, with the corrected and validated place_cube dataset revision `4ad42310b4408ff08370124e680e3a20ad267b1e`.
 
-See the [upload guide](../../CHECKPOINT_UPLOADS.md).
+[Old runs](old/README.md) preserve the previous job 4247 weights and metadata. Those weights used invalid place_cube crops and are superseded.

joint/fasterwam/old/ARCHIVE_PROVENANCE.json

@@ -0,0 +1,724 @@
+{
+  "commit": "e73433f58cd3b4e2266fc6b759ca0f54ceae1af7",
+  "source_revision": "a99226d389334830c413f8a419dff39560ee8b89",
+  "source_prefix": "joint/fasterwam/train90_joint_job4247/",
+  "archive_prefix": "joint/fasterwam/old/train90_joint_job4247/",
+  "verified_files": 119,
+  "reason": "Invalid place_cube spatial crops; superseded by job4414",
+  "files": [
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/README.md",
+      "size": 1082,
+      "sha256": null,
+      "blob_id": "e8ea7671120730ba22d5c4fa1ddc6f137546bdc1"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/checkpoints/weights/step_029310.pt",
+      "size": 10360250873,
+      "sha256": "714b360d124faa1eccef880ef97916250bf9b267f84276f9c5235f239fb55ab3",
+      "blob_id": "7bc1b60d59bd1830ae034645b582de3cf16a5e7c"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/checkpoints/weights/step_058620.pt",
+      "size": 10360250873,
+      "sha256": "229abf320895323b87f42dae740a0b7c9cd8d03860b3a313d3d7e7c9a98fba91",
+      "blob_id": "7f32e0496b6e7f64c32fc8af496e9cf3c12f013e"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/checkpoints/weights/step_087930.pt",
+      "size": 10360250873,
+      "sha256": "0a2e5a3592cfb6d02682183b746e6009300e080d753d22b400b08820d4e1d8c4",
+      "blob_id": "284bfd8f838ae78a8fe25071ed6dfcb84212e709"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/conditioning/dish_utensil/tasks.jsonl",
+      "size": 163,
+      "sha256": null,
+      "blob_id": "4889ce572a4fba78e9b0c0db49e2e3139895057e"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/conditioning/fruit_pick/tasks.jsonl",
+      "size": 82,
+      "sha256": null,
+      "blob_id": "1cf9cc95bcf3b7cd93dd6c318c9e5266df517aee"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/conditioning/index.json",
+      "size": 1651,
+      "sha256": null,
+      "blob_id": "a08f8e4eb5d5765b5ffa7fb33d11180b0e366121"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/conditioning/place_cube/tasks.jsonl",
+      "size": 56,
+      "sha256": null,
+      "blob_id": "2f1a8277b173ab2a3a0e7321a424921f32b5ee5c"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/conditioning/prompts.json",
+      "size": 330,
+      "sha256": null,
+      "blob_id": "c4d04fa855239969c2853d2a54ed4188d1549db9"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/conditioning/push_t/tasks.jsonl",
+      "size": 68,
+      "sha256": null,
+      "blob_id": "1dedddb57ce3fb271987779e8b688f196a06ffd8"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/conditioning/text_embeds_cache/3331746089cf26d56af486af1ef7035e746c2e823cc957e2e3b7a0c3baf347ef.t5_len128.wan22ti2v5b.pt",
+      "size": 1051869,
+      "sha256": "7ddfc1a78ca521bc8793e4a58e8c1f4fa55d83274ae0026483888d21521e5855",
+      "blob_id": "ff38e930fb2171e06a66a825b02c59071a9d5991"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/conditioning/text_embeds_cache/531e2910f4efdc285bcefbeca24a8a1ff789d6c4365dfd7c15de4eda9eb89f6b.t5_len128.wan22ti2v5b.pt",
+      "size": 1051869,
+      "sha256": "c676ff34af5f0fd05efa441912d0b94569a824caafa5778847b9a885a79c1e23",
+      "blob_id": "40c9e1771938248f3a82f545d8a212f501372235"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/conditioning/text_embeds_cache/6bbe3e745d0bcd06a540d3d895af431a769ae466d0cf1102bcee7979ba41e95b.t5_len128.wan22ti2v5b.pt",
+      "size": 1051869,
+      "sha256": "f4d0befa15744dccbba163d380fd62e8c0ca8bffc6b5271f200d527abc23d200",
+      "blob_id": "b2aab59f6efd38faebc888e4561bebabf897c2f5"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/conditioning/text_embeds_cache/71cb088954da46da4e3cb6c6f73ac812690e9bccf886c7858377c61918b4e3e8.t5_len128.wan22ti2v5b.pt",
+      "size": 1051869,
+      "sha256": "85b8468de72c7e7c481fe968d6ab5164d3b3c694f64b7037ec2d05fa706c73c6",
+      "blob_id": "897035aef7e7c67b5888ba6ac7e4bc7f3db82f60"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/config.yaml",
+      "size": 8668,
+      "sha256": null,
+      "blob_id": "7c71304ca5cdeb48c17118080c7c6719b1819a2e"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/dataset_stats.json",
+      "size": 40087,
+      "sha256": null,
+      "blob_id": "700f9c798742497fbe3b831a5e7f708234f22961"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/manifest.json",
+      "size": 1737,
+      "sha256": null,
+      "blob_id": "385eea812f62fc92e0b89255c4a6ead3770a491b"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/provenance/code.json",
+      "size": 814,
+      "sha256": null,
+      "blob_id": "0f4e4c5550b1c1efeeaa760d3b7e6b87ad87f5e2"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/provenance/implementation.json",
+      "size": 42911,
+      "sha256": null,
+      "blob_id": "8c655b29d8501a4ad76f034bc66d1c2b7711f6bb"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/provenance/training.log",
+      "size": 4024180,
+      "sha256": null,
+      "blob_id": "6aa04b0e02ac670b53ddadfcde85e16fd38bdce3"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/provenance/training_summary.json",
+      "size": 66,
+      "sha256": null,
+      "blob_id": "89dc1ccdf4dd67a320bba366f9805bd86f9d4519"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/requirements.txt",
+      "size": 4136,
+      "sha256": null,
+      "blob_id": "9170e47ace8e1b0b2c76374d13fdb864e9a5825b"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/splits/dish_utensil_lerobot_v21.json",
+      "size": 1340,
+      "sha256": null,
+      "blob_id": "dceff5f8f43f54d6fe4f011848210a0c01276820"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/splits/fruit_pick_lerobot_v21.json",
+      "size": 1336,
+      "sha256": null,
+      "blob_id": "c079faa8f98ae706d44fe91c105a24a88f320eec"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/splits/place_cube_lerobot_v21.json",
+      "size": 1333,
+      "sha256": null,
+      "blob_id": "50da50bfb6f4e1bf0a0a68313388c91e59ac140f"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/splits/push_t_lerobot_v21.json",
+      "size": 1328,
+      "sha256": null,
+      "blob_id": "521fe4a4f96b004d0ddc54c1b8340fc5e8955319"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/LICENSE",
+      "size": 1210,
+      "sha256": null,
+      "blob_id": "90124d129334cd5de11aa0fd606182b3ffd442cb"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/pyproject.toml",
+      "size": 1152,
+      "sha256": null,
+      "blob_id": "853bc3e032f6cc85ff20f2338f8418976b69a615"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/scripts/train.py",
+      "size": 543,
+      "sha256": null,
+      "blob_id": "f0a3b5e2467eef86eb7deac5305a33d1cc00bcf7"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/__init__.py",
+      "size": 23,
+      "sha256": null,
+      "blob_id": "f40dcb36ffb7cb5999600c8d9520cd72e3f60af0"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/__init__.py",
+      "size": 0,
+      "sha256": null,
+      "blob_id": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/aligned_3dpft.py",
+      "size": 4311,
+      "sha256": null,
+      "blob_id": "e18d746558f8cda87966946151f5a425d47d6363"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/dataset_utils.py",
+      "size": 3735,
+      "sha256": null,
+      "blob_id": "e7d5830119dd42c492ec3ba5c01081c26b836d71"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/eef_anchors.py",
+      "size": 12039,
+      "sha256": null,
+      "blob_id": "d1a2b97271c6c10a9514430605fdac99315d5dea"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/base_lerobot_dataset.py",
+      "size": 23105,
+      "sha256": null,
+      "blob_id": "227fb9ee707369162bc1cc2c16fa1b96a1729a7a"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/constants.py",
+      "size": 1915,
+      "sha256": null,
+      "blob_id": "30777239efdfa096bfefbc0f2d729e8f36da90ca"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/lerobot/datasets/compute_stats.py",
+      "size": 7067,
+      "sha256": null,
+      "blob_id": "df26818f654de1410ccdab2306a85ca4070b761b"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/lerobot/datasets/utils.py",
+      "size": 36236,
+      "sha256": null,
+      "blob_id": "dd382df529058e4edcf202cde1eef54170e21863"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/lerobot/datasets/video_utils.py",
+      "size": 19421,
+      "sha256": null,
+      "blob_id": "9dd6fee91c9d867d5a0f4540e5ae0713b7f753dc"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/lerobot/lerobot_dataset.py",
+      "size": 60778,
+      "sha256": null,
+      "blob_id": "ef5d5e50235f051c8919c9a635c25a3289215c02"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/processors/base_processor.py",
+      "size": 10811,
+      "sha256": null,
+      "blob_id": "39d1665b6f0da68060fad7a120241577301a6139"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/processors/fastwam_processor.py",
+      "size": 15064,
+      "sha256": null,
+      "blob_id": "e06eb0246a6443f7dcd1052582f3cad41dd05f37"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/robot_video_dataset.py",
+      "size": 20540,
+      "sha256": null,
+      "blob_id": "b7b682a760a2671104c5cbcae7e63e077a68a249"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/transforms/action_state_merger.py",
+      "size": 2522,
+      "sha256": null,
+      "blob_id": "0a35644a4fbc65a5cb6abe3f642f4af35a4e438b"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/transforms/image.py",
+      "size": 725,
+      "sha256": null,
+      "blob_id": "8dbeda01c09dd57bc772ad4d53cf8b49586a2d06"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/transforms/misc.py",
+      "size": 422,
+      "sha256": null,
+      "blob_id": "49279d6888f565078aafbcc3a830584bb34515a5"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/transforms/relative_action.py",
+      "size": 5423,
+      "sha256": null,
+      "blob_id": "5e4df6dbf0e131e9093ae7e2e149dcdc9823801f"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/transforms/rotation.py",
+      "size": 5603,
+      "sha256": null,
+      "blob_id": "4f19924703f4274401f01537180aae11f9bc84c7"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/utils/normalizer.py",
+      "size": 11274,
+      "sha256": null,
+      "blob_id": "1c674b0234bcf3cf1a1bef0f8fc0523020449b4a"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/utils/rotation.py",
+      "size": 21110,
+      "sha256": null,
+      "blob_id": "f468cd4f24092bfe8a601a85e2cb8e5e6b84cbbb"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/robotwin_aligned_3dpft.py",
+      "size": 4506,
+      "sha256": null,
+      "blob_id": "e601786919c6f4723924c6ef0bc16984348a3c7e"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/video_latent_cache.py",
+      "size": 19138,
+      "sha256": null,
+      "blob_id": "ce28d1193029023b115d3a63b8cd4480c3f1b7a0"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/geometry/__init__.py",
+      "size": 3140,
+      "sha256": null,
+      "blob_id": "a710f4c422f5b6c459c1404112b173f60569dc20"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/geometry/bearing.py",
+      "size": 7646,
+      "sha256": null,
+      "blob_id": "3491b9a307ab752fe0005e6daa3410f4eeb9ca2e"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/geometry/calibration.py",
+      "size": 15987,
+      "sha256": null,
+      "blob_id": "177eac6a5383929a16be17ccfb8283512c270992"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/geometry/camera_source.py",
+      "size": 5050,
+      "sha256": null,
+      "blob_id": "9cab1f86c82968633b4efef4df5ce001c7808f60"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/geometry/control_rope.py",
+      "size": 4168,
+      "sha256": null,
+      "blob_id": "6bb696b07899fcd4c0b49771be8aca39b9c726ac"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/geometry/eef_projector.py",
+      "size": 41068,
+      "sha256": null,
+      "blob_id": "eb813ce6bbd97aef8fc6893c7b24e25de05504c8"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/geometry/flow_context.py",
+      "size": 4745,
+      "sha256": null,
+      "blob_id": "dfc3ce73445ca45a74f6d8e42d2973dbc3d0056f"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/geometry/flow_trajectory.py",
+      "size": 12820,
+      "sha256": null,
+      "blob_id": "aa2a7bae6aca961f5cfa536b72416708422a8400"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/geometry/identity.py",
+      "size": 5463,
+      "sha256": null,
+      "blob_id": "7322cadc38c3b9524f23d0270a8b5f7cb5b8b103"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/geometry/plus_anchors.py",
+      "size": 17643,
+      "sha256": null,
+      "blob_id": "155e35f69a054c091fae01cb82591f6b436fa9ee"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/geometry/prox_pinhole.py",
+      "size": 3570,
+      "sha256": null,
+      "blob_id": "63525b5f4a848216b057e047aa4c8e5e9d611bf5"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/geometry/robotwin_flow.py",
+      "size": 21052,
+      "sha256": null,
+      "blob_id": "1ae33b25208913cf44e85f195429c173bf0fd194"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/geometry/weak_perspective.py",
+      "size": 5089,
+      "sha256": null,
+      "blob_id": "7f16f51493fdc5c1957c6a4efa5b2d9b20c6d953"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/lr_schedules.py",
+      "size": 7988,
+      "sha256": null,
+      "blob_id": "df51864620d37bc7988f17e6e358a3a58189405b"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/__init__.py",
+      "size": 35,
+      "sha256": null,
+      "blob_id": "f45b7d25cd81883bbc40b37fd6366225d1e84105"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/__init__.py",
+      "size": 0,
+      "sha256": null,
+      "blob_id": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/action_dit.py",
+      "size": 52467,
+      "sha256": null,
+      "blob_id": "cd095affb62d566b059ad381b5454d943a00e307"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/action_mlp.py",
+      "size": 9289,
+      "sha256": null,
+      "blob_id": "5417e8e8874304c0609436e1af17ca9d84a65032"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/action_proprio_jitter.py",
+      "size": 7732,
+      "sha256": null,
+      "blob_id": "e2852c5faf003256cd851c1d022c806820889166"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/aligned_3dpft.py",
+      "size": 14891,
+      "sha256": null,
+      "blob_id": "876e508f059e13cab19f760b8f5ab2f2f0cff4e7"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/aligned_3dpft_x0.py",
+      "size": 11619,
+      "sha256": null,
+      "blob_id": "a0e589a4cf955e223116b1e668b01ef05741f34e"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/attn_offset_head_anchor.py",
+      "size": 10748,
+      "sha256": null,
+      "blob_id": "1a58ca9cdcdbc333e4cae94898e08b530c346ea6"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/control_rope.py",
+      "size": 7260,
+      "sha256": null,
+      "blob_id": "3149d1a5360bd2c3d5ced44a0750d7ef3c279ec3"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/controlnet_pp.py",
+      "size": 10714,
+      "sha256": null,
+      "blob_id": "5bb451df634f1fd2469f9e901bbd75d9d848454c"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/fasterwam_decoupled.py",
+      "size": 83098,
+      "sha256": null,
+      "blob_id": "8c9791ef4925fbed2976c4febd5309b72b4b98dc"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/fastwam.py",
+      "size": 89934,
+      "sha256": null,
+      "blob_id": "a7adf6a70cf493de36e96ed8de627362d902dc7c"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/fastwam_action_mlp.py",
+      "size": 21755,
+      "sha256": null,
+      "blob_id": "28daaff52e33cc945c11461a7bab52c13406d6cb"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/fastwam_decoupled.py",
+      "size": 59696,
+      "sha256": null,
+      "blob_id": "f12470812b4c8db6e4d6983573370df5b330093e"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/fastwam_idm.py",
+      "size": 20353,
+      "sha256": null,
+      "blob_id": "d21d69b3ac9a83f931e6d1018b17202d49e1b788"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/fastwam_joint.py",
+      "size": 10088,
+      "sha256": null,
+      "blob_id": "c0604f15536c5f433ea68faa02284e56088d9260"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/ha_content_pp.py",
+      "size": 3395,
+      "sha256": null,
+      "blob_id": "1893e772fdd9fda4e2f01848e69cd06c973a341c"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/helpers/__init__.py",
+      "size": 415,
+      "sha256": null,
+      "blob_id": "35bac73c6b329a83d34b02e39a12012305879347"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/helpers/gradient.py",
+      "size": 565,
+      "sha256": null,
+      "blob_id": "636ef5c2e29a96553bfc6d21e47c70506a3831f4"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/helpers/io.py",
+      "size": 7751,
+      "sha256": null,
+      "blob_id": "26d65d08cfa52a40c6e41d4e6b1d9fd4b65843b6"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/helpers/loader.py",
+      "size": 8279,
+      "sha256": null,
+      "blob_id": "99d92ff409fb104c6ebf8cc29905baa12d80e28f"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/helpers/state_dict_converters.py",
+      "size": 5226,
+      "sha256": null,
+      "blob_id": "3a83b5c554d79278c3b73859eea092a78f3ec528"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/iha.py",
+      "size": 7474,
+      "sha256": null,
+      "blob_id": "65e167e35f562e80544ba49178ac7f59871502b9"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/kv_fusion.py",
+      "size": 5917,
+      "sha256": null,
+      "blob_id": "021c5cb471cf7756bb42cf8f00948ae6b8b9ba90"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/learnable_head_anchor.py",
+      "size": 4046,
+      "sha256": null,
+      "blob_id": "866a7779829795a2a6bbc1d32c4fdd2efaf284de"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/mot.py",
+      "size": 23212,
+      "sha256": null,
+      "blob_id": "dfb1a7cfe4b299c3d99d5a118f7728f24069ed0c"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/mot_decoupled.py",
+      "size": 89831,
+      "sha256": null,
+      "blob_id": "2ec4f3931f07ddf3fd5977e1b95f1c8d847a7b15"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/offset_head_anchor.py",
+      "size": 10467,
+      "sha256": null,
+      "blob_id": "1ee79a69c81c082f1b9c01e9310995e49d3c9d22"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/piha.py",
+      "size": 4158,
+      "sha256": null,
+      "blob_id": "a55946e05d6595bd56e4a30f2fc8661e4e6c92a9"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/piha_post_rope_kv.py",
+      "size": 6922,
+      "sha256": null,
+      "blob_id": "47e8fcab87fc3bed9a8f86b94d3ff4fd0cb13523"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/proprio_offset_head_anchor.py",
+      "size": 7182,
+      "sha256": null,
+      "blob_id": "99404ba80dff7aa5372726052f188ac7aae8d0b8"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/robotwin_aligned_3dpft.py",
+      "size": 9908,
+      "sha256": null,
+      "blob_id": "6c4bd2baa2b3d7676e5ee9ff00a6372e12f0e54d"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/schedulers/scheduler_continuous.py",
+      "size": 4068,
+      "sha256": null,
+      "blob_id": "9028f6c86e2e35bc9efd75dda26d9cf88ff898bb"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/text_ca_dropout.py",
+      "size": 15007,
+      "sha256": null,
+      "blob_id": "389bda2abf6c557801f7a2bbbc7527ee950cb69e"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/viewlocal_ha_pp.py",
+      "size": 13486,
+      "sha256": null,
+      "blob_id": "698ea3c6f3b6afd3865e70c6566b19cf9d0fc88f"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/wan22.py",
+      "size": 16945,
+      "sha256": null,
+      "blob_id": "0a7f5a6bccb07193e2fcaf0329a27b28ddda20f0"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/wan_video_dit.py",
+      "size": 33084,
+      "sha256": null,
+      "blob_id": "afb9a25b3ca6c8e3819997e26fd5a9ddad6b9a6c"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/wan_video_text_encoder.py",
+      "size": 11459,
+      "sha256": null,
+      "blob_id": "24f89f49c971d3798a2eed8e20faa98ec01cba20"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/models/wan22/wan_video_vae.py",
+      "size": 50058,
+      "sha256": null,
+      "blob_id": "0386bdedb6a532781eb81509e5f574011113a706"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/runtime.py",
+      "size": 34288,
+      "sha256": null,
+      "blob_id": "cdf15830cc1109a0f1361cf97aa2d69ed6f58d2e"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/trainer.py",
+      "size": 66389,
+      "sha256": null,
+      "blob_id": "ea6e07fb54072e50f98c085395c3344bbcc116f3"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/utils/__init__.py",
+      "size": 96,
+      "sha256": null,
+      "blob_id": "3d0eb927e25fab27c8dae7daa3d52a31c2d532b2"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/utils/config_resolvers.py",
+      "size": 2526,
+      "sha256": null,
+      "blob_id": "4b1273b96b716ffa1028dfce42474376930a19f1"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/utils/fs.py",
+      "size": 76,
+      "sha256": null,
+      "blob_id": "b210bde5a81689be2969db6059ab71833958f43a"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/utils/logging_config.py",
+      "size": 4679,
+      "sha256": null,
+      "blob_id": "eba39b2fcff02c4d8488cf099d414eca19fbbc47"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/utils/misc.py",
+      "size": 1223,
+      "sha256": null,
+      "blob_id": "9981aa8913c2b565c3b6cf5e317eed12d6a7222c"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/utils/pytorch_utils.py",
+      "size": 5049,
+      "sha256": null,
+      "blob_id": "87180a30f9edbba85cc1c94a3fd604b79fd15b1a"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/utils/samplers.py",
+      "size": 1339,
+      "sha256": null,
+      "blob_id": "8b4f52a26a749fadc78a5c4ae7fa9068570be000"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/utils/video_io.py",
+      "size": 819,
+      "sha256": null,
+      "blob_id": "74898b9c02a79c6b34b36af215a32743a8541d5d"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/utils/video_metrics.py",
+      "size": 3446,
+      "sha256": null,
+      "blob_id": "6b2837fa1d7b3c7c2532e99121ee46d68eb6be6e"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/training_code/fastwam_joint.py",
+      "size": 3994,
+      "sha256": null,
+      "blob_id": "bcd1ba2657cb2c6ea920a48439feddbb6319ccbf"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/upload_manifest.json",
+      "size": 36140,
+      "sha256": null,
+      "blob_id": "aae0341b5ba11619cab14934d870442b604b3fa5"
+    },
+    {
+      "path": "joint/fasterwam/train90_joint_job4247/validation/final_metrics.json",
+      "size": 3,
+      "sha256": null,
+      "blob_id": "0967ef424bce6791893e9a57bb952f80fd536e93"
+    }
+  ]
+}

joint/fasterwam/old/README.md

@@ -0,0 +1,5 @@
+# Old joint FasterWAM checkpoints
+
+[train90_joint_job4247](train90_joint_job4247/README.md) preserves all three historical checkpoints (epochs 10, 20 and 30) and all matching metadata, unchanged. This run used the invalid place_cube spatial crops and is superseded by [job 4414](../train90_joint_job4414/README.md).
+
+Original prefix: `joint/fasterwam/train90_joint_job4247/`. Archived prefix: `joint/fasterwam/old/train90_joint_job4247/`. Original manifests retain their original paths as historical provenance; apply this prefix mapping when inspecting them. `ARCHIVE_PROVENANCE.json` records the pinned source revision and original file hashes.

joint/fasterwam/train90_joint_job4247/README.md

@@ -1,9 +0,0 @@
-# Joint FasterWAM — job 4247
-
-Trained jointly on fruit_pick, dish_utensil, place_cube, and push_t using eight H200 GPUs, global batch 32, and canonical 90/10 episode splits. The user stopped the originally planned 50-epoch run during epoch 33.
-
-Published checkpoints: epoch 10 (29310), epoch 20 (58620), epoch 30 (87930). These retain the original 50-epoch cosine schedule; this was not a separate 30-epoch training schedule. Optimizer and resume state are excluded.
-
-Use checkpoints/weights with the bundled runtime, config.yaml, dataset_stats.json, and all four task embeddings under conditioning/. Remap training paths locally. The Wan2.2 VAE/base components in the config remain external dependencies. Source snapshots are export-time copies; provenance/implementation.json records training-time source hashes.
-
-The W&B summary was not finalized after cancellation. Training-time validation is recorded in provenance/training.log; no robot evaluation is claimed. See manifest.json for provenance and upload_manifest.json for checksums. Bundled code retains upstream licenses.

joint/fasterwam/train90_joint_job4247/checkpoints/weights/step_029310.pt

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

joint/fasterwam/train90_joint_job4247/checkpoints/weights/step_058620.pt

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

joint/fasterwam/train90_joint_job4247/checkpoints/weights/step_087930.pt

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

joint/fasterwam/train90_joint_job4247/conditioning/dish_utensil/tasks.jsonl

@@ -1 +0,0 @@
-{"task_index": 0, "task": "pick the dishes out of the rack and place them on the table, then pick and place the spoon to the gray dish and fork to the pink dish"}

joint/fasterwam/train90_joint_job4247/conditioning/fruit_pick/tasks.jsonl

@@ -1 +0,0 @@
-{"task_index": 0, "task": "Lift the lid, put it aside, and pick the black plum."}

joint/fasterwam/train90_joint_job4247/conditioning/index.json

@@ -1,22 +0,0 @@
-{
-  "dish_utensil": {
-    "embedding": "conditioning/text_embeds_cache/6bbe3e745d0bcd06a540d3d895af431a769ae466d0cf1102bcee7979ba41e95b.t5_len128.wan22ti2v5b.pt",
-    "encoded_prompt": "A video recorded from a robot's point of view executing the following instruction: pick the dishes out of the rack and place them on the table, then pick and place the spoon to the gray dish and fork to the pink dish",
-    "task": "pick the dishes out of the rack and place them on the table, then pick and place the spoon to the gray dish and fork to the pink dish"
-  },
-  "fruit_pick": {
-    "embedding": "conditioning/text_embeds_cache/3331746089cf26d56af486af1ef7035e746c2e823cc957e2e3b7a0c3baf347ef.t5_len128.wan22ti2v5b.pt",
-    "encoded_prompt": "A video recorded from a robot's point of view executing the following instruction: Lift the lid, put it aside, and pick the black plum.",
-    "task": "Lift the lid, put it aside, and pick the black plum."
-  },
-  "place_cube": {
-    "embedding": "conditioning/text_embeds_cache/531e2910f4efdc285bcefbeca24a8a1ff789d6c4365dfd7c15de4eda9eb89f6b.t5_len128.wan22ti2v5b.pt",
-    "encoded_prompt": "A video recorded from a robot's point of view executing the following instruction: place the cube in the bowl",
-    "task": "place the cube in the bowl"
-  },
-  "push_t": {
-    "embedding": "conditioning/text_embeds_cache/71cb088954da46da4e3cb6c6f73ac812690e9bccf886c7858377c61918b4e3e8.t5_len128.wan22ti2v5b.pt",
-    "encoded_prompt": "A video recorded from a robot's point of view executing the following instruction: push the T block to the target outline",
-    "task": "push the T block to the target outline"
-  }
-}

joint/fasterwam/train90_joint_job4247/conditioning/place_cube/tasks.jsonl

@@ -1 +0,0 @@
-{"task_index": 0, "task": "place the cube in the bowl"}

joint/fasterwam/train90_joint_job4247/conditioning/prompts.json

@@ -1,6 +0,0 @@
-{
-  "dish_utensil": "pick the dishes out of the rack and place them on the table, then pick and place the spoon to the gray dish and fork to the pink dish",
-  "fruit_pick": "Lift the lid, put it aside, and pick the black plum.",
-  "place_cube": "place the cube in the bowl",
-  "push_t": "push the T block to the target outline"
-}

joint/fasterwam/train90_joint_job4247/conditioning/push_t/tasks.jsonl

@@ -1 +0,0 @@
-{"task_index": 0, "task": "push the T block to the target outline"}

joint/fasterwam/train90_joint_job4247/conditioning/text_embeds_cache/3331746089cf26d56af486af1ef7035e746c2e823cc957e2e3b7a0c3baf347ef.t5_len128.wan22ti2v5b.pt

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

joint/fasterwam/train90_joint_job4247/conditioning/text_embeds_cache/531e2910f4efdc285bcefbeca24a8a1ff789d6c4365dfd7c15de4eda9eb89f6b.t5_len128.wan22ti2v5b.pt

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

joint/fasterwam/train90_joint_job4247/conditioning/text_embeds_cache/6bbe3e745d0bcd06a540d3d895af431a769ae466d0cf1102bcee7979ba41e95b.t5_len128.wan22ti2v5b.pt

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

joint/fasterwam/train90_joint_job4247/conditioning/text_embeds_cache/71cb088954da46da4e3cb6c6f73ac812690e9bccf886c7858377c61918b4e3e8.t5_len128.wan22ti2v5b.pt

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

joint/fasterwam/train90_joint_job4247/config.yaml

@@ -1,344 +0,0 @@
-output_dir: /shared_work/amin-a/realworld-wam/fastwam_train/runs/joint_all4_fasterwam/2026-09-17_04-15-26_job4247
-batch_size: 4
-num_workers: 4
-lr_scheduler_type: cosine
-learning_rate: 0.0001
-num_epochs: 50
-max_steps: null
-wsd_decay_fraction: 0.1
-wsd_decay_shape: linear
-wsd_branch_decay_steps: null
-log_every: 10
-save_every: 29310
-save_steps: []
-eval_every: 2931
-eval_num_inference_steps: 10
-gradient_accumulation_steps: 1
-mixed_precision: bf16
-distributed_timeout_minutes: 60
-seed: 42
-max_grad_norm: 1.0
-weight_decay: 0.01
-resume: null
-allow_unverified_full_state_resume: false
-freeze_video_backbone: false
-hf_upload:
-  enabled: false
-  dry_run: false
-  fail_on_error: false
-  script_path: huggingface/upload_to_hf.sh
-  bucket_run_name: null
-wandb:
-  enabled: true
-  workspace: aabyaneh
-  project: fasterwam-real
-  name: joint_all4_fasterwam_2026-09-17_04-15-26_job4247
-  group: fasterwam
-  mode: online
-data:
-  dataset_name: joint_all4
-  train:
-    _target_: fastwam.datasets.lerobot.robot_video_dataset.RobotVideoDataset
-    dataset_dirs:
-    - /tmp/amin_fastwam/fruit_pick_lerobot_v21
-    - /tmp/amin_fastwam/dish_utensil_lerobot_v21
-    - /tmp/amin_fastwam/place_cube_lerobot_v21
-    - /tmp/amin_fastwam/push_t_lerobot_v21
-    shape_meta:
-      images:
-      - key: image
-        raw_shape:
-        - 3
-        - 256
-        - 256
-        shape:
-        - 3
-        - 224
-        - 224
-      - key: wrist_image
-        raw_shape:
-        - 3
-        - 256
-        - 256
-        shape:
-        - 3
-        - 224
-        - 224
-      action:
-      - key: default
-        raw_shape: 7
-        shape: 7
-      state:
-      - key: default
-        raw_shape: 8
-        shape: 8
-    num_frames: 33
-    global_sample_stride: 1
-    action_video_freq_ratio: 4
-    video_size:
-    - 224
-    - 448
-    camera_key: null
-    val_set_proportion: 0.0
-    is_training_set: true
-    episode_indices_path: /shared_work/amin-a/realworld-wam/splits/fruit_pick_lerobot_v21.json
-    episode_indices_key: train
-    skip_padding_as_possible: false
-    concat_multi_camera: horizontal
-    processor:
-      _target_: fastwam.datasets.lerobot.processors.fastwam_processor.FastWAMProcessor
-      shape_meta:
-        images:
-        - key: image
-          raw_shape:
-          - 3
-          - 256
-          - 256
-          shape:
-          - 3
-          - 224
-          - 224
-        - key: wrist_image
-          raw_shape:
-          - 3
-          - 256
-          - 256
-          shape:
-          - 3
-          - 224
-          - 224
-        action:
-        - key: default
-          raw_shape: 7
-          shape: 7
-        state:
-        - key: default
-          raw_shape: 8
-          shape: 8
-      num_obs_steps: 33
-      num_output_cameras: 2
-      action_output_dim: 7
-      proprio_output_dim: 8
-      delta_action_dim_mask:
-        default:
-        - true
-        - true
-        - true
-        - true
-        - true
-        - true
-        - false
-      action_state_transforms: null
-      use_stepwise_action_norm: false
-      norm_default_mode: min/max
-      norm_exception_mode: null
-      action_state_merger:
-        _target_: fastwam.datasets.lerobot.transforms.action_state_merger.ConcatLeftAlign
-      train_transforms:
-      - _target_: fastwam.datasets.lerobot.transforms.image.ToTensor
-      - _target_: torchvision.transforms.Resize
-        size:
-        - 224
-        - 224
-      val_transforms:
-      - _target_: fastwam.datasets.lerobot.transforms.image.ToTensor
-      - _target_: torchvision.transforms.Resize
-        size:
-        - 224
-        - 224
-    text_embedding_cache_dir: /tmp/amin_fastwam/joint_all4_text_embeds_cache
-    context_len: 128
-  val:
-    _target_: fastwam.datasets.lerobot.robot_video_dataset.RobotVideoDataset
-    dataset_dirs:
-    - /tmp/amin_fastwam/fruit_pick_lerobot_v21
-    - /tmp/amin_fastwam/dish_utensil_lerobot_v21
-    - /tmp/amin_fastwam/place_cube_lerobot_v21
-    - /tmp/amin_fastwam/push_t_lerobot_v21
-    shape_meta:
-      images:
-      - key: image
-        raw_shape:
-        - 3
-        - 256
-        - 256
-        shape:
-        - 3
-        - 224
-        - 224
-      - key: wrist_image
-        raw_shape:
-        - 3
-        - 256
-        - 256
-        shape:
-        - 3
-        - 224
-        - 224
-      action:
-      - key: default
-        raw_shape: 7
-        shape: 7
-      state:
-      - key: default
-        raw_shape: 8
-        shape: 8
-    num_frames: 33
-    global_sample_stride: 1
-    action_video_freq_ratio: 4
-    video_size:
-    - 224
-    - 448
-    camera_key: null
-    val_set_proportion: 0.0
-    is_training_set: false
-    episode_indices_path: /shared_work/amin-a/realworld-wam/splits/fruit_pick_lerobot_v21.json
-    episode_indices_key: val
-    skip_padding_as_possible: false
-    concat_multi_camera: horizontal
-    processor:
-      _target_: fastwam.datasets.lerobot.processors.fastwam_processor.FastWAMProcessor
-      shape_meta:
-        images:
-        - key: image
-          raw_shape:
-          - 3
-          - 256
-          - 256
-          shape:
-          - 3
-          - 224
-          - 224
-        - key: wrist_image
-          raw_shape:
-          - 3
-          - 256
-          - 256
-          shape:
-          - 3
-          - 224
-          - 224
-        action:
-        - key: default
-          raw_shape: 7
-          shape: 7
-        state:
-        - key: default
-          raw_shape: 8
-          shape: 8
-      num_obs_steps: 33
-      num_output_cameras: 2
-      action_output_dim: 7
-      proprio_output_dim: 8
-      delta_action_dim_mask:
-        default:
-        - true
-        - true
-        - true
-        - true
-        - true
-        - true
-        - false
-      action_state_transforms: null
-      use_stepwise_action_norm: false
-      norm_default_mode: min/max
-      norm_exception_mode: null
-      action_state_merger:
-        _target_: fastwam.datasets.lerobot.transforms.action_state_merger.ConcatLeftAlign
-      train_transforms:
-      - _target_: fastwam.datasets.lerobot.transforms.image.ToTensor
-      - _target_: torchvision.transforms.Resize
-        size:
-        - 224
-        - 224
-      val_transforms:
-      - _target_: fastwam.datasets.lerobot.transforms.image.ToTensor
-      - _target_: torchvision.transforms.Resize
-        size:
-        - 224
-        - 224
-    text_embedding_cache_dir: /tmp/amin_fastwam/joint_all4_text_embeds_cache
-    context_len: 128
-model:
-  _target_: fastwam.models.wan22.piha.create_piha
-  model_id: Wan-AI/Wan2.2-TI2V-5B
-  tokenizer_model_id: Wan-AI/Wan2.1-T2V-1.3B
-  tokenizer_max_len: 128
-  load_text_encoder: false
-  proprio_dim: 8
-  redirect_common_files: true
-  mot_checkpoint_mixed_attn: false
-  action_dit_pretrained_path: null
-  skip_dit_load_from_pretrain: false
-  decoupled: true
-  kv_source_mode: new_fused_kv
-  fusion_hidden_dim: 64
-  fusion_use_norm: true
-  fixed_rope: true
-  new_fused_kv_rope_mode: aligned_3d
-  aligned_3d_action_spatial_anchor_layout: horizontal
-  new_fused_kv_projection_mode: simple_head_softmax
-  new_fused_kv_pos_embed_dim: 128
-  new_fused_kv_mlp_mixer_num_blocks: 1
-  new_fused_kv_mlp_mixer_token_mlp_ratio: 4.0
-  new_fused_kv_mlp_mixer_channel_mlp_ratio: 4.0
-  new_fused_kv_head_fused_kv_sin2d_pe_mlp_hidden_dim: 512
-  new_fused_kv_simple_head_softmax_fuse_mode: all
-  new_fused_kv_head_fused_kv_fuse_mode: all
-  video_dit_config:
-    has_image_input: false
-    patch_size:
-    - 1
-    - 2
-    - 2
-    in_dim: 48
-    hidden_dim: 3072
-    ffn_dim: 14336
-    freq_dim: 256
-    text_dim: 4096
-    out_dim: 48
-    num_heads: 24
-    attn_head_dim: 128
-    num_layers: 30
-    eps: 1.0e-06
-    seperated_timestep: true
-    require_clip_embedding: false
-    require_vae_embedding: false
-    fuse_vae_embedding_in_latents: true
-    use_gradient_checkpointing: false
-    video_attention_mask_mode: first_frame_causal
-    action_conditioned: false
-    action_dim: 7
-    action_group_causal_mask_mode: group_diagonal
-  action_dit_config:
-    action_dim: 7
-    hidden_dim: 3072
-    ffn_dim: 12288
-    num_heads: 24
-    attn_head_dim: 128
-    num_layers: 1
-    layer_selected: null
-    text_dim: 4096
-    freq_dim: 256
-    eps: 1.0e-06
-    use_gradient_checkpointing: false
-    action_text_cross_attn: false
-  video_scheduler:
-    train_shift: 5.0
-    infer_shift: 5.0
-    num_train_timesteps: 1000
-  action_scheduler:
-    train_shift: 5.0
-    infer_shift: 5.0
-    num_train_timesteps: 1000
-  loss:
-    lambda_video: 1.0
-    lambda_action: 1.0
-  piha_permutation_mode: cyclic
-  action_text_ca_dropout_p: 0.0
-method: fasterwam
-implementation:
-  repository: https://github.com/rhyang6/fastwam
-  branch: new_fused_kv
-  commit: 19483b8b1b6a72e697091a07e7df7777aa09fd85
-  reference_config: scripts_liheng/final_version/libero.yaml

joint/fasterwam/train90_joint_job4247/dataset_stats.json

@@ -1,1938 +0,0 @@
-{
-  "state": {
-    "default": {
-      "stepwise_min": [
-        [
-          0.3257139027118683,
-          -0.19808503985404968,
-          0.11773434281349182,
-          2.8797452449798584,
-          -1.348800778388977,
-          0.1602623164653778,
-          5.3190000471659005e-05,
-          -0.03993518278002739
-        ]
-      ],
-      "stepwise_max": [
-        [
-          0.6804016828536987,
-          0.31247836351394653,
-          0.45249679684638977,
-          3.012880325317383,
-          -1.1482024192810059,
-          0.589073657989502,
-          0.03993518278002739,
-          -5.3190000471659005e-05
-        ]
-      ],
-      "global_min": [
-        0.3257139027118683,
-        -0.19808503985404968,
-        0.11773434281349182,
-        2.8797452449798584,
-        -1.348800778388977,
-        0.1602623164653778,
-        5.3190000471659005e-05,
-        -0.03993518278002739
-      ],
-      "global_max": [
-        0.6804016828536987,
-        0.31247836351394653,
-        0.45249679684638977,
-        3.012880325317383,
-        -1.1482024192810059,
-        0.589073657989502,
-        0.03993518278002739,
-        -5.3190000471659005e-05
-      ],
-      "stepwise_q01": [
-        [
-          0.326332151889801,
-          -0.19770283997058868,
-          0.1177695095539093,
-          2.881575584411621,
-          -1.346077799797058,
-          0.1623862236738205,
-          0.0001012185966828838,
-          -0.039905305951833725
-        ]
-      ],
-      "stepwise_q99": [
-        [
-          0.6752662658691406,
-          0.3044644892215729,
-          0.450180321931839,
-          3.0091538429260254,
-          -1.149796485900879,
-          0.5569735765457153,
-          0.039905305951833725,
-          -0.00010121861123479903
-        ]
-      ],
-      "global_q01": [
-        0.326332151889801,
-        -0.19770283997058868,
-        0.1177695095539093,
-        2.881575584411621,
-        -1.346077799797058,
-        0.1623862236738205,
-        0.0001012185966828838,
-        -0.039905305951833725
-      ],
-      "global_q99": [
-        0.6752662658691406,
-        0.3044644892215729,
-        0.450180321931839,
-        3.0091538429260254,
-        -1.149796485900879,
-        0.5569735765457153,
-        0.039905305951833725,
-        -0.00010121861123479903
-      ],
-      "stepwise_mean": [
-        [
-          0.4861578345298767,
-          0.02602844499051571,
-          0.25201132893562317,
-          2.952380657196045,
-          -1.2511029243469238,
-          0.37992680072784424,
-          0.021428851410746574,
-          -0.021428851410746574
-        ]
-      ],
-      "stepwise_std": [
-        [
-          0.04675422981381416,
-          0.1213567927479744,
-          0.06022870913147926,
-          0.017529325559735298,
-          0.03535432368516922,
-          0.09873220324516296,
-          0.01631387695670128,
-          0.01631387695670128
-        ]
-      ],
-      "global_mean": [
-        0.4861578345298767,
-        0.02602844499051571,
-        0.25201132893562317,
-        2.952380657196045,
-        -1.2511029243469238,
-        0.37992680072784424,
-        0.021428851410746574,
-        -0.021428851410746574
-      ],
-      "global_std": [
-        0.04675422981381416,
-        0.1213567927479744,
-        0.06022870913147926,
-        0.017529325559735298,
-        0.03535432368516922,
-        0.09873220324516296,
-        0.01631387695670128,
-        0.01631387695670128
-      ]
-    }
-  },
-  "action": {
-    "default": {
-      "stepwise_min": [
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.023571429774165154,
-          -0.03100000135600567,
-          -0.025142857804894447,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ]
-      ],
-      "stepwise_max": [
-        [
-          0.022142857313156128,
-          0.021714285016059875,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.021714285016059875,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.021714285016059875,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.021714285016059875,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.021714285016059875,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.021714285016059875,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.021714285016059875,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.021714285016059875,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.021714285016059875,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.021714285016059875,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.021714285016059875,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.021714285016059875,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.021714285016059875,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.021714285016059875,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.01842857152223587,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.01842857152223587,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.01842857152223587,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.01842857152223587,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.01842857152223587,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.01842857152223587,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.01842857152223587,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.017999999225139618,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.017999999225139618,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.017999999225139618,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.017999999225139618,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.017999999225139618,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.017999999225139618,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.017999999225139618,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.017999999225139618,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.017999999225139618,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.017999999225139618,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ],
-        [
-          0.022142857313156128,
-          0.017999999225139618,
-          0.03257143124938011,
-          0.0,
-          -0.0,
-          -0.0,
-          1.0
-        ]
-      ],
-      "global_min": [
-        -0.023571429774165154,
-        -0.03100000135600567,
-        -0.025142857804894447,
-        0.0,
-        -0.0,
-        -0.0,
-        -1.0
-      ],
-      "global_max": [
-        0.022142857313156128,
-        0.021714285016059875,
-        0.03257143124938011,
-        0.0,
-        -0.0,
-        -0.0,
-        1.0
-      ],
-      "stepwise_q01": [
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ],
-        [
-          -0.017999999225139618,
-          -0.028668571263551712,
-          -0.020428571850061417,
-          0.0,
-          -0.0,
-          -0.0,
-          -1.0
-        ]
-      ],
-      "stepwise_q99": [
-        [
-          0.01874857023358345,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01874857023358345,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01874857023358345,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01874857023358345,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01874857023358345,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01874857023358345,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01874857023358345,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01874857023358345,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01874857023358345,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01874857023358345,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01874857023358345,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01874857023358345,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ],
-        [
-          0.01811428926885128,
-          0.017999999225139618,
-          0.032182857394218445,
-          0.0,
-          0.0,
-          0.0,
-          1.0
-        ]
-      ],
-      "global_q01": [
-        -0.017999999225139618,
-        -0.028668571263551712,
-        -0.020428571850061417,
-        0.0,
-        -0.0,
-        -0.0,
-        -1.0
-      ],
-      "global_q99": [
-        0.01874857023358345,
-        0.017999999225139618,
-        0.032182857394218445,
-        0.0,
-        0.0,
-        0.0,
-        1.0
-      ],
-      "stepwise_mean": [
-        [
-          0.00010599139204714447,
-          -0.0003520426689647138,
-          0.00014291385014075786,
-          0.0,
-          0.0,
-          0.0,
-          0.2183247208595276
-        ],
-        [
-          0.00010662782733561471,
-          -0.00035185267915949225,
-          0.00014307233504951,
-          0.0,
-          0.0,
-          0.0,
-          0.22085411846637726
-        ],
-        [
-          0.00010768464562715963,
-          -0.0003513394040055573,
-          0.0001433969009667635,
-          0.0,
-          0.0,
-          0.0,
-          0.22338351607322693
-        ],
-        [
-          0.0001071520455298014,
-          -0.0003502023755572736,
-          0.0001435836311429739,
-          0.0,
-          0.0,
-          0.0,
-          0.22591295838356018
-        ],
-        [
-          0.00010332007514080033,
-          -0.00034813376259990036,
-          0.00014470236783381552,
-          0.0,
-          0.0,
-          0.0,
-          0.22844235599040985
-        ],
-        [
-          9.708326979307458e-05,
-          -0.0003456552803982049,
-          0.0001498961355537176,
-          0.0,
-          0.0,
-          0.0,
-          0.23097175359725952
-        ],
-        [
-          8.982994040707126e-05,
-          -0.00034212053287774324,
-          0.00015701490337960422,
-          0.0,
-          0.0,
-          0.0,
-          0.23350116610527039
-        ],
-        [
-          8.295998850371689e-05,
-          -0.00033426276058889925,
-          0.00016626888827886432,
-          0.0,
-          0.0,
-          0.0,
-          0.23603059351444244
-        ],
-        [
-          7.580933743156493e-05,
-          -0.00032417502370662987,
-          0.00018232851289212704,
-          0.0,
-          0.0,
-          0.0,
-          0.23855999112129211
-        ],
-        [
-          6.725409912178293e-05,
-          -0.00031425998895429075,
-          0.00019788365170825273,
-          0.0,
-          0.0,
-          0.0,
-          0.24108940362930298
-        ],
-        [
-          5.8587662351783365e-05,
-          -0.0003024389152415097,
-          0.0002139062125934288,
-          0.0,
-          0.0,
-          0.0,
-          0.24361883103847504
-        ],
-        [
-          4.8913931095739827e-05,
-          -0.00029040378285571933,
-          0.00023386623070109636,
-          0.0,
-          0.0,
-          0.0,
-          0.2461482435464859
-        ],
-        [
-          3.9833157643442973e-05,
-          -0.0002796816115733236,
-          0.0002501923299860209,
-          0.0,
-          0.0,
-          0.0,
-          0.24867764115333557
-        ],
-        [
-          3.252932947361842e-05,
-          -0.0002679046301636845,
-          0.00026465911651030183,
-          0.0,
-          0.0,
-          0.0,
-          0.25120702385902405
-        ],
-        [
-          2.6598059776006266e-05,
-          -0.0002585168113000691,
-          0.00028005309286527336,
-          0.0,
-          0.0,
-          0.0,
-          0.2537364661693573
-        ],
-        [
-          1.9946868633269332e-05,
-          -0.00025132004520855844,
-          0.00029630353674292564,
-          0.0,
-          0.0,
-          0.0,
-          0.25626587867736816
-        ],
-        [
-          1.303988574363757e-05,
-          -0.00024510364164598286,
-          0.0003103403723798692,
-          0.0,
-          0.0,
-          0.0,
-          0.25880569219589233
-        ],
-        [
-          5.248548404779285e-06,
-          -0.00024028636107686907,
-          0.00032640460995025933,
-          0.0,
-          0.0,
-          0.0,
-          0.2613455355167389
-        ],
-        [
-          -2.630091103128507e-06,
-          -0.00023644340399187058,
-          0.0003419383428990841,
-          0.0,
-          0.0,
-          0.0,
-          0.2638853192329407
-        ],
-        [
-          -1.1612431080720853e-05,
-          -0.00023524471907876432,
-          0.00035437088808976114,
-          0.0,
-          0.0,
-          0.0,
-          0.2664651870727539
-        ],
-        [
-          -2.4109574951580726e-05,
-          -0.00023595777747686952,
-          0.0003668583813123405,
-          0.0,
-          0.0,
-          0.0,
-          0.26908746361732483
-        ],
-        [
-          -3.409310011193156e-05,
-          -0.00023765936202835292,
-          0.0003780024708248675,
-          0.0,
-          0.0,
-          0.0,
-          0.2717488706111908
-        ],
-        [
-          -4.41225383838173e-05,
-          -0.00024006325111258775,
-          0.0003892174281645566,
-          0.0,
-          0.0,
-          0.0,
-          0.2744331955909729
-        ],
-        [
-          -5.318918192642741e-05,
-          -0.00024481830769218504,
-          0.0003998273750767112,
-          0.0,
-          0.0,
-          0.0,
-          0.27719661593437195
-        ],
-        [
-          -6.362147541949525e-05,
-          -0.00025020778411999345,
-          0.0004108487628400326,
-          0.0,
-          0.0,
-          0.0,
-          0.27999645471572876
-        ],
-        [
-          -7.399872993119061e-05,
-          -0.0002569758507888764,
-          0.00042012453195638955,
-          0.0,
-          0.0,
-          0.0,
-          0.28288376331329346
-        ],
-        [
-          -8.447915024589747e-05,
-          -0.00026511374744586647,
-          0.00042987134656868875,
-          0.0,
-          0.0,
-          0.0,
-          0.28581443428993225
-        ],
-        [
-          -9.251773008145392e-05,
-          -0.00027324925758875906,
-          0.00043566094245761633,
-          0.0,
-          0.0,
-          0.0,
-          0.28880083560943604
-        ],
-        [
-          -0.0001004255173029378,
-          -0.00028087335522286594,
-          0.00044270692160353065,
-          0.0,
-          0.0,
-          0.0,
-          0.2919144332408905
-        ],
-        [
-          -0.00010663300781743601,
-          -0.0002883909037336707,
-          0.0004484386881813407,
-          0.0,
-          0.0,
-          0.0,
-          0.29495498538017273
-        ],
-        [
-          -0.00011239774903515354,
-          -0.0002963065926451236,
-          0.000453940243460238,
-          0.0,
-          0.0,
-          0.0,
-          0.2980213463306427
-        ],
-        [
-          -0.00011664993508020416,
-          -0.0003038592985831201,
-          0.00045629238593392074,
-          0.0,
-          0.0,
-          0.0,
-          0.3011433184146881
-        ]
-      ],
-      "stepwise_std": [
-        [
-          0.003859531134366989,
-          0.005849294830113649,
-          0.005096182227134705,
-          0.0,
-          0.0,
-          0.0,
-          0.6930140852928162
-        ],
-        [
-          0.003858074778690934,
-          0.005849248263984919,
-          0.005096119828522205,
-          0.0,
-          0.0,
-          0.0,
-          0.692183256149292
-        ],
-        [
-          0.00385070638731122,
-          0.005849029868841171,
-          0.005095901433378458,
-          0.0,
-          0.0,
-          0.0,
-          0.6913419961929321
-        ],
-        [
-          0.003835494164377451,
-          0.005848364904522896,
-          0.0050956266932189465,
-          0.0,
-          0.0,
-          0.0,
-          0.6904901266098022
-        ],
-        [
-          0.0038173042703419924,
-          0.0058466228656470776,
-          0.005094226449728012,
-          0.0,
-          0.0,
-          0.0,
-          0.6896276473999023
-        ],
-        [
-          0.003798459656536579,
-          0.005840709898620844,
-          0.005085964687168598,
-          0.0,
-          0.0,
-          0.0,
-          0.6887545585632324
-        ],
-        [
-          0.003779440186917782,
-          0.0058306735008955,
-          0.0050780801102519035,
-          0.0,
-          0.0,
-          0.0,
-          0.6878708600997925
-        ],
-        [
-          0.0037602565716952085,
-          0.005817433353513479,
-          0.005068507045507431,
-          0.0,
-          0.0,
-          0.0,
-          0.686976432800293
-        ],
-        [
-          0.0037413816899061203,
-          0.005803139880299568,
-          0.00504791084676981,
-          0.0,
-          0.0,
-          0.0,
-          0.6860713362693787
-        ],
-        [
-          0.003722784109413624,
-          0.005785479210317135,
-          0.005028924439102411,
-          0.0,
-          0.0,
-          0.0,
-          0.6851553320884705
-        ],
-        [
-          0.003704249393194914,
-          0.005768594332039356,
-          0.005011409055441618,
-          0.0,
-          0.0,
-          0.0,
-          0.6842285990715027
-        ],
-        [
-          0.003684787079691887,
-          0.005749644245952368,
-          0.004986910615116358,
-          0.0,
-          0.0,
-          0.0,
-          0.683290958404541
-        ],
-        [
-          0.003669159021228552,
-          0.005727663636207581,
-          0.004969390109181404,
-          0.0,
-          0.0,
-          0.0,
-          0.6823424696922302
-        ],
-        [
-          0.0036586951464414597,
-          0.005707941949367523,
-          0.00495464401319623,
-          0.0,
-          0.0,
-          0.0,
-          0.681382954120636
-        ],
-        [
-          0.0036503244191408157,
-          0.005686633288860321,
-          0.0049393498338758945,
-          0.0,
-          0.0,
-          0.0,
-          0.6804124116897583
-        ],
-        [
-          0.0036399371456354856,
-          0.005666919052600861,
-          0.004921806510537863,
-          0.0,
-          0.0,
-          0.0,
-          0.6794309020042419
-        ],
-        [
-          0.0036300860811024904,
-          0.005649130791425705,
-          0.004907391965389252,
-          0.0,
-          0.0,
-          0.0,
-          0.6784419417381287
-        ],
-        [
-          0.003619162132963538,
-          0.005632068496197462,
-          0.004889165051281452,
-          0.0,
-          0.0,
-          0.0,
-          0.6774417757987976
-        ],
-        [
-          0.0036096996627748013,
-          0.005616484675556421,
-          0.00487248320132494,
-          0.0,
-          0.0,
-          0.0,
-          0.6764302849769592
-        ],
-        [
-          0.0035996257793158293,
-          0.005601839628070593,
-          0.004860007204115391,
-          0.0,
-          0.0,
-          0.0,
-          0.675421416759491
-        ],
-        [
-          0.003584834048524499,
-          0.0055876681581139565,
-          0.004846835974603891,
-          0.0,
-          0.0,
-          0.0,
-          0.6744153499603271
-        ],
-        [
-          0.0035738751757889986,
-          0.00557406060397625,
-          0.004837150685489178,
-          0.0,
-          0.0,
-          0.0,
-          0.6734107136726379
-        ],
-        [
-          0.0035626839380711317,
-          0.005561233498156071,
-          0.00482589565217495,
-          0.0,
-          0.0,
-          0.0,
-          0.6724013686180115
-        ],
-        [
-          0.0035529215820133686,
-          0.005548112094402313,
-          0.004816059954464436,
-          0.0,
-          0.0,
-          0.0,
-          0.6714058518409729
-        ],
-        [
-          0.0035408444236963987,
-          0.005534714087843895,
-          0.0048048244789242744,
-          0.0,
-          0.0,
-          0.0,
-          0.670409083366394
-        ],
-        [
-          0.0035294988192617893,
-          0.005521110724657774,
-          0.004796639084815979,
-          0.0,
-          0.0,
-          0.0,
-          0.669427216053009
-        ],
-        [
-          0.003518011188134551,
-          0.0055075655691325665,
-          0.0047874050214886665,
-          0.0,
-          0.0,
-          0.0,
-          0.6684450507164001
-        ],
-        [
-          0.003509625094011426,
-          0.005495153367519379,
-          0.004781167954206467,
-          0.0,
-          0.0,
-          0.0,
-          0.6674659252166748
-        ],
-        [
-          0.003499576123431325,
-          0.005482127424329519,
-          0.0047730510123074055,
-          0.0,
-          0.0,
-          0.0,
-          0.6665111780166626
-        ],
-        [
-          0.0034931653644889593,
-          0.0054698726162314415,
-          0.004765379708260298,
-          0.0,
-          0.0,
-          0.0,
-          0.665599524974823
-        ],
-        [
-          0.0034858165308833122,
-          0.005457438062876463,
-          0.0047576818615198135,
-          0.0,
-          0.0,
-          0.0,
-          0.6647313833236694
-        ],
-        [
-          0.0034800912253558636,
-          0.005446141120046377,
-          0.004752232693135738,
-          0.0,
-          0.0,
-          0.0,
-          0.6638643145561218
-        ]
-      ],
-      "global_mean": [
-        8.372806405532174e-06,
-        -0.00028733949875459075,
-        0.0002960901183541864,
-        0.0,
-        0.0,
-        0.0,
-        0.2582257091999054
-      ],
-      "global_std": [
-        0.0036533514503389597,
-        0.005667832214385271,
-        0.004929195158183575,
-        0.0,
-        0.0,
-        0.0,
-        0.6791926622390747
-      ]
-    }
-  },
-  "num_episodes": 360,
-  "num_transition": 93771
-}

joint/fasterwam/train90_joint_job4247/manifest.json

@@ -1,45 +0,0 @@
-{
-  "base_model": "Wan-AI/Wan2.2-TI2V-5B",
-  "checkpoint_contents": "three inference checkpoints and matching metadata",
-  "checkpoint_epochs": [
-    10,
-    20,
-    30
-  ],
-  "checkpoint_selection": "epochs 10, 20, and 30; stopped early at user request",
-  "completed_updates": 94160,
-  "ended_utc": "2026-09-17T15:38:29Z",
-  "epochs": 50,
-  "final_checkpoint": "checkpoints/weights/step_087930.pt",
-  "final_checkpoint_step": 87930,
-  "global_batch_size": 32,
-  "includes_training_state": false,
-  "integrity_inventory": "upload_manifest.json",
-  "last_logged_training_step": 94160,
-  "model": "fasterwam",
-  "native_checkpoint_steps": [
-    29310,
-    58620,
-    87930
-  ],
-  "planned_epochs": 50,
-  "prompts": {
-    "dish_utensil": "pick the dishes out of the rack and place them on the table, then pick and place the spoon to the gray dish and fork to the pink dish",
-    "fruit_pick": "Lift the lid, put it aside, and pick the black plum.",
-    "place_cube": "place the cube in the bowl",
-    "push_t": "push the T block to the target outline"
-  },
-  "retained_through_epoch": 30,
-  "robot_evaluation": "not performed for these runs",
-  "run_id": "train90_joint_job4247",
-  "schema_version": 1,
-  "slurm_job": 4247,
-  "source_dir": "fastwam_train/runs/joint_all4_fasterwam/2026-09-17_04-15-26_job4247",
-  "stop_reason": "User requested cancellation and publication of epochs 10, 20, 30 only",
-  "task": "joint",
-  "training_gpus": 8,
-  "training_mode": "joint",
-  "training_status": "cancelled_by_user",
-  "validation_note": "No finalized W&B summary was available after cancellation. See training log for validation history; no robot evaluation claimed.",
-  "wandb_run": "https://wandb.ai/aabyaneh/fasterwam-real/runs/pp7o49m6"
-}

joint/fasterwam/train90_joint_job4247/provenance/code.json

@@ -1,22 +0,0 @@
-{
-  "args": [
-    "--config-dir",
-    "/shared_work/amin-a/realworld-wam/fastwam_train/configs",
-    "task=fasterwam_joint_split90",
-    "output_dir=/shared_work/amin-a/realworld-wam/fastwam_train/runs/joint_all4_fasterwam/2026-09-17_04-15-26_job4247",
-    "wandb.name=joint_all4_fasterwam_2026-09-17_04-15-26_job4247",
-    "wandb.workspace=aabyaneh",
-    "wandb.project=fasterwam-real",
-    "wandb.mode=online",
-    "hydra/job_logging=stdout",
-    "data.dataset_name=joint_all4",
-    "batch_size=4",
-    "gradient_accumulation_steps=1",
-    "num_epochs=50",
-    "save_every=29310",
-    "eval_every=2931"
-  ],
-  "code_snapshot_note": "Bundled source files are export-time snapshots; saved run config and checkpoint are authoritative.",
-  "python": "CPython 3.10.20",
-  "startedAt": "2026-09-17T04:17:33.873343Z"
-}

joint/fasterwam/train90_joint_job4247/provenance/implementation.json

@@ -1,364 +0,0 @@
-{
-  "repository": "https://github.com/rhyang6/fastwam",
-  "branch": "new_fused_kv",
-  "commit": "19483b8b1b6a72e697091a07e7df7777aa09fd85",
-  "reference_config": "scripts_liheng/final_version/libero.yaml",
-  "method": "fasterwam",
-  "files": {
-    "LICENSE": "8379dddfbbb1154ad9cc57f008f1f8d4a8d26c3de99bd6b36aa4d8067888aa92",
-    "configs/calibration/libero_camera_calibration_v1.json": "dfd4faa7ed6ccbf27b3ef69a682377b9e839a75e757caaa16f41d86c3faa685e",
-    "configs/calibration/libero_plus_anchors_v1.json": "67abf6f8c5b6067d3cc93a806299947de47f8b8393d895757dbf2880757349c1",
-    "configs/data/libero_2cam.yaml": "67a6b911352cef43bb2e5da4a60083a6c94af0143bfbf811e9d612b72bfa5960",
-    "configs/data/libero_2cam_aligned_3dpft.yaml": "3f8f0448440db7b0cdb5c5e1cc408e3b19dc8b4b564d4e196e781d6327152ab2",
-    "configs/data/roboreal.yaml": "ed35d3f0cf25a3939a703fedcc547015fcb5415d683df57ae39243447efbb944",
-    "configs/data/robotwin.yaml": "f1ba509fac21fc59d5a210d6f68bcf94640729ce00dce695b7ca6df24c7b5aa7",
-    "configs/data/robotwin_clean_random.yaml": "53ff96c11d41c47ac137109d53c7f5ae6f73abc9042607dcccbd3a7d8e0a1387",
-    "configs/data/robotwin_v30.yaml": "72b59238d3699d41eda61af3871419505ac6b7c0adda58af66c33bdfa403db8f",
-    "configs/data/robotwin_v30_aligned_3dpft.yaml": "8646fba876beb63b9ac79cf54628016b2fd60596eee77a73d9fc808b1ed46174",
-    "configs/data/robotwin_v30_delta.yaml": "4a4fa6d059c5f5c90a1bb464b4d76bad06e67a1f0c934bb20e5b001fe8621c92",
-    "configs/model/faster_wam.yaml": "4376e8b8e5fde662d3722404819f4bd5247236e8dae93857871f09b2d587d059",
-    "configs/model/fasterwam_decoupled_action_rope.yaml": "35b34784bf44ca502b691c294e6835ac5a4b171bcaeb7b205b845b456af0064c",
-    "configs/model/fasterwam_decoupled_aligned_3dpft.yaml": "e02fcba5a4edfbbe3d369b046fd956c6329e5efdf7df48dd19697580321c0de0",
-    "configs/model/fasterwam_decoupled_aligned_3dpft_weakpersp.yaml": "38c0a978291c47e65e135f8a98a7080919a83e7ca276b5eb47329df9f2599596",
-    "configs/model/fasterwam_decoupled_aligned_3dpft_x0.yaml": "c6aa72fcf8ffae0390216f2cc7614c54f94b1ba1d2796e1cc8ecf05b0431dcf7",
-    "configs/model/fasterwam_decoupled_aligned_3dpft_x0_proxpinhole.yaml": "8e71445d25266dba71a923dfb436bebd0e9d751d5cc7bad20a1eab1eff575e94",
-    "configs/model/fasterwam_decoupled_aligned_3dpft_x0_weakpersp.yaml": "fe99f4df2febd7251b70179367135969215ceb9fb8b71ebcc18842ce453c130a",
-    "configs/model/fasterwam_decoupled_attn_offset_head_anchor.yaml": "6806230f3272c222c47d66e3e7ab06b70d31038fad945649254059e7be0b1d11",
-    "configs/model/fasterwam_decoupled_control_rope.yaml": "46af59125fbd223540c3180553681094e1bdf12e384c703bb11d352793ed3daf",
-    "configs/model/fasterwam_decoupled_controlnet_pp.yaml": "bd56cb94c5252b1eadf580b2b8c323f5b0f284120a4e55a5f7cc8caf03fb4e24",
-    "configs/model/fasterwam_decoupled_ha_content_pp.yaml": "88c894f3d7092b09a73a72767ec230cbfdee48a23a443446afc47dd7b51f6cd4",
-    "configs/model/fasterwam_decoupled_ha_origami.yaml": "723f97e6bc43e3110564af570f05cdb6b4d55d7c817c3f0c81b8aaa4517c686b",
-    "configs/model/fasterwam_decoupled_head_anchor_h3072.yaml": "802896b938dfec82fbb1e1c4c79cde8d48cce474c8017095fe0faefd657f51cf",
-    "configs/model/fasterwam_decoupled_iha.yaml": "478b106254f15562e72d4e669d7171a397ea968018a0766183d37eb24d92e2af",
-    "configs/model/fasterwam_decoupled_learnable_head_anchor.yaml": "820e603a7a303950f5bb1db63d1f33cd47ad43ce2f0684e5cfa5d3f04ffe19e9",
-    "configs/model/fasterwam_decoupled_learnable_head_anchor_h3072.yaml": "635214d40f122009807edbb255815367ecb382e4b6185466aeff9d75dde3e4f7",
-    "configs/model/fasterwam_decoupled_non_fixed_rope.yaml": "c18df423fe45ca49682511d46194a3b823938b4d045260580fada97f50f74763",
-    "configs/model/fasterwam_decoupled_offset_head_anchor.yaml": "a1cc2b511321031fe2533bad45936fb082fb47f6203231af781e6a3def58854a",
-    "configs/model/fasterwam_decoupled_piha.yaml": "8c92c8c77af46dacdc6a3b42ed5e70cafff1be65efae075b0c98008da8d8cd2f",
-    "configs/model/fasterwam_decoupled_piha_post_rope_kv_simplepad_wide_newdrop05.yaml": "f94784772f55edfd5463b642f2b1e01bbf50f94f862b38543360a1d328d09749",
-    "configs/model/fasterwam_decoupled_piha_proprio_adaln_zero.yaml": "7738bab2cf88206c13dca23a828899edd61d6b1062b85554042acc0a26f91892",
-    "configs/model/fasterwam_decoupled_piha_proprio_adaln_zero_cfgdrop01.yaml": "c775698ea84f8a4ede6b68a043fee6bdce31e1f45b8bdb7e6f931ba6f6a627b9",
-    "configs/model/fasterwam_decoupled_piha_proprio_adaln_zero_drop02.yaml": "3a4b6d439c1ba523b7a2a0d01f96a1327ffc6de79ee04a5fb7ed0c43c73ab990",
-    "configs/model/fasterwam_decoupled_piha_proprio_adaln_zero_jitter05.yaml": "a518782be1d7840d97e96c92c055b5affcd57b7dfa15cbf3e38a37f9df2b425d",
-    "configs/model/fasterwam_decoupled_piha_proprio_adaln_zero_newdrop01.yaml": "1d37eee2d374798fed73dbbca610a0efcd24f4cf2534082198216d93821c1845",
-    "configs/model/fasterwam_decoupled_piha_proprio_adaln_zero_newdrop05.yaml": "117db49eadf95e8ae708ba29c8c9ca9a76725a7f6eab5e92c0f1681d89e9fe1f",
-    "configs/model/fasterwam_decoupled_piha_proprio_adaln_zero_simple_cfgdrop01.yaml": "0d5ee96e2a370a0dbc5b9d99851fe28642cf9f5a4d0f06fe1bc69d9636e07627",
-    "configs/model/fasterwam_decoupled_piha_proprio_adaln_zero_simple_wide_newdrop01.yaml": "e5a1c21b7dd751872ba4975fcbbf002b13e5220d37add2b05b200a680d803983",
-    "configs/model/fasterwam_decoupled_piha_proprio_adaln_zero_simple_wide_newdrop05.yaml": "900d8de2a7e89a0732942b93187b409bca96d4f63df5a311aba2763af22c738c",
-    "configs/model/fasterwam_decoupled_piha_proprio_adaln_zero_simple_wide_nulldrop0.yaml": "661cf1ae45c855829631ca6727e612a8510a70f297954e124e3fcf69603d6cdf",
-    "configs/model/fasterwam_decoupled_piha_proprio_adaln_zero_tgate_drop02.yaml": "7cef525d1debc26fbb0a9d4524e710898a834f1d44c3ca351ed7aa5d50799c84",
-    "configs/model/fasterwam_decoupled_piha_proprio_adaln_zero_wide_cfgdrop01.yaml": "68b49e4dea0f3b0282d3708c2b843f4a7872d2d947d8238f8103e3a1fb82d340",
-    "configs/model/fasterwam_decoupled_piha_proprio_adaln_zero_wide_newdrop01.yaml": "20ec0e1e879739d845fac9a20255fc5f87ce42a67eb60e5ae78e992d49adefee",
-    "configs/model/fasterwam_decoupled_piha_proprio_adaln_zero_wide_newdrop05.yaml": "51ff20d87979292fe5e26d97a7a23bb7ecad2b9f1f6f21082cc712bcd1b036b2",
-    "configs/model/fasterwam_decoupled_piha_proprioca_pre_piha_adaln_zero.yaml": "203dab8186358b7e00d3ec29548bdcbe7689d9833d88d5b656cd20ec91885405",
-    "configs/model/fasterwam_decoupled_piha_s2_notextca_wide.yaml": "428f1cd7e15c7f73de8a902a922d1901f589bb8776dd43514d0e250a17c7027a",
-    "configs/model/fasterwam_decoupled_piha_textca_cfgdrop01.yaml": "ad068306feb58b79e78c35d7df2404212aacf1c532ad00f5d5e732e69a036ad9",
-    "configs/model/fasterwam_decoupled_piha_textca_post_droppath02.yaml": "af9e3c11ad60b6b421953a8578fcdaed7e303463e357bee052b7d1a267fdda6e",
-    "configs/model/fasterwam_decoupled_piha_textca_post_piha_adaln_zero.yaml": "d3bd137c793d81c550e27da27d5d112adaf8ca1254e51f1856be9abdde0f4efe",
-    "configs/model/fasterwam_decoupled_piha_textca_post_piha_adaln_zero_cfgdrop01.yaml": "b935f7b017640b1921b6933bf4db47d0552166fde149b0d143935fcc4743fadf",
-    "configs/model/fasterwam_decoupled_piha_textca_pre_piha_adaln_zero.yaml": "c7db20a11dbcdb7a7e5eb3d8016ec6ae388642e3be50f9d01e7cade8f12ab468",
-    "configs/model/fasterwam_decoupled_piha_textca_pre_piha_adaln_zero_drop01.yaml": "0decdda84bacafcdaf8a6d0b9240b799d62ad6fee7544ff83636087dcefaf199",
-    "configs/model/fasterwam_decoupled_piha_textca_pre_piha_adaln_zero_drop02.yaml": "0c7bed756eacf69ff48a7642708fde7c45a002bff0080c630e20ec789d7a0f8a",
-    "configs/model/fasterwam_decoupled_piha_textca_pre_piha_adaln_zero_newdp01.yaml": "e4edb493c653218fd3242f5427897b9ee40e22c7484295b783df0673d26c08a8",
-    "configs/model/fasterwam_decoupled_piha_textca_proprio_jitter.yaml": "2f546b9609b6fa4b396962a84837f0f45bbc35122c59e0dc7d5c24195fd3baf5",
-    "configs/model/fasterwam_decoupled_piha_textca_separate_null_drop01.yaml": "4039be28e1ae9c67c683b27ee62014a4b2e91400e88eed7333594be5539500aa",
-    "configs/model/fasterwam_decoupled_piha_textca_separate_null_drop01_wide.yaml": "80443ead682fb85e943307ab18ede4e78cffe1d2d97b7c6c9268721de13588c5",
-    "configs/model/fasterwam_decoupled_piha_textca_separate_null_drop02.yaml": "731d5ad71209f77578e6b68e7a43dabfc614c34fe5f512128dfdadcd3d116694",
-    "configs/model/fasterwam_decoupled_piha_textca_text_only.yaml": "054c236c5c7560f4c09b37c53031fd75e72530fa5cc3d63cde1ceca5d4efcb5a",
-    "configs/model/fasterwam_decoupled_proprio_offset_head_anchor.yaml": "5a991a2a83c3aca15b6505f94fc7b16cf989e21796915ad7e59e2e2995be503b",
-    "configs/model/fasterwam_decoupled_robotwin_aligned_3dpft.yaml": "1ad5b5203967f4b699b1dcd452b9517b0fb18cf22bd2596a031d9f7bba287cc5",
-    "configs/model/fasterwam_decoupled_robotwin_piha.yaml": "589d760a4bdeff1462c11473091d904e14e6fee364eb19f28abe82a8cd789a3f",
-    "configs/model/fasterwam_decoupled_robotwin_piha_cyclic_notextca_wide.yaml": "7d83328f3115ecb382fb08a304d838ca73e917fe307577ef33d33f586eb9a238",
-    "configs/model/fasterwam_decoupled_robotwin_piha_cyclic_notextca_wide_m2.yaml": "033ed8c5ba8df6dba7babe8614010fd964cdfc794da491afe48f65772be2ee57",
-    "configs/model/fasterwam_decoupled_robotwin_piha_cyclic_proprio_adaln_zero_simple_wide_newdrop01.yaml": "ecd85b1b781a5c701f2e30ac5048113a0c29d2575a704e382e9d2acffb5d84ef",
-    "configs/model/fasterwam_decoupled_robotwin_piha_s3_notextca_wide.yaml": "65c04fc915408e51161a56910b2ce867718125c67608e8946c49217893cf292a",
-    "configs/model/fasterwam_decoupled_robotwin_piha_s3_notextca_wide_m2.yaml": "bb6b3c81557db91d781c9194bf17bc8ccacd1e143dbf526c1e0c96cd6d1ac93c",
-    "configs/model/fasterwam_decoupled_robotwin_piha_s3_post_rope_kv_simplepad_wide_newdrop01.yaml": "64b2d3128b2e1132ccbcb7952f91e31e5080acf0cea820455cc99174eeae7b06",
-    "configs/model/fasterwam_decoupled_robotwin_piha_s3_proprio_adaln_zero.yaml": "2835c16bc27a1861ece3111ad2bbcc0ca6c8c163888269d658fee93116298716",
-    "configs/model/fasterwam_decoupled_robotwin_piha_s3_proprio_adaln_zero_cfgdrop01.yaml": "1d52f29de3d8137eaef46016b83813e4e739f55574fbcdb722e2f5b4dd4fe5a1",
-    "configs/model/fasterwam_decoupled_robotwin_piha_s3_proprio_adaln_zero_jitter05.yaml": "9709256567b7eb05cbf6a601f602878a94e0f34b43f58a52375c193810bf68c3",
-    "configs/model/fasterwam_decoupled_robotwin_piha_s3_proprio_adaln_zero_simple_wide_newdrop01.yaml": "522d322b47eb9bff865b77dae1626596cbf3105ec1b22141d42ce7c8ee36f835",
-    "configs/model/fasterwam_decoupled_robotwin_piha_s3_proprio_adaln_zero_simple_wide_nulldrop0.yaml": "ed9421ab8c79fb242626fd0bf7b86bcabfafed1b83269bbeecf9ed11d9db4410",
-    "configs/model/fasterwam_decoupled_robotwin_piha_s3_proprio_adaln_zero_wide_cfgdrop01.yaml": "7df67a49dba60c481f3acf8633f73f62f8088615f5402a9d939ef4dfbe66e873",
-    "configs/model/fasterwam_decoupled_robotwin_piha_s3_textca.yaml": "23b28a10d06b5711a6f3ac71a93b278525845a0868c6d1c2e8f55bac16cd4c2c",
-    "configs/model/fasterwam_decoupled_robotwin_piha_s3_textca_cfgdrop01.yaml": "dd681117e2d45190138e7713de107d57b6af158be77b5bcf49fa40433556f0f9",
-    "configs/model/fasterwam_decoupled_robotwin_piha_s3_textca_post_droppath01_wide.yaml": "71f561f22621b36924a11fb2b23b290f8a22e622f6b23265fe6bdc8d7d708226",
-    "configs/model/fasterwam_decoupled_robotwin_piha_s3_textca_pre_piha_adaln_zero.yaml": "f1bd375a3eb80505646796ebb9578215b8ae3330da1a004e83819b8a9e9d9197",
-    "configs/model/fasterwam_decoupled_robotwin_piha_s3_textca_separate_null_drop01_wide.yaml": "04ce7e36b50dafc99cb1e75190b97d32d45bbb9fceb51d8e2a86123ae6d3c7d5",
-    "configs/model/fasterwam_decoupled_viewlocal_ha_pp.yaml": "809db6d01a4f9640be616d8e1b8ce44f16b0bd8ab3d27c6c62d3cee3d88e319c",
-    "configs/model/fastwam.yaml": "e19fd569ca168f9621567bd273cba544251f57609972c3ab95d9125b3ab7146d",
-    "configs/model/fastwam_action_mlp.yaml": "c5090b5e1ef85f2e82df82844fef4a3d0ed6d69a3d1715471399c1b0fcbcc08b",
-    "configs/model/fastwam_decoupled.yaml": "32ca8b9d20ad26add7de7a3ab0a564de7ee7f785567f9f35d5716617e2171067",
-    "configs/model/fastwam_idm.yaml": "951c508dfee6a3b4066489a57d633ee83743d2ecb96ba695c61c38cded7528f2",
-    "configs/model/fastwam_joint.yaml": "4bb1ed76ff315d11ee4de8804740393c06e9736517fb232117f58005f100c3bb",
-    "configs/sim_libero.yaml": "aaf0ca1c9fa847b5084e0b849520a1bafec406914b75ad409432b142f43ac5cb",
-    "configs/task/libero_idm_2cam224_1e-4.yaml": "5df6cf62843806b0d9d2fb48b873945865bbfa74d135c58032651d54d6992c4e",
-    "configs/task/libero_joint_2cam224_1e-4.yaml": "1c46f34058c9c5363bab6814a0b86eb13be3a0077e944db7d39cf151da07636e",
-    "configs/task/libero_uncond_2cam224_1e-4.yaml": "27bdc30545aa06bca81137690a241d469d5a67a433881976bd79da3d4171d1a0",
-    "configs/task/roboreal_uncond_3cam_384_1e-4.yaml": "654614f5a146dc7d02aae59b9a184efdf6f88f1a49ca76d48b4eb97847a7bcfa",
-    "configs/task/robotwin_action_mlp_3cam_384_1e-4_v30.yaml": "26d29ac6cba793ccda1e659e6dc495b88f140ebc97257975dc95cedc146c5b76",
-    "configs/task/robotwin_decoupled_3cam_384_1e-4.yaml": "fb0b79ddcfcaf1f04030477d2dda04b0b931d4a85a3b5a7ff253883865ce198f",
-    "configs/task/robotwin_decoupled_3cam_384_1e-4_clean_random.yaml": "7c1273a424a6df2b7407ce692756186d9e42e8cd54451912f200a12a8de02cf7",
-    "configs/task/robotwin_decoupled_3cam_384_1e-4_v30.yaml": "f7f5d3d06b596ce0fc42d44a95d394bf0d1a081c313e2e6336c43aaf7d198642",
-    "configs/task/robotwin_fasterwam_3cam_384_1e-4_v30.yaml": "e03f812c18296d3d9ca9dc6006d18a0db8316dae89d37eb5d87918424fc238b8",
-    "configs/task/robotwin_fasterwam_3cam_384_1e-4_v30_delta.yaml": "11442397245491db776b70bdab6e0c53de8193e340a5d687f158de5be0f9e46f",
-    "configs/task/robotwin_fasterwam_aligned_3dpft_3cam_384_1e-4_v30.yaml": "b5d4e77f862163bb5e5198347a970f1a1c80598062682217e1aac459ae879b40",
-    "configs/task/robotwin_fasterwam_fixed_rope_starclean_holdout.yaml": "4ed28ff0d2749008aabe0eb7768ac42870ff516adbc1fb24cc76ed114abe17c8",
-    "configs/task/robotwin_fasterwam_non_fixed_rope_starclean_holdout.yaml": "72b8e49fa073e9b21f9fb6e2c97cbf10fa93dfaff224726e90a82fed1fb4eb52",
-    "configs/task/robotwin_fastwam_30layer_starclean_holdout.yaml": "7c23c35d1dea094aae9adee6449dc207d4cf6f910ee91528e2aaa2ce3a4bcb31",
-    "configs/task/robotwin_fused_kv_3cam_384_1e-4_v30.yaml": "6ed7b018130805be3d29c7f298697288ba7f95bc9dabf8bec372574897ae4859",
-    "configs/task/robotwin_idm_3cam_384_1e-4.yaml": "2e67c9f301105752962af825e57e5b46ef5e6ba4290e397e5efc7abb88652619",
-    "configs/task/robotwin_joint_3cam_384_1e-4.yaml": "daf4cb5246728ba60ae6903fbfd9d5e029d7172f30916b8143f81783450fa874",
-    "configs/task/robotwin_uncond_3cam_384_1e-4.yaml": "2f78a207415b452b05e0238f3e00eb9942d7960413076b5b3cdcf1ce09caef9f",
-    "configs/task/robotwin_uncond_3cam_384_1e-4_v30.yaml": "f64f830ce7331b8fb6925cd275f23cf34ed7a848a584f2fa5176c7b5aa720e69",
-    "configs/train.yaml": "3d1294b83b7de598fa65e29e96988694be7f4b4c211f5f0890418313421c659c",
-    "pyproject.toml": "cd7abcb7b19b3ab6e2b2f3dd57e3ac7f8f329b07a7f1ff4f819b6627e9045a1a",
-    "scripts/__init__.py": "5a71e51c716ea7579151f36996bebb1ff82c6fedd0c45c68f2918cf5812f1053",
-    "scripts/accelerate_configs/accelerate_zero0.yaml": "dacdf1cee3675246567f1f61e943c6762a4700b8b40c888af8fdf89773adc35b",
-    "scripts/accelerate_configs/accelerate_zero1_ds.yaml": "5b9e24f38c199fdff6bbd17981d86e2624f855f707660094c99f711efc8e0833",
-    "scripts/consolidate_parquets.py": "aeea6ee5c4536843daa5a192280d8f4b126e70a0b5b17d67927b6fb64da2b23e",
-    "scripts/convert_multitask_to_v30.py": "989dfb32c6e2869d8ce6003f3ade338035dcddf6102723dfb3f190cb77f850d8",
-    "scripts/convert_to_v30.py": "55a0685d75287c687759f75ba66faa4c5f2e9f4131e33386c308e4ab5f453dca",
-    "scripts/ds_configs/ds_zero1_config.json": "8b65ebcb8de8c3c89113695a61783cdb97c2aa5003477f0ca743aa511bc68312",
-    "scripts/find_lowest_inference_time.py": "09060fec278c0e107dc1a84ff326ecb0b25dbfd58f83b7bf544d5a6a404e4fe3",
-    "scripts/fix_step5.py": "c7d1a306f3714d48a384e162a1b5c1473e3d7fc6a73d68816ccefc928cd6da5f",
-    "scripts/nccl_smoke_test.py": "207c69bdbacc8fc837372866bd9cf9e50049985d633988b10d972119216c9f0a",
-    "scripts/precompute_clean2rand_text_embeds.sh": "ba39e5506ec920d78f707cb4bf14af44ac0013b7928a130de44f63b088abf59a",
-    "scripts/precompute_libero_plus_eval_prompt_caches.sh": "77d7fd49bca0794a20fb3cbf09102726eb43dae59675c89af6c17d3e5fd7839f",
-    "scripts/precompute_text_embeds.py": "a1c0b63a0cac37394bfb4d023ae5dd916ca64ffbb87b8a086b34c5e4c903ba1e",
-    "scripts/precompute_video_latents.py": "25191edbc21862b87549d613d2d9590772adc67fbbdd3aeee354cc146126c141",
-    "scripts/preprocess_action_dit_backbone.py": "0fb11f04756d71e6b1b1d26cdf9e5831dfead339da38aa25c02f171d7f484a94",
-    "scripts/run_eval.sh": "0f95ef66bf81cbb12857805a96a7d560f7bd56efbe36be4a29b65c55b3497472",
-    "scripts/run_train.sh": "bf470e305d1f663372e7a966bfac2ec8fd5a9bdf0c32f5f028dc135b24b5f610",
-    "scripts/slurm_train.sh": "54a212c718c6b199a9d5e67e726a390adacbde70eec32e0933a6029aaae7f333",
-    "scripts/test_find_lowest_inference_time.py": "23354d0b3fa5b29928597dc9df8ca5ae2e38675d5c59001a212d90c242fa3a54",
-    "scripts/train.py": "0b137862ae1a269863960508d282a27dbaee3caae90c9989403fef977fbbe8b8",
-    "scripts/train_zero1.sh": "3eb17cb89605954acf5652768b1fc174be17c9776d9178c4a82d7483e6a8934c",
-    "scripts_liheng/final_version/README.md": "eefa3d83dd86d0d2b2b90eb8f2e05d553a9f7f66708aebd5f3a0d08cb02cf736",
-    "scripts_liheng/final_version/libero.yaml": "3593f63981c929d21c3f9f61d802d9ede835d6fe9767bf71b9774d00fed26e65",
-    "scripts_liheng/final_version/robotwin.yaml": "4b2e79381fcb82ed39097dc21f6f40c169cbb4f3c766080e851c930ff3bafb40",
-    "src/fastwam/__init__.py": "c4149c5ff0f9abd1517360daf761e692feb8570eb7a0caa2dfde52d4412c3e23",
-    "src/fastwam/datasets/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-    "src/fastwam/datasets/aligned_3dpft.py": "48a439a71ca5e7687f76304d50c3c8b401fce6c255feb60fbab4bd24affbfa7f",
-    "src/fastwam/datasets/dataset_utils.py": "3bc17590049c7cb54061acf8d731b07892e7f530c5d7eeac2613fa77a285a392",
-    "src/fastwam/datasets/eef_anchors.py": "2e0cdd77ab4072a0355f379bbd3c1aaaa845c5ba1098b59b652b8f08495ea961",
-    "src/fastwam/datasets/lerobot/base_lerobot_dataset.py": "4d264f9f96e067883053843c7711644cd129353a9be9a5b0e41c4ab9099174f6",
-    "src/fastwam/datasets/lerobot/constants.py": "11ac9260341e1560c5eb0dd7acb79ed63c74180b8ab4113c27622ff213db417f",
-    "src/fastwam/datasets/lerobot/lerobot/datasets/compute_stats.py": "7d7daab219332b5abdfd5ec67ccaf3502e8eb583a17a4e482c3f3d4f7a691e89",
-    "src/fastwam/datasets/lerobot/lerobot/datasets/utils.py": "f2cfe722464cbe2144efa42eab48e92c4db06cfe0301217c12e03bc9b9a6cee4",
-    "src/fastwam/datasets/lerobot/lerobot/datasets/video_utils.py": "cb647a1e955c3279e39ce8d7af7a37ea7432bbd71534c183f9ceebc8557dd89f",
-    "src/fastwam/datasets/lerobot/lerobot/lerobot_dataset.py": "ef054e5b0dfb3a26e392376699e31808174afd620298f5977e1eb88385d93963",
-    "src/fastwam/datasets/lerobot/processors/base_processor.py": "1f47bc85fee11e3d16714b2f1e3a2dc874f4609a1706a788617156d34b48b58e",
-    "src/fastwam/datasets/lerobot/processors/fastwam_processor.py": "f61b2ed19e199f0e063e727878b17fce70ba451b3ee32b036f0b19e1b2d74384",
-    "src/fastwam/datasets/lerobot/robot_video_dataset.py": "6a2538f41567cc86435d36a90e09c819a82eb0e1ce8897ee10b817758cc0dada",
-    "src/fastwam/datasets/lerobot/transforms/action_state_merger.py": "669d6991415fc5eca44b32b129d15fee1e06e2f17d59d90350c252598033b427",
-    "src/fastwam/datasets/lerobot/transforms/image.py": "4d7ab61d0844918525244db653831f0f632730046b2714a6163ff57c441a16fa",
-    "src/fastwam/datasets/lerobot/transforms/misc.py": "8b505bd9e3a54ab2db7efcd64f0929d2e0303f5db1123de1074fd01fa9887e2b",
-    "src/fastwam/datasets/lerobot/transforms/relative_action.py": "ebd0a50b91b44aac2959b0903d22b197490355ebf1371fb906d424cd1ed4fbb0",
-    "src/fastwam/datasets/lerobot/transforms/rotation.py": "0de34b252d60b956cda07c0c19baebbd3c8a28916face700c6664c5815e11e91",
-    "src/fastwam/datasets/lerobot/utils/normalizer.py": "5ac89a646cd6395e98feaa832f8fdf7c7e00857080af3d9c15710e243c43ad43",
-    "src/fastwam/datasets/lerobot/utils/rotation.py": "6169162f98faf02a3fe5201e2b8a1069fe299840d036ee7cad8af5fa8f561542",
-    "src/fastwam/datasets/robotwin_aligned_3dpft.py": "a25697adce91bb50bc647b5a2750cc6c06a734a853a18e73c7c45ff3575b2aa4",
-    "src/fastwam/datasets/video_latent_cache.py": "029685a2c508093d4103e91b4cfe4752cab02c8a339854c54996ef410d932860",
-    "src/fastwam/geometry/__init__.py": "6dca1e525b0309aa1dc652bc358da8bbffdf6a1b897d550f94e3b6475af25bdb",
-    "src/fastwam/geometry/bearing.py": "b532e46f4ee370512bbb85c8ec6953984d60f45bc7023b25d50b0a7c715af367",
-    "src/fastwam/geometry/calibration.py": "27fd1ac432e2f84e4f93a81c44212e43242935e8e740e4cbe62cc369ce3c040d",
-    "src/fastwam/geometry/camera_source.py": "c1ed83f4ca07906a93591e0909273e9c11e8ae557869a10f2710a40fcdb09389",
-    "src/fastwam/geometry/control_rope.py": "faf4b8161d551bf2f0e04d50863997972e8b3838547309052c02877f65370d53",
-    "src/fastwam/geometry/eef_projector.py": "4573508ee3f4dbe5f73a99267cf8b3e5c039ca8067a8a3060d6653b81e052964",
-    "src/fastwam/geometry/flow_context.py": "176f1f5bec816d79de152a914e6b438dff2f6aa6b86e0cd61b078a0d80f7bd04",
-    "src/fastwam/geometry/flow_trajectory.py": "eb886b53e1c5efe333bbf3dcf7437235168c5d685739a5c12ae9cb487bf45c01",
-    "src/fastwam/geometry/identity.py": "5ce73d68a505f9ade3a607ccb3f87f7c5498acdc64b5f9669b80fb9a2a695102",
-    "src/fastwam/geometry/plus_anchors.py": "0819cfcedfa19a20345c2107e292a5c70bac3ac806054f647ca41581b17fef5f",
-    "src/fastwam/geometry/prox_pinhole.py": "c2e5924c93b6628f22a3609b01a84403821f4ff43e9ebc09fcec1477987908bd",
-    "src/fastwam/geometry/robotwin_flow.py": "ed872b88878961c434ae3cee4d9e36bcf802371c8b5b3e66d3b9784d797c35d2",
-    "src/fastwam/geometry/weak_perspective.py": "5dda53e80d8d69eafb5b6b391c38115f60e263da20f014bede43bc4c38a170a5",
-    "src/fastwam/lr_schedules.py": "a55094b749307d792f10bd8dcee7fec6e64767592fd11ca609efe6bcf2b64ab2",
-    "src/fastwam/models/__init__.py": "ae4c5733f4bbf7caf31df2ae6f789516f6a10cd84a321f7d0375a7034253ac6d",
-    "src/fastwam/models/wan22/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-    "src/fastwam/models/wan22/action_dit.py": "b44dbb467bbe4bdb7aecd3d62398887e969d2322f9b7fa5ba4d1f0d7512f076b",
-    "src/fastwam/models/wan22/action_mlp.py": "cae2696f55eb3ad6a9e0ad57808670e4f5daa2c3cfab779849adeafbf8f64a0f",
-    "src/fastwam/models/wan22/action_proprio_jitter.py": "5e0514d8b6c4b7055ef3d1cbdee7ef8c48f01b68c74ca05f55c757ffece3d359",
-    "src/fastwam/models/wan22/aligned_3dpft.py": "dadf2af499fd1c885c4208eda3d99d9359b9c9e1c8117019886161fdec7ff3c1",
-    "src/fastwam/models/wan22/aligned_3dpft_x0.py": "6457955b5d917b19a887903ef40d1c99c4279aacf8bc1bb04900ba77fa1959aa",
-    "src/fastwam/models/wan22/attn_offset_head_anchor.py": "72db2485774b4092e14b7277a49e4e7faed1afa4b319f7921e5dea27b44795e3",
-    "src/fastwam/models/wan22/control_rope.py": "dc38bac44b7255333db11c51f342b4dada4b1a8583f8c664cc7d905bec7e886b",
-    "src/fastwam/models/wan22/controlnet_pp.py": "9705427f6210b11c6180bd61e7079c3c7d1a06f8c564d1358f63a28f69ead4b6",
-    "src/fastwam/models/wan22/fasterwam_decoupled.py": "1c75e685f0a930dd318f6be2c8440f07ad70c97e23bb889b82272df065d6712c",
-    "src/fastwam/models/wan22/fastwam.py": "22ca5d635f84205f820a9bb2bad618aaa0a2cf0ac34e6296d9209c8e8c59b28e",
-    "src/fastwam/models/wan22/fastwam_action_mlp.py": "6900181ba52cd469d6b67059d1ed1877776bd4f6eaf8e95305467153e2c7b3e2",
-    "src/fastwam/models/wan22/fastwam_decoupled.py": "2e2b1ef09c60a497e778cb8dfde72bb9cc0853651c072c9fa9c9bd910f2134ae",
-    "src/fastwam/models/wan22/fastwam_idm.py": "0f380cef6363123531b116712f7b46dafa16961f50de822881e76fc8b1313b1d",
-    "src/fastwam/models/wan22/fastwam_joint.py": "35bf9bceba78b5c49b6655e5e103fce3566595fce31974a5da54a35ddc3a2ffb",
-    "src/fastwam/models/wan22/ha_content_pp.py": "14419e79fb5bc42f8c3c63385bb6c7d943844fcc5a069ed9baecbfa16241431b",
-    "src/fastwam/models/wan22/helpers/__init__.py": "f26116de229557a37a4812dc4ee75971f5f9e8b80240786ea4d0e5b0ff703cbf",
-    "src/fastwam/models/wan22/helpers/gradient.py": "ba5d8f7272eb029dc6cd2849ca99b70f6ad5abb838d21c818beb0590620dc793",
-    "src/fastwam/models/wan22/helpers/io.py": "1c6c1bc8a975b47092912833194fce25e2e3ac886fbab72d73af3ff5a00b3c62",
-    "src/fastwam/models/wan22/helpers/loader.py": "792f66bd0609c1365256aa24d43301340f81260c1651d89b04d2ae8224a08726",
-    "src/fastwam/models/wan22/helpers/state_dict_converters.py": "81d213373e5056a8d8bf31768b9b04164138ea78d0b306e316334841499f4bf9",
-    "src/fastwam/models/wan22/iha.py": "9ebd044a7a1bc27192425c1ddaee52f6d009b176f632c99b01f5993dd8b6e38a",
-    "src/fastwam/models/wan22/kv_fusion.py": "6d0923ac3c13b003d80c532c33f2f072c88a4a407b631da9f751bbbea8491f49",
-    "src/fastwam/models/wan22/learnable_head_anchor.py": "e4535aa748092bd63786bdcb078655d3fc79cc4260dc69c15f946657a7cbc676",
-    "src/fastwam/models/wan22/mot.py": "e4572d5a63e8a0329a365208161a923116f3d49fe4fe9992998de26abc83c09d",
-    "src/fastwam/models/wan22/mot_decoupled.py": "ecb2feefbb15f0f4c5081f2ed7eed8e0c16dc6ad5fbe3e5c3323d54997f27ca7",
-    "src/fastwam/models/wan22/offset_head_anchor.py": "ded0371aa5e376f2ba54886d3200bdff09d41223d58846ec10d13f25f59c139a",
-    "src/fastwam/models/wan22/piha.py": "671de66cbd53af8af281fd8fa2f3e3eeb7b499d2bc2da30c70c1a0ee5bdb0b99",
-    "src/fastwam/models/wan22/piha_post_rope_kv.py": "98aeffc362e21fb9417264c837ae9a8fc47165ad0aa4421aa0690643c8a46201",
-    "src/fastwam/models/wan22/proprio_offset_head_anchor.py": "46030d28f3beee04900d5ea52c59bed0cf25f2e65efa228671ef69cdea7e4805",
-    "src/fastwam/models/wan22/robotwin_aligned_3dpft.py": "db4ea90fe871746c5fa6afe27bee3d7ee4a9064b3f390d79eecb617906574360",
-    "src/fastwam/models/wan22/schedulers/scheduler_continuous.py": "2ececce284f7b9fe876965fbf5e11ca7b69caaf693979266b0f63062a589f181",
-    "src/fastwam/models/wan22/text_ca_dropout.py": "65d621fb0e3c0c4f10db1d58c7cd53eb53078e44d9ad3266a9f2b1fee8cd2f7a",
-    "src/fastwam/models/wan22/viewlocal_ha_pp.py": "350b06631f6b98056f2e0a9221776e8715614284894e8f28c380c232c5598f04",
-    "src/fastwam/models/wan22/wan22.py": "b72998999b4b2c5096773092339b8ca81e9e7d96f398b81c57d3d22d14972ac4",
-    "src/fastwam/models/wan22/wan_video_dit.py": "9fe059b41fa8248bee5d0e6b49fd22c2d2fe5ef48553a7f1cb06f769a06e6feb",
-    "src/fastwam/models/wan22/wan_video_text_encoder.py": "aedf7f131556a39b99a273deec3a85d67f41b5367cef41f310f33a807ae60a87",
-    "src/fastwam/models/wan22/wan_video_vae.py": "31b3fb9f844a76f5db5af4854e14802aae640b85b61d0de03a4b53b52515abb7",
-    "src/fastwam/runtime.py": "253454009a5defad0f4138875304999ea36195dd59ce4745ab79149880204887",
-    "src/fastwam/trainer.py": "80afaf3dd3d3bffaec81023bc6bd3b7efc822bf5e836f983c2e97e9bc2d96fa9",
-    "src/fastwam/utils/__init__.py": "2893c05b99b17162941c70a41859c2808f8ae390be367a26cac7d5ab93ee197b",
-    "src/fastwam/utils/config_resolvers.py": "01c48cbd42b86e636b70ccc3e193a81147162ba890777102b2c61086fa415340",
-    "src/fastwam/utils/fs.py": "69e6df236b43360428a613686c8f37c531c0d16a3a2c5b06a725c46b49d657c5",
-    "src/fastwam/utils/logging_config.py": "cadc4f6ad487c3f37171a6defad36d23d9ab8bf262f73a461cd9ee9b03b757e7",
-    "src/fastwam/utils/misc.py": "05aa51247936a8d3faac27f90b78b65ff83a688259bed55d114b6a617ced532d",
-    "src/fastwam/utils/pytorch_utils.py": "ffc483e7fb435cd654326750eaffdbfc9243837c3140dcc74e45b24abb751a33",
-    "src/fastwam/utils/samplers.py": "4d3bd9b2d498f4ad8f2cf9765d60c4bf5368fa6fa2a7d42d0db6210f66899652",
-    "src/fastwam/utils/video_io.py": "9e9898b021a44e87aa1b4e6d13e3755a9869a2e27a7eb53c72a6802808d5bd80",
-    "src/fastwam/utils/video_metrics.py": "aaa37e458cc9e4bb79a17923b5ff5900c97b4309f7abd50db44cf76e9143ffd6",
-    "tests/print_eval_results.py": "34590e8ce1baa7a93a453e0ac3af0e1be38392e20d8e19330932f1e598ac5f80",
-    "tests/print_real_dimensions.py": "bf718b8feb599a9e7f52d3227171079b6acee5c4dbc8d520d6567bfd0da0e3c2",
-    "tests/test_action_dit_selective_init.py": "0f8e8ab3ed9366b797a51a092e5eec57a516462105137e207dc52cea93ae8ff1",
-    "tests/test_action_mlp.py": "6880720c982d1350ee207c21c32e74af4ffc89fd6c4673a9fe7a5fef74984005",
-    "tests/test_action_proprio_condition_jitter.py": "99877f4f7f5256fec08c3043b3abadc90bc89e8d411db5c7f30d5e754595978b",
-    "tests/test_action_proprio_null_dropout.py": "1bfa23472c4493b6e5d8c046a988e3d98ea9e2de7f48591bba968a623374eff3",
-    "tests/test_action_text_ca_dropout.py": "ffd1bd7c0cab920bef709f18fb3cca7d31e88fcc8c4542b4c1436e65aa38f624",
-    "tests/test_action_text_ca_post_droppath.py": "ffc4f40854b2a21260a4d6ebf8250599ef88fe5972974e77eb29c9fbe4a9bc13",
-    "tests/test_action_text_ca_proprio_jitter.py": "1256041d8c86a4a9ecdc3be51e6ff4c494ea13fbbc5c95849049fce5c30d0a1e",
-    "tests/test_action_text_cross_attn.py": "58a2f441f666ebef0d755c9c894b4fd55720600899db00f47e4b2901c4fb0487",
-    "tests/test_aligned_3dpft.py": "be54483206fed5410491116487975bc5626712c9bfa9b9ed6116ec21b8ad3a85",
-    "tests/test_aligned_3dpft_eval_context.py": "9c7097662669a1122d2f39fbcb5f758e1e79d5e80c34f7c6ae84a682e27f3b13",
-    "tests/test_aligned_3dpft_factory.py": "fe052ecfdc71c84c7747e49e28a7537e776751f874443d2fbf75fc19ef425941",
-    "tests/test_aligned_3dpft_live_camera.py": "0ff58b5ecc6a67d9eb8602499c0c24206c60cbe2b1a676b07ba58eea13ea369b",
-    "tests/test_aligned_3dpft_native_launchers.py": "408b9efc6f1727f030e03ba244d20066fd5cb950d6d5a91bc4475570175244c5",
-    "tests/test_aligned_3dpft_x0.py": "097aff5b5e3094999d95ca63b5cc9ffaabec98fe45646c15bfa2b17d2d98d18c",
-    "tests/test_attn_head_softmax_libero.py": "ef1d4a23aa160c328d57afae626cd509f193041cf5b5507a762d2792c8119e77",
-    "tests/test_attn_offset_head_anchor.py": "08d86090997ac6f8c0564e50664c7b8a0f5541c8d92ee5acc5bec8f8d9b057e1",
-    "tests/test_bearing_projection.py": "84b2bad0bc07d8b936b78d30ac72bd0c750db8f0e72b0816b1e9e6fec8f1c190",
-    "tests/test_checkpoint_identity_metadata.py": "4f89721f55275c1d0dfac8156ba5aed8618f6c5b02194ef1565f714ffc5b418c",
-    "tests/test_config_resolvers.py": "f3a3686cf924797c4b24caa97dcad12d65eb5de950a6a449483109c94fb2da05",
-    "tests/test_control_rope.py": "6281fc66eea8b5c1340a8549b77d3928f276e1fffa2635072d1118dd4d5b2d83",
-    "tests/test_controlnet_pp.py": "eac6a8e177f68421035b6d6f062686ab15cdb0c051b6f3432311baf2daeb8d1d",
-    "tests/test_decoupled_full_integration.py": "671a9e8caea55b9532f9637b4030664d9e141576c99a8ce112ea279711585d54",
-    "tests/test_decoupled_prelaunch_gate.py": "bea2f1e5834183b6143b16b8683c7433aa3250760b4f2d18120bf568e6b2e916",
-    "tests/test_decoupled_shapes.py": "560de0e0593933284e27c418b8a9776e2ac613d9e13dadbeb086e5dfc86954d5",
-    "tests/test_decoupled_stress_edge_cases.py": "d2b9ca8ede032e64ddfb925a0beacbc2ba8425c25048ed515d8cd3442b93ad55",
-    "tests/test_decoupled_stress_mutation.py": "ed17b747c1db8467ac75407180ad32f5d840b41fdc3c9b099a03a18e987364fb",
-    "tests/test_decoupled_stress_pipeline.py": "9b90e942fb935d7e6d96b9a5a34f62e75a991bb6603499a92bd0853a11482b52",
-    "tests/test_decoupled_vs_baseline_comparison.py": "f004729b97c47224f62539ef1f8256315f6544c0109cde952b6712b1192fd1fc",
-    "tests/test_eef_anchor_dataset_threading.py": "8608c1fdf80ed434bd1e389dd9f6132bb39d077f3574e328d4955fc49bcece12",
-    "tests/test_eef_anchor_tooling.py": "0e16f0dac6bf17dd9ef50cc622fd0a786f120b7fbaa36c399e99eeede7126958",
-    "tests/test_eef_calibration_artifact.py": "32c8b89e0531d3cda947aee57841de68bdf44125af34ce0e92538681e4501422",
-    "tests/test_eef_calibration_parity.py": "80f4d3dac2056428629868cc2c8e61bcbab71aa45ea2ae70b92c06aacbdb9e3a",
-    "tests/test_eef_projector.py": "c564ea2b643a78407307b47828f4beee56b3750a838df0f71fcaa6b39d080edf",
-    "tests/test_explicit_checkpoint_steps.py": "feaeb15ee0aee6a43c473d586ebaf6fc8d321fe7cec571ab643870298495d68a",
-    "tests/test_fasterwam_fused_inference.py": "db548954165f610c066b643cab72617c2fe78661f2214b3e4a56bebf9f42a2f0",
-    "tests/test_fasterwam_fused_kv_rope_gate.py": "54362f3121f98031a5b46490ac81c67b563cd6a480ef49bcfc2062d9475f2f06",
-    "tests/test_fasterwam_fused_mlp.py": "6bef5c70b3e2e48524420f34f36578c12041ed9eff37d1f6fac0beea3e907da3",
-    "tests/test_fasterwam_fused_mlp_gate.py": "277aaf626e82618586583dca51b04a759de94b2ce2247e58362d40d4be911931",
-    "tests/test_fastwam_decoupled.py": "3d1139dc08434a20767abd34c42557335dac2323e04517243a555e09bde8ef7a",
-    "tests/test_fastwam_idm.py": "9c265791e9bb0ac010e793de2febb57cffae8296a168959a26b4d3b132da4b9c",
-    "tests/test_fastwam_joint.py": "9b739c632f32f48e170b71acd6804654e732f02809d10e61cd738b3d65009b5c",
-    "tests/test_freeze_integration_gpu.py": "4716b14ae346d032147ec4c59a9611080835728c6d83005705a28c0e9e82c18b",
-    "tests/test_freeze_trainer_wiring.py": "2398d3b91e004931f60ee1695a932dba1a3195c360cb1daf0c697b11e2b813b7",
-    "tests/test_freeze_video_backbone.py": "a703963d4ba806cac1d022ef398919eb9db892f68d8fea213be3eb71b1724a7f",
-    "tests/test_fused_kv_checkpoint_guard.py": "916c878cce9aedaf68e4390606c317398cc3ac9604a0b372609702ede87f2185",
-    "tests/test_fused_kv_prefill_consistency.py": "50dfd01e6e00cc289bc483df1242ee58d504d2c48e7670a69331ef0ee14bf39e",
-    "tests/test_ha_content_pp.py": "ede7c7543fd7fd78b108dee29b60abbe8308ef1fff55fd2b779aba272ddb1a87",
-    "tests/test_ha_origami.py": "c9dcbfe0449f4c5332bcb89be8a549cfaf4e94d83cd92f2b5acb1cc75412110d",
-    "tests/test_iha.py": "e53b7a14e27b57798929b0da06370dc08d7204dd2b422ccecb05004e7670f8c5",
-    "tests/test_interleaved_forward.py": "533e43c99a2de4d3ff4fb2ae982e9d8fab8b8a99d539411f8391f0e30c2bcdc0",
-    "tests/test_kv_fusion.py": "7aafff16c4e2c47468d64920fb1937e9570c234b02996ddf0453c96d3640c36a",
-    "tests/test_kv_fusion_factory_integration_gate.py": "e03cbb0163bb75f18c9f3d619976f143665a6f9c69edce52521cf970379512c5",
-    "tests/test_kv_source_mapping.py": "de282041d88a5dfcd026498e103603292186dae3b341f265f9b6c74a785f5e33",
-    "tests/test_learnable_head_anchor.py": "9d71e07cc3a7c1066ecc1f2e2907435eeff24d82ddaa1cf07629d2ab84cd8760",
-    "tests/test_libero_4090_dispatcher_policy.py": "9acfd91c87fc3298e0b67a71048f11fa5b943d42ee29c3756e10d33bd887aaac",
-    "tests/test_libero_4090_dispatcher_sim.py": "353483387264277c129ed693fb508ea5a2c809a8c651154f95141c33c16eb514",
-    "tests/test_libero_actor_topology.py": "1b2087b23fa811653b102c5e5c83a98b12e6c25dd5e9ef9f4559855cd25119e3",
-    "tests/test_libero_batch_dispatch.py": "9252872495832d5a999f11968cd2e843dc54c9c2db96697c3620239aa29014b7",
-    "tests/test_libero_batched_inference_gate.py": "1174a1d8237cf72b711a4915327d0a5444fb7440c5b30312eb8230a1bd58bb55",
-    "tests/test_libero_context_cache.py": "e550ff058b42015e61b4a13e3cdad060155e0ed107d1441c0f0b8f4d0082995a",
-    "tests/test_libero_eval_batch_topology.py": "3c81cd05c52f3f0784f54adb7cb9ac0876ffb8cf95b936444a5568f76a43ec58",
-    "tests/test_libero_fixedenv_actor.py": "aa9c29060e45d47aa13fcd77b66264c4a0b78ff4862d697c6e5cca6102c0748c",
-    "tests/test_libero_image_preprocessing.py": "f54af57369de94461d7f5223ae42f20d435b92ec5997eccdf9dd79d132ebc1e7",
-    "tests/test_libero_jitter_handoff_queue.py": "357c463799c87b6b9b27de818479e281120f3d2268a541a0d9e48c80eab93f2b",
-    "tests/test_libero_localpipeline_cluster.py": "1dacea0ccbbb5f6b008996433ce8d301ac7ba0721b5763a449f6642bd1b49714",
-    "tests/test_libero_manager_shutdown.py": "7296534d9b2d4aa7a0077732361810de4a326de32bf5f0dbedf092eef5b3e107",
-    "tests/test_libero_manager_topology.py": "532614cf5fdca51e43c54f89164bce1202048f84203349f6bd87e62e4addc4d1",
-    "tests/test_libero_plus_gpu_defaults.py": "9584355e771ea339bb267775b9015e1870116885011a5e2a46980a3b4b061df3",
-    "tests/test_libero_precision_pair.py": "d79d4e7db637c00d8ba5d76ac6c884996fb107da2ea5437fb8200d2e6658e267",
-    "tests/test_libero_shared_model_batch.py": "9e98c9605ab229bf8389abe693524133c877fe20e4ca074f0e6ef6dfc84bf086",
-    "tests/test_libero_standard_gpu_defaults.py": "1d86ca160c1a0130c046dbaa97a7ad32f6f22d9e53445cd6a706d9fa9239d79d",
-    "tests/test_libero_standard_protocol.py": "6586b7e55cea78b1e8299c5d8a8e27a7f05c6585640b01b35bc191485a9fc66a",
-    "tests/test_libero_task_work_queue.py": "be8b7430624bfdabb10980f2969dd24c73206679c2339ff5faad9f3539d9665c",
-    "tests/test_libero_topology_config.py": "48b9ee1f0684037c1ad17b9ce82ed738534a0b977f1ac3da2c194689e0645aa3",
-    "tests/test_libero_wide_s2_notextca_switch.py": "1bb77467c705d9327cbbf5309ee5749ea20e1704b3c054459e82c859846b0e7b",
-    "tests/test_local_libero_reference_verifier.py": "015d4f8a30a56d2aecdcafd4fba8224d1867e787938cb7d2de8f9669b54101fe",
-    "tests/test_lr_schedules.py": "e95695bc09ab2b73b91f4e0cdc744c1622e80f9b3ce6bf8bc2b72eae7e0bea77",
-    "tests/test_nd01_resume_topology.py": "4626002a1106f9f391e84138d6c1b0fe912984e6efdcd8766442048c7404129c",
-    "tests/test_new_fused_kv_freqs_guard.py": "1a05a96c6aa6a90c9c866bdc96e019402e8ab38cb8a02d58b00dd7f49fe10abe",
-    "tests/test_new_fused_kv_projection_contracts.py": "a57ff0c233fb2a1674ff24e791b2f446c5fb36697b87738849cc33d3f854c40e",
-    "tests/test_non_decoupled_inference.py": "083ec475d1c2e8fc051cbeaa347ad8ab53ff616095e78cc6eaf4f147dc4123c0",
-    "tests/test_normalizer.py": "9a4385f581ef300d1a6c56ad354665bc78e4ddb00abd928fba27e8eed697299d",
-    "tests/test_offset_head_anchor.py": "46da333b0d6958935a1e16fc251383f9b2c0730c0c5465e5547f36a3ecba0197",
-    "tests/test_per_request_noise.py": "4983702be58d30196e1cccbc1dc168e6492617de2ff7f69a7bb57eb4f1c204ad",
-    "tests/test_piha.py": "6af1a7db6bcba26b74423f39582bb8d299035bba02a4eb3711efea83f0645b59",
-    "tests/test_piha_post_rope_kv.py": "211b76bd730f4030c3c4dbaa8b6e8074f9b7b2e1eaf061db474be60a1ca1b27b",
-    "tests/test_plus_anchors.py": "665d9cf67b9c0c7f3b867c3a4b1a9ccd81ea18b262feca008f7151d7adc01d65",
-    "tests/test_postrope_readout_observer.py": "1555c682e6c2e4c183c1dfcbd50d336d3ae04fd903f1a1c5b58f7644e2d7813a",
-    "tests/test_preflight_libero.py": "252ec7ee0ecab2a39decf9a1118fb07787e9bc11fb1631c8aec71288f08b7eb4",
-    "tests/test_proprio_offset_head_anchor.py": "9f0d076810f56874f4367f65806c34d94b7af5ac8230229fb99de5ca83899b2c",
-    "tests/test_prox_pinhole.py": "b3c1a59252d3f5443e796283760f46157011ddb7461c0c52304161637e619ee5",
-    "tests/test_relative_joint_transform.py": "f2df795ad3f9ec3eca37279e60d97602dc44508b1fe09d63907f0251c8ec46fd",
-    "tests/test_resume_eval_manager.py": "7244d315c62c05aa111e99e0f81ef2757d49f1385798e2be70dbdce36cbeb8af",
-    "tests/test_robotwin_3843_env0_extra2.py": "40e3f20410af3351872be41a3136653e7500148583e466e31012f911265e8c6f",
-    "tests/test_robotwin_3843_env0_extra3.py": "d5ca67a8de097c1e837c1f6228ee9d4326295094370e87b0370fd987c8a3e61e",
-    "tests/test_robotwin_3843_env0_switch.py": "b1b41709a15db2676683e04889a7efddb4fe1e8cbebb9a3238ee585e30c73e44",
-    "tests/test_robotwin_3843_env42_switch.py": "10cad34ccab31e551a55ce8325d450ad63c39e3ff4c6c874f39de7aa36340355",
-    "tests/test_robotwin_aligned_3dpft.py": "b04376e1b9417f47e30bcec7aeea88e32e722250c165125448749fda1b31c661",
-    "tests/test_robotwin_aligned_3dpft_factory.py": "376cce62d42a209da5624ab46f63c362bae6f469605ead6fa87f0c38a99ce443",
-    "tests/test_robotwin_aligned_3dpft_rope.py": "48b64a1d3b5e3f32e2dae228bd9e1d36e03a760c9a1433a5798a718f17914a41",
-    "tests/test_robotwin_bf16first_overlay.py": "e30ccd71b92296444cbe76647f3ee0e1b17203ac2a3ab9bf54d85d965633dba6",
-    "tests/test_robotwin_bf16first_repeats.py": "651c698df4210e43f8f49abbd838c7dd109695c79f1582bbda28ccc54ed3a54a",
-    "tests/test_robotwin_cyclic3911_extra3.py": "d7f2af23780f066a2e0eb440d5a0181c6ce3e16ab9b6cd5bbc141bb9da930857",
-    "tests/test_robotwin_cyclic_error_retry.py": "660bb6cf0199a49260cc1d18f0ccdfffe1cb1afddef5dee30b5a09b907a12e3e",
-    "tests/test_robotwin_m2_wide_cyclic_notextca_recipe.py": "68c670f513b36683a62e5e48863f710fb73147281f6fe738d1e8f847cc84f4ac",
-    "tests/test_robotwin_nd05_lr5e5_recipe.py": "adbac1f1c54b815541c31d32b9031c0a820923fceb0d60a7481dc74da3398110",
-    "tests/test_robotwin_piha_post_rope_kv.py": "b2164aab5d28321e3bb8b303cf3d2012be706b1938b03408c02ee20a64044d36",
-    "tests/test_robotwin_wide_cyclic_notextca_recipe.py": "95b93ece32702fc8adcbba2e82869b0228c25c8aa5a14ba5e47512e98220e787",
-    "tests/test_robotwin_wide_s3_notextca_cosine_8ep_recipe.py": "e6d47bb5ec9ec6959bf8db9957ed0a007b7f7e1f33764aaa8124d0872209ef95",
-    "tests/test_samplers.py": "998afae7f0e0d461b56ca195218b2ec428e6be5a0c29baee2e0103e8687510df",
-    "tests/test_scheduler_continuous.py": "e1014ef8883075686c09faeb2c1e7a814dd20e25657ec409bb9b120b6db0a1bb",
-    "tests/test_sepnull01_eval_summary.py": "56860f190ed804d549cfba18c9ea49b3d682971e1c32f7f2fd46eb9bf147257c",
-    "tests/test_sepnull01_fixedenv.py": "c9ccc86f1315efce4d277c849277475e76cd1a2bd1e3de6e330386531a98f03f",
-    "tests/test_simplepad_standard_cfgdrop01.py": "0de131a91a0118e131ff0f9aeb95dfabc3c536360f9cc7b3fce12959cca3ba26",
-    "tests/test_state_dict_converters.py": "a5c2ee0e6fb098e9c07327afd55eb9aeecec8a24fc2b1e8b18e951ed8a9e5482",
-    "tests/test_summarize_libero.py": "43ec6f729c399df11b192bff4b2f0a82310a118194efcc61f0fd3c51bf13bd60",
-    "tests/test_transforms.py": "2893a02cab2eca2b94bf2f91a8c559094bae7c2d36bc25b79d41bce7ba795e81",
-    "tests/test_v30_dataset.py": "355c6c29185e39279d8267e52b98eb3336284f2f4d64cb5c030d536b993cdb1e",
-    "tests/test_verify_liberoplus_install.py": "79dfd53fbaed29dd687f198f7ffea70302ef5110fd50b1db6a57e172e80dfc8b",
-    "tests/test_video_latent_cache.py": "791c0d93ef99735fd64c05235037042caf8cefda8682478d5eedf44cdbae6334",
-    "tests/test_video_latent_cache_real_gate.py": "c087aeb585504c154bf2216791148a9858238f2d8295afe88cb4cab596c69435",
-    "tests/test_video_metrics.py": "5d6ffdde7c0a642807f2c728b44d16909574118616ebfb70de66494e1435a7c7",
-    "tests/test_viewlocal_ha_pp.py": "13159450cd3a6761edd4c35cbfbaab3addbfa3a2b3f6f516f3589bc18f46840a",
-    "tests/test_weak_perspective.py": "edfda5a6793f76074548019c165b2285fc091916fa30ba93a6a81f8d2c29a76b",
-    "tests/test_wsd_extension_preparation.py": "c1a6165849f88c78d9a14b3fa78dfd7c082086b78047fce22dfae3f9eeb380d8",
-    "tests/verify_decoupled_config.py": "c20f11c029b168605a8b1c0b56d68cbeafea9649ceb54414c32f973282d61dd5",
-    "tests/verify_dimensions_both_modes.py": "faeba9f69770520b4fcb849d2e277a9e4f14c968d69d7b493f17035fbb4a19ee",
-    "tests/verify_kb_lean.py": "6527db5b95d7188b0d66f11ab3236e426b149261920c10f5503514fc6676c7b7",
-    "tests/verify_kb_real_gpu.py": "6ce6180d2e16df40adffea84f56e85cadec81f90c2261728f5e0ba6f249cb0b7",
-    "tests/verify_kb_sysdiag_gaps.py": "32d17be18535e8dd0a1326af5028f3a6ed66ff11f4ada626cb5ca87d6b8bda0f",
-    "tests/verify_knowledge_base_deep_dive.py": "001a19226ca0c6b087609845e54677c609308ca549804df55365374905d1bafe",
-    "tests/verify_knowledge_base_system_diagram.py": "6c5f554e5c4add0c51cf3c8d6d11b6b5bb0436bf4f38ab4028965d1a46f2665c",
-    "tests/verify_mot_mask_topology.py": "32d50a2f48a93963d78916eace52414e8ef32bfa3462d6d6435f3e8b30ed0af6",
-    "tests/verify_selective_init_integration.py": "518ad075e1c758c9cc655637ea4a4edfc99b9a053f36ad8ac570fb78976da00e"
-  }
-}

joint/fasterwam/train90_joint_job4247/provenance/training_summary.json

@@ -1,3 +0,0 @@
-{
-  "note": "Run cancelled by user; W&B summary not finalized."
-}

joint/fasterwam/train90_joint_job4247/requirements.txt

@@ -1,226 +0,0 @@
-anyio==4.14.2
-httpx==0.28.1
-nvidia-ml-py==13.595.45
-tqdm==4.70.0
-click==8.5.0
-h5py==3.16.0
-httpcore==1.0.9
-fsspec==2026.7.0
-numpy==2.2.6
-huggingface_hub==1.29.0
-nvitop==1.7.1
-filelock==3.32.4
-hf-xet==1.6.0
-typing_extensions==4.16.0
-exceptiongroup==1.3.1
-h11==0.16.0
-psutil==7.2.2
-Flask==3.1.3
-gymnasium==1.3.0
-packaging==25.0
-packaging==26.0
-Jinja2==3.1.6
-lazy-loader==0.5
-fsspec==2025.3.0
-pillow==12.0.0
-six==1.17.0
-frozenlist==1.8.0
-idna==3.16
-mplib==0.2.1
-aiosignal==1.4.0
-nvidia_curobo==0.0.0
-setuptools-scm==10.0.5
-sympy==1.14.0
-widgetsnbextension==4.0.15
-ConfigArgParse==1.7.5
-msgpack==1.1.2
-embreex==4.4.0
-parso==0.8.7
-zipp==4.1.0
-nvidia-cuda-nvrtc-cu12==12.8.61
-exceptiongroup==1.3.1
-datasets==3.6.0
-triton==3.3.1
-av==16.0.1
-tokenizers==0.21.4
-nvidia-nvjitlink-cu12==12.8.61
-fastwam==0.1.0
-Werkzeug==3.1.8
-retrying==1.4.2
-aiohttp==3.13.5
-dash==4.1.0
-propcache==0.5.2
-joblib==1.5.3
-tzdata==2026.2
-pandas==2.2.3
-nvidia-cusparse-cu12==12.5.7.53
-typing-inspection==0.4.2
-charset-normalizer==3.4.7
-nbformat==5.10.4
-boto3==1.35.99
-cycler==0.12.1
-ipython==8.39.0
-omegaconf==2.3.0
-setuptools==69.5.1
-setuptools==82.0.1
-jsonschema==4.26.0
-python-dateutil==2.9.0.post0
-pexpect==4.9.0
-svg.path==7.0
-numpy==1.26.4
-vcs-versioning==1.1.1
-blinker==1.9.0
-modelscope==1.34.0
-scikit-image==0.25.2
-fusepy==3.0.1
-plotly==6.7.0
-requests==2.34.2
-stack-data==0.6.3
-shapely==2.1.2
-jsonlines==4.0.0
-sapien==3.0.0b1
-typer==0.25.1
-hf-xet==1.5.0
-jedi==0.20.0
-imageio-ffmpeg==0.6.0
-ninja==1.13.0
-gitdb==4.0.12
-mapbox_earcut==2.0.0
-jsonschema-specifications==2025.9.1
-s3transfer==0.10.4
-Farama-Notifications==0.0.6
-tifffile==2025.5.10
-smmap==5.0.3
-nvidia-cudnn-cu12==9.7.1.26
-trimesh==4.12.2
-pydantic==2.13.4
-pycollada==0.9.3
-scipy==1.15.3
-nvidia-nccl-cu12==2.26.2
-rich==14.2.0
-mpmath==1.3.0
-nvidia-cuda-cupti-cu12==12.8.57
-aiohappyeyeballs==2.6.2
-torchvision==0.22.1+cu128
-torch==2.7.1+cu128
-Pygments==2.20.0
-annotated-types==0.7.0
-traitlets==5.15.0
-GitPython==3.1.45
-toppra==0.6.8
-opencv-python==4.11.0.86
-h5py==3.16.0
-vhacdx==0.0.10
-rpds-py==0.30.0
-yourdfpy==0.0.60
-torchcodec==0.5
-tqdm==4.66.5
-referencing==0.37.0
-transformers==4.49.0
-pytz==2026.2
-PyYAML==6.0.3
-itsdangerous==2.2.0
-warp-lang==1.6.1
-antlr4-python3-runtime==4.9.3
-regex==2025.11.3
-addict==2.4.0
-nvidia-cusolver-cu12==11.7.2.55
-pyarrow==23.0.0
-botocore==1.35.99
-httpcore==1.0.9
-imageio==2.37.0
-einops==0.8.1
-threadpoolctl==3.6.0
-multidict==6.7.1
-urllib3==2.7.0
-nvidia-curand-cu12==10.3.9.55
-anyio==4.13.0
-asttokens==3.0.1
-open3d==0.19.0
-fonttools==4.63.0
-certifi==2026.5.20
-narwhals==2.21.2
-safetensors==0.5.3
-jupyter_core==5.9.1
-h11==0.16.0
-hjson==3.1.0
-ipywidgets==8.1.8
-markdown-it-py==4.2.0
-deepspeed==0.18.5
-jupyterlab_widgets==3.0.16
-contourpy==1.3.2
-scikit-learn==1.7.2
-pyperclip==1.11.0
-pydantic_core==2.46.4
-annotated-doc==0.0.4
-dill==0.3.8
-pure_eval==0.2.3
-shellingham==1.5.4
-jmespath==1.1.0
-transforms3d==0.4.2
-psutil==7.2.2
-importlib_resources==7.1.0
-pyparsing==3.3.2
-importlib_metadata==9.0.0
-nvidia-nvtx-cu12==12.8.55
-MarkupSafe==3.0.3
-nvidia-cufile-cu12==1.13.0.11
-matplotlib==3.10.9
-click==8.4.1
-nest-asyncio==1.6.0
-nvidia-cusparselt-cu12==0.6.3
-kiwisolver==1.5.0
-numpy-quaternion==2024.0.13
-rtree==1.4.1
-sentry-sdk==2.60.0
-manifold3d==3.5.0
-matplotlib-inline==0.2.2
-multiprocess==0.70.16
-mdurl==0.1.2
-platformdirs==4.9.6
-nvidia-cufft-cu12==11.3.3.41
-nvidia-cuda-runtime-cu12==12.8.57
-accelerate==1.12.0
-xxhash==3.7.0
-wandb==0.23.1
-cloudpickle==3.1.2
-networkx==3.4.2
-ptyprocess==0.7.0
-termcolor==2.5.0
-tomli==2.4.1
-async-timeout==5.0.1
-typing_extensions==4.15.0
-wcwidth==0.7.0
-comm==0.2.3
-py-cpuinfo==9.0.0
-decorator==5.3.1
-prompt_toolkit==3.0.52
-nvidia-cublas-cu12==12.8.3.14
-hydra-core==1.3.2
-fastjsonschema==2.21.2
-filelock==3.29.0
-httpx==0.28.1
-attrs==26.1.0
-pybind11==3.0.4
-yarl==1.24.2
-executing==2.2.1
-protobuf==6.33.6
-colorlog==6.10.1
-lxml==6.1.1
-pyquaternion==0.9.9
-wheel==0.46.3
-pip==26.0.1
-huggingface-hub==0.29.2
-fastwam==0.1.0
-autocommand==2.2.2
-backports.tarfile==1.2.0
-importlib_metadata==8.7.1
-jaraco.text==4.0.0
-jaraco.context==6.1.0
-jaraco.functools==4.4.0
-more-itertools==10.8.0
-packaging==26.0
-platformdirs==4.4.0
-tomli==2.4.0
-wheel==0.46.3
-zipp==3.23.0

joint/fasterwam/train90_joint_job4247/splits/dish_utensil_lerobot_v21.json

@@ -1,118 +0,0 @@
-{
-  "dataset": "dish_utensil_lerobot_v21",
-  "dataset_dir": "/shared_work/amin-a/realworld-wam/data/dish_utensil_lerobot_v21",
-  "generated": "2026-09-10T20:23:03Z",
-  "seed": 42,
-  "val_proportion": 0.1,
-  "recipe": "sorted(episode_ids) shuffled by np.random.default_rng(seed), split at int(total_episodes * (1 - val_proportion)); matches fastwam base_lerobot_dataset.py",
-  "total_episodes": 100,
-  "total_frames": 42863,
-  "train_episodes": 90,
-  "train_frames": 37936,
-  "val_episodes": 10,
-  "val_frames": 4927,
-  "train": [
-    0,
-    1,
-    2,
-    3,
-    4,
-    5,
-    6,
-    7,
-    9,
-    10,
-    11,
-    15,
-    16,
-    17,
-    18,
-    19,
-    20,
-    21,
-    22,
-    23,
-    24,
-    25,
-    26,
-    27,
-    28,
-    29,
-    30,
-    31,
-    32,
-    33,
-    34,
-    35,
-    37,
-    38,
-    39,
-    40,
-    41,
-    42,
-    43,
-    44,
-    45,
-    46,
-    48,
-    49,
-    50,
-    51,
-    52,
-    54,
-    55,
-    56,
-    57,
-    58,
-    59,
-    60,
-    61,
-    62,
-    63,
-    64,
-    67,
-    68,
-    69,
-    70,
-    71,
-    72,
-    73,
-    74,
-    75,
-    76,
-    78,
-    79,
-    80,
-    81,
-    82,
-    83,
-    84,
-    85,
-    86,
-    87,
-    88,
-    89,
-    90,
-    91,
-    92,
-    93,
-    94,
-    95,
-    96,
-    97,
-    98,
-    99
-  ],
-  "val": [
-    8,
-    12,
-    13,
-    14,
-    36,
-    47,
-    53,
-    65,
-    66,
-    77
-  ]
-}

joint/fasterwam/train90_joint_job4247/splits/fruit_pick_lerobot_v21.json

@@ -1,118 +0,0 @@
-{
-  "dataset": "fruit_pick_lerobot_v21",
-  "dataset_dir": "/shared_work/amin-a/realworld-wam/data/fruit_pick_lerobot_v21",
-  "generated": "2026-09-10T20:23:10Z",
-  "seed": 42,
-  "val_proportion": 0.1,
-  "recipe": "sorted(episode_ids) shuffled by np.random.default_rng(seed), split at int(total_episodes * (1 - val_proportion)); matches fastwam base_lerobot_dataset.py",
-  "total_episodes": 100,
-  "total_frames": 20149,
-  "train_episodes": 90,
-  "train_frames": 17863,
-  "val_episodes": 10,
-  "val_frames": 2286,
-  "train": [
-    0,
-    1,
-    2,
-    3,
-    4,
-    5,
-    6,
-    7,
-    9,
-    10,
-    11,
-    15,
-    16,
-    17,
-    18,
-    19,
-    20,
-    21,
-    22,
-    23,
-    24,
-    25,
-    26,
-    27,
-    28,
-    29,
-    30,
-    31,
-    32,
-    33,
-    34,
-    35,
-    37,
-    38,
-    39,
-    40,
-    41,
-    42,
-    43,
-    44,
-    45,
-    46,
-    48,
-    49,
-    50,
-    51,
-    52,
-    54,
-    55,
-    56,
-    57,
-    58,
-    59,
-    60,
-    61,
-    62,
-    63,
-    64,
-    67,
-    68,
-    69,
-    70,
-    71,
-    72,
-    73,
-    74,
-    75,
-    76,
-    78,
-    79,
-    80,
-    81,
-    82,
-    83,
-    84,
-    85,
-    86,
-    87,
-    88,
-    89,
-    90,
-    91,
-    92,
-    93,
-    94,
-    95,
-    96,
-    97,
-    98,
-    99
-  ],
-  "val": [
-    8,
-    12,
-    13,
-    14,
-    36,
-    47,
-    53,
-    65,
-    66,
-    77
-  ]
-}

joint/fasterwam/train90_joint_job4247/splits/place_cube_lerobot_v21.json

@@ -1,118 +0,0 @@
-{
-  "dataset": "place_cube_lerobot_v21",
-  "dataset_dir": "/shared_work/amin-a/realworld-wam/data/place_cube_lerobot_v21",
-  "generated": "2026-09-10T20:23:10Z",
-  "seed": 42,
-  "val_proportion": 0.1,
-  "recipe": "sorted(episode_ids) shuffled by np.random.default_rng(seed), split at int(total_episodes * (1 - val_proportion)); matches fastwam base_lerobot_dataset.py",
-  "total_episodes": 100,
-  "total_frames": 9267,
-  "train_episodes": 90,
-  "train_frames": 8362,
-  "val_episodes": 10,
-  "val_frames": 905,
-  "train": [
-    0,
-    1,
-    2,
-    3,
-    4,
-    5,
-    6,
-    7,
-    9,
-    10,
-    11,
-    15,
-    16,
-    17,
-    18,
-    19,
-    20,
-    21,
-    22,
-    23,
-    24,
-    25,
-    26,
-    27,
-    28,
-    29,
-    30,
-    31,
-    32,
-    33,
-    34,
-    35,
-    37,
-    38,
-    39,
-    40,
-    41,
-    42,
-    43,
-    44,
-    45,
-    46,
-    48,
-    49,
-    50,
-    51,
-    52,
-    54,
-    55,
-    56,
-    57,
-    58,
-    59,
-    60,
-    61,
-    62,
-    63,
-    64,
-    67,
-    68,
-    69,
-    70,
-    71,
-    72,
-    73,
-    74,
-    75,
-    76,
-    78,
-    79,
-    80,
-    81,
-    82,
-    83,
-    84,
-    85,
-    86,
-    87,
-    88,
-    89,
-    90,
-    91,
-    92,
-    93,
-    94,
-    95,
-    96,
-    97,
-    98,
-    99
-  ],
-  "val": [
-    8,
-    12,
-    13,
-    14,
-    36,
-    47,
-    53,
-    65,
-    66,
-    77
-  ]
-}

joint/fasterwam/train90_joint_job4247/splits/push_t_lerobot_v21.json

@@ -1,118 +0,0 @@
-{
-  "dataset": "push_t_lerobot_v21",
-  "dataset_dir": "/shared_work/amin-a/realworld-wam/data/push_t_lerobot_v21",
-  "generated": "2026-09-10T20:23:10Z",
-  "seed": 42,
-  "val_proportion": 0.1,
-  "recipe": "sorted(episode_ids) shuffled by np.random.default_rng(seed), split at int(total_episodes * (1 - val_proportion)); matches fastwam base_lerobot_dataset.py",
-  "total_episodes": 100,
-  "total_frames": 32131,
-  "train_episodes": 90,
-  "train_frames": 29610,
-  "val_episodes": 10,
-  "val_frames": 2521,
-  "train": [
-    0,
-    1,
-    2,
-    3,
-    4,
-    5,
-    6,
-    7,
-    9,
-    10,
-    11,
-    15,
-    16,
-    17,
-    18,
-    19,
-    20,
-    21,
-    22,
-    23,
-    24,
-    25,
-    26,
-    27,
-    28,
-    29,
-    30,
-    31,
-    32,
-    33,
-    34,
-    35,
-    37,
-    38,
-    39,
-    40,
-    41,
-    42,
-    43,
-    44,
-    45,
-    46,
-    48,
-    49,
-    50,
-    51,
-    52,
-    54,
-    55,
-    56,
-    57,
-    58,
-    59,
-    60,
-    61,
-    62,
-    63,
-    64,
-    67,
-    68,
-    69,
-    70,
-    71,
-    72,
-    73,
-    74,
-    75,
-    76,
-    78,
-    79,
-    80,
-    81,
-    82,
-    83,
-    84,
-    85,
-    86,
-    87,
-    88,
-    89,
-    90,
-    91,
-    92,
-    93,
-    94,
-    95,
-    96,
-    97,
-    98,
-    99
-  ],
-  "val": [
-    8,
-    12,
-    13,
-    14,
-    36,
-    47,
-    53,
-    65,
-    66,
-    77
-  ]
-}

joint/fasterwam/train90_joint_job4247/training_code/fastwam/LICENSE

@@ -1,24 +0,0 @@
-MIT License
-
-Copyright (c) 2026 The FastWAM Authors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-Except for third-party code and files that retain their original license
-headers, this repository is released under the MIT License.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

joint/fasterwam/train90_joint_job4247/training_code/fastwam/pyproject.toml

@@ -1,53 +0,0 @@
-[build-system]
-requires = ["setuptools>=68", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "fastwam"
-version = "0.1.0"
-description = "FastWAM: standalone Wan2.2-TI2V-5B training/inference package"
-requires-python = ">=3.10"
-dependencies = [
-  "accelerate==1.12.0",
-  "av==16.0.1",
-  "boto3==1.35.99",
-  "datasets==3.6.0",
-  "deepspeed==0.18.5",
-  "einops==0.8.1",
-  "gitpython==3.1.45",
-  "huggingface-hub==0.29.2",
-  "hydra-core==1.3.2",
-  "imageio==2.37.0",
-  "imageio-ffmpeg==0.6.0",
-  "jsonlines==4.0.0",
-  "modelscope==1.34.0",
-  "numpy==1.26.4",
-  "omegaconf==2.3.0",
-  "packaging==25.0",
-  "pandas==2.2.3",
-  "pillow==12.0.0",
-  "pyarrow==23.0.0",
-  "regex==2025.11.3",
-  "rich==14.2.0",
-  "safetensors==0.5.3",
-  "termcolor==2.5.0",
-  "torch==2.7.1+cu128",
-  "torchcodec==0.5",
-  "torchvision==0.22.1+cu128",
-  "tqdm==4.66.5",
-  "transformers==4.49.0",
-  "typing-extensions==4.15.0",
-  "wandb==0.23.1",
-]
-
-[tool.setuptools.package-dir]
-"" = "src"
-
-[tool.setuptools.packages.find]
-where = ["src"]
-include = ["fastwam*"]
-
-[tool.pytest.ini_options]
-markers = [
-    "slow: marks tests as slow (deselect with -m 'not slow')",
-]

joint/fasterwam/train90_joint_job4247/training_code/fastwam/scripts/train.py

@@ -1,24 +0,0 @@
-import sys
-from pathlib import Path
-
-import hydra
-from omegaconf import DictConfig
-
-PROJECT_ROOT = Path(__file__).resolve().parents[1]
-SRC_DIR = str(PROJECT_ROOT / "src")
-if SRC_DIR not in sys.path:
-    sys.path.insert(0, SRC_DIR)
-
-from fastwam.runtime import run_training
-from fastwam.utils.config_resolvers import register_default_resolvers
-
-register_default_resolvers()
-
-
-@hydra.main(config_path="../configs", config_name="train", version_base="1.3")
-def main(cfg: DictConfig):
-    run_training(cfg)
-
-
-if __name__ == "__main__":
-    main()

joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/__init__.py

@@ -1 +0,0 @@
-"""FastWAM package."""

joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/aligned_3dpft.py

@@ -1,91 +0,0 @@
-"""Opt-in LIBERO dataset context for ``aligned_3dpft``."""
-
-from __future__ import annotations
-
-import numpy as np
-import torch
-
-from fastwam.geometry.flow_context import build_flow_trajectory_context
-from fastwam.geometry.flow_trajectory import LIBERO_OSC_POSITION_SCALE
-
-from .lerobot.robot_video_dataset import DEFAULT_PROMPT, RobotVideoDataset
-
-
-class Aligned3DPFTRobotVideoDataset(RobotVideoDataset):
-    """Attach observed cameras and normalization affine to each training sample."""
-
-    def __init__(self, *args, **kwargs):
-        if not kwargs.get("eef_anchor_calibration_path"):
-            raise ValueError(
-                "Aligned3DPFTRobotVideoDataset requires eef_anchor_calibration_path"
-            )
-        # Optional geometry-channel augmentation: gaussian noise on the observed
-        # EEF pose BEFORE the flow context is built, as [position_std_m,
-        # orientation_std_rad]. Perturbs only the anchor geometry (trajectory
-        # origin + reconstructed wrist camera); the proprio the model consumes
-        # is untouched. Teaches partial trust in the anchor under sensor noise.
-        noise = kwargs.pop("aligned_3dpft_eef_noise_std", None)
-        if noise is not None:
-            noise = tuple(float(value) for value in noise)
-            if len(noise) != 2 or any(value < 0 for value in noise):
-                raise ValueError(
-                    "aligned_3dpft_eef_noise_std must be "
-                    f"[position_std_m>=0, orientation_std_rad>=0], got {noise}"
-                )
-            if noise == (0.0, 0.0):
-                noise = None
-        self.aligned_3dpft_eef_noise_std = noise
-        super().__init__(*args, **kwargs)
-
-    @staticmethod
-    def _merged_normalization(processor, field: str) -> tuple[torch.Tensor, torch.Tensor]:
-        meta_entries = processor.shape_meta[field]
-        scales = []
-        offsets = []
-        for meta in meta_entries:
-            normalizer = processor.normalizer.normalizers[field][meta["key"]]
-            scales.append(torch.as_tensor(normalizer.scale, dtype=torch.float32))
-            offsets.append(torch.as_tensor(normalizer.offset, dtype=torch.float32))
-        return torch.cat(scales, dim=-1), torch.cat(offsets, dim=-1)
-
-    def _get(self, idx):
-        data = super()._get(idx)
-        if self.precompute_video_only:
-            return data
-        if self.eef_anchor_index is None:
-            raise RuntimeError("aligned_3dpft EEF projector was not initialized")
-        processor = self.lerobot_dataset.processor
-        if processor is None:
-            raise RuntimeError("aligned_3dpft requires a configured processor")
-
-        state_scale, state_offset = self._merged_normalization(processor, "state")
-        normalized_state = torch.as_tensor(data["proprio"][0], dtype=torch.float32)
-        raw_state = (normalized_state[: state_scale.numel()] - state_offset) / state_scale
-        if raw_state.numel() < 6:
-            raise ValueError("aligned_3dpft requires at least six EEF state dimensions")
-
-        prefix = DEFAULT_PROMPT.split("{task}", 1)[0]
-        prompt = str(data["prompt"])
-        if not prompt.startswith(prefix):
-            raise ValueError(f"unexpected training prompt format: {prompt!r}")
-        task_language = prompt[len(prefix):]
-        eef_state = raw_state[:6].numpy().copy()
-        if self.aligned_3dpft_eef_noise_std is not None:
-            position_std, orientation_std = self.aligned_3dpft_eef_noise_std
-            eef_state[:3] += np.random.normal(0.0, position_std, size=3)
-            eef_state[3:6] += np.random.normal(0.0, orientation_std, size=3)
-        context = build_flow_trajectory_context(
-            self.eef_anchor_index.projector,
-            task_language,
-            eef_state,
-        )
-        action_scale, action_offset = self._merged_normalization(processor, "action")
-        context["action_scale"] = action_scale.numpy()
-        context["action_offset"] = action_offset.numpy()
-        # Denormalized LIBERO xyz actions are OSC commands, not meters.
-        context["action_translation_scale"] = np.float32(LIBERO_OSC_POSITION_SCALE)
-        data["aligned_3dpft_context"] = {
-            key: torch.as_tensor(np.asarray(value, dtype=np.float32).copy())
-            for key, value in context.items()
-        }
-        return data

joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/dataset_utils.py

@@ -1,109 +0,0 @@
-
-from typing import Optional
-
-import torch
-import torchvision.transforms.functional as transforms_F
-from PIL import Image
-
-
-def obtain_image_size(data: torch.Tensor | Image.Image) -> tuple[int, int]:
-    r"""Return spatial size from a PIL image or image/video tensor.
-
-    Args:
-        data (torch.Tensor | Image.Image): Input image or video tensor.
-    Returns:
-        width (int): Input width.
-        height (int): Input height.
-    """
-
-    if isinstance(data, Image.Image):
-        width, height = data.size
-    elif isinstance(data, torch.Tensor):
-        height, width = data.size()[-2:]
-    else:
-        raise ValueError("data to random crop should be PIL Image or tensor")
-
-    return width, height
-
-class ResizeSmallestSideAspectPreserving:
-    def __init__(self, args: Optional[dict] = None) -> None:
-        self.args = args
-
-    def __call__(self, video: torch.Tensor | Image.Image) -> torch.Tensor | Image.Image:
-        r"""Resize while preserving aspect ratio.
-
-        The output is scaled so both spatial dimensions are at least the
-        requested target size.
-
-        Args:
-            video (torch.Tensor | Image.Image): Input image or video tensor.
-        Returns:
-            torch.Tensor | Image.Image: Resized image or video tensor.
-        """
-
-        assert self.args is not None, "Please specify args in augmentations"
-
-        img_w, img_h = self.args["img_w"], self.args["img_h"]
-
-        orig_w, orig_h = obtain_image_size(video)
-        scaling_ratio = max((img_w / orig_w), (img_h / orig_h))
-        target_size = (int(scaling_ratio * orig_h + 0.5), int(scaling_ratio * orig_w + 0.5))
-
-        assert (
-            target_size[0] >= img_h and target_size[1] >= img_w
-        ), f"Resize error. orig {(orig_w, orig_h)} desire {(img_w, img_h)} compute {target_size}"
-
-        return transforms_F.resize(
-            video,
-            size=target_size,  # type: ignore
-            interpolation=self.args.get("interpolation", transforms_F.InterpolationMode.BICUBIC),
-            antialias=True,
-        )
-
-
-class CenterCrop:
-    def __init__(self, args: Optional[dict] = None) -> None:
-        self.args = args
-
-    def __call__(self, video: torch.Tensor | Image.Image) -> torch.Tensor | Image.Image:
-        r"""Center crop to the requested spatial size.
-
-        Args:
-            video (torch.Tensor | Image.Image): Input image or video tensor.
-        Returns:
-            torch.Tensor | Image.Image: Center cropped image or video tensor.
-        """
-        assert (
-            (self.args is not None) and ("img_w" in self.args) and ("img_h" in self.args)
-        ), "Please specify size in args"
-
-        img_w, img_h = self.args["img_w"], self.args["img_h"]
-        return transforms_F.center_crop(video, [img_h, img_w])
-
-
-class Normalize:
-    def __init__(self, args: Optional[dict] = None) -> None:
-        self.args = args
-
-    def __call__(self, video: torch.Tensor | Image.Image) -> torch.Tensor:
-        r"""Convert to tensor if needed and normalize by mean/std.
-
-        Args:
-            video (torch.Tensor | Image.Image): Input image or video tensor.
-        Returns:
-            torch.Tensor: Normalized image or video tensor.
-        """
-        assert self.args is not None, "Please specify args"
-
-        mean = self.args["mean"]
-        std = self.args["std"]
-
-        if isinstance(video, torch.Tensor):
-            data = video.to(dtype=torch.float32)
-            if video.dtype == torch.uint8:
-                data = data / 255.0
-            data = data.to(dtype=torch.get_default_dtype())
-        else:
-            data = transforms_F.to_tensor(video)  # division by 255 is applied in to_tensor()
-
-        return transforms_F.normalize(tensor=data, mean=mean, std=std)

joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/eef_anchors.py

@@ -1,310 +0,0 @@
-# Author: Rui Heng Yang
-"""Load-time per-episode EEF anchor resolution.
-
-There is no sidecar. Anchors are projected and hold-resolved once per episode at
-dataset initialisation and held in RAM (plan Section 15). Projection costs about
-35 microseconds per frame, so precomputing to disk bought nothing while adding
-stale-artifact and partial-write failure modes.
-
-Two traps this module exists to close:
-
-* **Episode identity is ``(dataset_index, episode_index)``, not
-  ``episode_index``.** A ``MultiLeRobotDataset`` concatenates several LeRobot
-  directories, each numbering its episodes from zero, so ``episode_index`` alone
-  collides across directories and would silently pair one suite's frames with
-  another suite's gripper positions.
-* **The anchor must key off the RETURNED sample, not the requested index.**
-  Both ``RobotVideoDataset._get()`` and ``__getitem__()`` resample to a random
-  global index on padding or on exception, so a lookup by requested ``idx``
-  attaches geometry from whichever episode was originally asked for -- with no
-  error and no log.
-"""
-
-from __future__ import annotations
-
-import glob
-import json
-import logging
-import os
-from dataclasses import dataclass, field
-from typing import Any, Mapping, Sequence
-
-import numpy as np
-
-from fastwam.geometry import (
-    CAMERA_ORDER,
-    CalibrationTable,
-    EEFProjector,
-    load_calibration,
-    resolve_anchor_series,
-)
-
-logger = logging.getLogger(__name__)
-
-EEF_POSE_DIMS = 6
-"""``observation.state[0:3]`` is metric position, ``[3:6]`` axis-angle."""
-
-
-@dataclass
-class AnchorResolutionStats:
-    """Substitution accounting, so no substitution is ever silent (Section 19.2)."""
-
-    episodes: int = 0
-    frames: int = 0
-    observed_frames: int = 0
-    held_offscreen_frames: int = 0
-    centre_default_frames: int = 0
-    max_consecutive_held: int = 0
-    per_camera_observed: dict[str, int] = field(default_factory=dict)
-
-    def as_dict(self) -> dict[str, Any]:
-        return {
-            "episodes": self.episodes,
-            "frames": self.frames,
-            "observed_frames": self.observed_frames,
-            "held_offscreen_frames": self.held_offscreen_frames,
-            "centre_default_frames": self.centre_default_frames,
-            "max_consecutive_held": self.max_consecutive_held,
-            "per_camera_observed": dict(self.per_camera_observed),
-        }
-
-
-class EpisodeAnchorIndex:
-    """Resolved per-episode anchors for every episode of every dataset dir.
-
-    Keyed by ``(dataset_index, episode_index)``; ``lookup()`` then indexes the
-    episode's series at the sample's own ``frame_index``.
-    """
-
-    def __init__(
-        self,
-        *,
-        calibration: CalibrationTable,
-        projector: EEFProjector,
-        anchors: Mapping[tuple[int, int], np.ndarray],
-        stats: AnchorResolutionStats,
-    ) -> None:
-        self.calibration = calibration
-        self.projector = projector
-        self._anchors = dict(anchors)
-        self.stats = stats
-
-    @property
-    def calibration_digest(self) -> str:
-        """Content digest of the calibration this index was resolved against."""
-        return self.calibration.digest
-
-    def __len__(self) -> int:
-        return len(self._anchors)
-
-    def lookup(
-        self, dataset_index: int, episode_index: int, frame_index: int
-    ) -> np.ndarray:
-        """Return the ``[2, 2]`` float32 anchor for one frame, as ``(y, x)``.
-
-        Args:
-            dataset_index: Which LeRobot directory the returned sample came from.
-            episode_index: Episode index **within that directory**.
-            frame_index: Episode-local frame index of the sample's ``t0``.
-
-        Raises:
-            KeyError: If the episode was not resolved at initialisation.
-            IndexError: If ``frame_index`` lies outside the episode.
-        """
-        key = (int(dataset_index), int(episode_index))
-        try:
-            series = self._anchors[key]
-        except KeyError as err:
-            raise KeyError(
-                f"no resolved anchors for (dataset_index={dataset_index}, "
-                f"episode_index={episode_index}); the anchor index and the "
-                "dataset disagree about which episodes exist"
-            ) from err
-        frame = int(frame_index)
-        if not 0 <= frame < series.shape[0]:
-            raise IndexError(
-                f"frame_index {frame} outside episode "
-                f"(dataset_index={dataset_index}, episode_index={episode_index}) "
-                f"of length {series.shape[0]}"
-            )
-        return series[frame]
-
-    # ------------------------------------------------------------------
-    # Construction
-    # ------------------------------------------------------------------
-
-    @classmethod
-    def build(
-        cls,
-        dataset_dirs: Sequence[str],
-        *,
-        calibration_path: str,
-        projector: EEFProjector | None = None,
-        episode_filter: Mapping[int, Sequence[int]] | None = None,
-    ) -> "EpisodeAnchorIndex":
-        """Project and hold-resolve every episode of every directory.
-
-        Args:
-            dataset_dirs: LeRobot directories, in the order the dataset stacks
-                them -- this ordering defines ``dataset_index``.
-            calibration_path: Versioned calibration artifact (Section 15.3).
-            projector: Defaults to the training projector (raw 512).
-            episode_filter: Optional ``{dataset_index: [episode_index, ...]}``
-                restricting work to the episodes actually selected by the split.
-
-        Raises:
-            InvalidProjectionError: If any frame projects to a nonfinite
-                coordinate or at/behind the camera plane (Section 19.1
-                Decision 1). This is a hard error by design: substituting a
-                stale anchor would convert a detectable geometry fault into
-                silently wrong training data.
-        """
-        calibration = load_calibration(calibration_path)
-        if projector is None:
-            projector = EEFProjector.for_training(calibration)
-        if tuple(projector.camera_order) != CAMERA_ORDER:
-            raise ValueError(
-                f"camera order is LOCKED to {CAMERA_ORDER}, got "
-                f"{tuple(projector.camera_order)}"
-            )
-
-        anchors: dict[tuple[int, int], np.ndarray] = {}
-        stats = AnchorResolutionStats(
-            per_camera_observed={name: 0 for name in CAMERA_ORDER}
-        )
-
-        for dataset_index, root in enumerate(dataset_dirs):
-            wanted = None
-            if episode_filter is not None:
-                wanted = {int(e) for e in episode_filter.get(dataset_index, ())}
-            cls._resolve_one_directory(
-                root=root,
-                dataset_index=dataset_index,
-                projector=projector,
-                anchors=anchors,
-                stats=stats,
-                wanted_episodes=wanted,
-            )
-
-        logger.info(
-            "EEF anchors resolved at load time: %d episodes, %d frames, "
-            "%d observed, %d held-offscreen, %d centre-default, "
-            "longest hold %d frames (calibration %s)",
-            stats.episodes,
-            stats.frames,
-            stats.observed_frames,
-            stats.held_offscreen_frames,
-            stats.centre_default_frames,
-            stats.max_consecutive_held,
-            calibration.digest[:12],
-        )
-        return cls(
-            calibration=calibration,
-            projector=projector,
-            anchors=anchors,
-            stats=stats,
-        )
-
-    @staticmethod
-    def _episode_task_languages(root: str) -> dict[int, str]:
-        """Map episode index to its task language string.
-
-        Calibration is joined by **language string**, never ``task_index``:
-        the dataset's task ordering differs from the benchmark's, so an
-        index join silently selects another task's camera pose (Section 6.1).
-        """
-        path = os.path.join(root, "meta", "episodes.jsonl")
-        languages: dict[int, str] = {}
-        with open(path, "r", encoding="utf-8") as handle:
-            for line in handle:
-                line = line.strip()
-                if not line:
-                    continue
-                record = json.loads(line)
-                tasks = record.get("tasks") or []
-                if not tasks:
-                    raise ValueError(
-                        f"episode {record.get('episode_index')} in {root} has no "
-                        "task language; calibration cannot be joined"
-                    )
-                languages[int(record["episode_index"])] = str(tasks[0])
-        if not languages:
-            raise ValueError(f"no episodes found in {path}")
-        return languages
-
-    @classmethod
-    def _resolve_one_directory(
-        cls,
-        *,
-        root: str,
-        dataset_index: int,
-        projector: EEFProjector,
-        anchors: dict[tuple[int, int], np.ndarray],
-        stats: AnchorResolutionStats,
-        wanted_episodes: set[int] | None,
-    ) -> None:
-        import pandas as pd  # local: keeps the module importable without pandas
-
-        languages = cls._episode_task_languages(root)
-        files = sorted(
-            glob.glob(os.path.join(root, "data", "**", "*.parquet"), recursive=True)
-        )
-        if not files:
-            raise FileNotFoundError(f"no parquet shards under {root}/data")
-
-        columns = ["episode_index", "frame_index", "observation.state"]
-        frames = pd.concat(
-            (pd.read_parquet(path, columns=columns) for path in files),
-            ignore_index=True,
-        )
-
-        for episode_index, group in frames.groupby("episode_index", sort=True):
-            episode_index = int(episode_index)
-            if wanted_episodes is not None and episode_index not in wanted_episodes:
-                continue
-            ordered = group.sort_values("frame_index")
-            state = np.stack(
-                [np.asarray(row, dtype=np.float64) for row in ordered["observation.state"]]
-            )
-            if state.ndim != 2 or state.shape[1] < EEF_POSE_DIMS:
-                raise ValueError(
-                    f"observation.state for episode {episode_index} in {root} has "
-                    f"shape {state.shape}; expected [N, >= {EEF_POSE_DIMS}]"
-                )
-
-            language = languages.get(episode_index)
-            if language is None:
-                raise KeyError(
-                    f"episode {episode_index} present in {root}/data but absent "
-                    "from meta/episodes.jsonl; cannot resolve its task language"
-                )
-
-            projection = projector.project(language, state)
-            resolved = np.empty(projection.anchor_token.shape, dtype=np.float32)
-            episode_max_hold = 0
-            for camera_index, camera_name in enumerate(CAMERA_ORDER):
-                series, camera_stats = resolve_anchor_series(
-                    projection.anchor_token_precise[:, camera_index, :],
-                    projection.onscreen[:, camera_index],
-                )
-                resolved[:, camera_index, :] = series.astype(np.float32)
-                stats.observed_frames += int(camera_stats.get("observed_frames", 0))
-                stats.held_offscreen_frames += int(
-                    camera_stats.get("held_offscreen_frames", 0)
-                )
-                stats.centre_default_frames += int(
-                    camera_stats.get("centre_default_frames", 0)
-                )
-                stats.per_camera_observed[camera_name] += int(
-                    camera_stats.get("observed_frames", 0)
-                )
-                episode_max_hold = max(
-                    episode_max_hold, int(camera_stats.get("max_consecutive_held", 0))
-                )
-
-            anchors[(dataset_index, episode_index)] = resolved
-            stats.episodes += 1
-            stats.frames += int(state.shape[0])
-            stats.max_consecutive_held = max(
-                stats.max_consecutive_held, episode_max_hold
-            )

joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/base_lerobot_dataset.py

@@ -1,517 +0,0 @@
-# Author: Rui Heng Yang
-
-import json
-import torch
-import numpy as np
-from pathlib import Path
-from typing import List, Literal, Dict, Optional, Any, DefaultDict, Sequence
-from tqdm import tqdm
-from .lerobot.lerobot_dataset import (
-    LeRobotDatasetMetadata,
-    MultiLeRobotDataset,
-    dataset_dir_to_repo_id,
-)
-
-from concurrent.futures import ThreadPoolExecutor, as_completed
-import traceback
-from fastwam.utils.logging_config import get_logger
-from .processors.base_processor import BaseProcessor
-
-logger = get_logger(__name__)
-
-MAX_GETITEM_ATTEMPT = 5
-
-class BaseLerobotDataset(torch.utils.data.Dataset):
-    def __init__(
-        self,
-        dataset_dirs: List[str],
-
-        # shapes
-        shape_meta: Dict[str, Any],
-        action_size: int = 1, 
-        past_action_size: int = 0, # Excludes the current frame
-        obs_size: int = 1, # should be 
-        past_obs_size: int = 0,
-
-        # train vs val
-        val_set_proportion: float = 0.05, 
-        is_training_set: bool = False,
-        seed: int = 42,
-        episode_indices: Optional[Sequence[int]] = None,
-        episode_indices_path: Optional[str] = None,
-        episode_indices_key: Optional[str] = None,
-
-        # sampling
-        global_sample_stride: int = 1,
-        video_backend: Optional[str] = None,
-        strict_getitem: bool = False,
-        image_only: bool = False,
-        image_sample_indices: Optional[Sequence[int]] = None,
-    ):
-        assert len(dataset_dirs) > 0, "At least one dataset directory is required"
-        assert past_action_size == 0
-        assert past_obs_size == 0
-        assert action_size == obs_size - 1, "In this dataset, action_size should be obs_size - 1"
-        
-        self.dataset_dirs = dataset_dirs
-        self.shape_meta = shape_meta
-        self.action_size = action_size
-        self.past_action_size = past_action_size
-        self.obs_size = obs_size
-        self.processor = None  # Will be set externally
-        self.return_images = True
-        self.strict_getitem = bool(strict_getitem)
-        self.image_only = bool(image_only)
-        self.image_sample_indices = (
-            None
-            if image_sample_indices is None
-            else [int(index) for index in image_sample_indices]
-        )
-        if self.image_only and not self.image_sample_indices:
-            raise ValueError("image_only mode requires nonempty image_sample_indices.")
-        metas = []
-        for ds_dir in dataset_dirs:
-            ds_root = Path(ds_dir)
-            repo_id = dataset_dir_to_repo_id(ds_dir)
-            meta = LeRobotDatasetMetadata(repo_id=repo_id, root=ds_root)
-            metas.append(meta)
-
-        fps_list = [m.fps for m in metas]
-        assert len(set(fps_list)) == 1, f"All dataset_dirs must have the same fps, got {fps_list}"
-        fps = fps_list[0]
-        
-        self.global_sample_stride = global_sample_stride
-
-        self.val_set_proportion = val_set_proportion
-        self.is_training_set = is_training_set
-        self.episode_indices = self._load_episode_indices(
-            episode_indices=episode_indices,
-            episode_indices_path=episode_indices_path,
-            episode_indices_key=episode_indices_key,
-        )
-
-        self.image_meta = shape_meta["images"]
-        self.state_meta = shape_meta["state"]
-        self.action_meta = shape_meta["action"]
-
-        delta_timestamps = {}
-        image_offsets = (
-            range(-past_obs_size, -past_obs_size + obs_size)
-            if self.image_sample_indices is None
-            else self.image_sample_indices
-        )
-        for meta in self.image_meta:
-            key = meta["key"]
-            meta["lerobot_key"] = f"observation.images.{key}" if key != "default" else "observation.images"
-            delta_timestamps[meta["lerobot_key"]] = [
-                (t * global_sample_stride) / fps for t in image_offsets
-            ]
-
-        for meta in self.state_meta:
-            key = meta["key"]
-            meta["lerobot_key"] = f"observation.state.{key}" if key != "default" else "observation.state"
-            if not self.image_only:
-                delta_timestamps[meta["lerobot_key"]] = [
-                    (t * global_sample_stride) / fps for t in range(-past_obs_size, -past_obs_size + obs_size)
-                ]
-
-        for meta in self.action_meta:
-            key = meta["key"]
-            meta["lerobot_key"] = f"action.{key}" if key != "default" else "action"
-            if not self.image_only:
-                delta_timestamps[meta["lerobot_key"]] = [(t * global_sample_stride) / fps for t in range(-past_action_size, -past_action_size + action_size)]
-
-        episodes = {}
-        if self.episode_indices is not None:
-            requested = sorted(set(int(i) for i in self.episode_indices))
-            for meta in metas:
-                available = set(meta.episodes.keys())
-                valid = [i for i in requested if i in available]
-                missing = len(requested) - len(valid)
-                if missing:
-                    logger.warning(
-                        "Ignoring %d episode indices not present in %s",
-                        missing,
-                        meta.repo_id,
-                    )
-                episodes.update({meta.repo_id: valid})
-        elif val_set_proportion < 1e-6:
-            for meta in metas:
-                episodes.update({meta.repo_id: sorted(meta.episodes.keys())})
-        else:
-            for meta in metas:
-                split_idx = int(meta.total_episodes * (1 - val_set_proportion))
-                # random shuffle episode indices before splitting
-                episode_indices = sorted(meta.episodes.keys())
-                rng = np.random.default_rng(seed)
-                rng.shuffle(episode_indices)
-                if self.is_training_set:
-                    episodes.update({meta.repo_id: [episode_indices[i] for i in range(split_idx)]})
-                else:
-                    episodes.update({meta.repo_id: [episode_indices[i] for i in range(split_idx, meta.total_episodes)]})
-
-        self.multi_dataset = MultiLeRobotDataset(
-            dataset_dirs=self.dataset_dirs,
-            episodes=episodes,
-            delta_timestamps=delta_timestamps,
-            video_backend=video_backend,
-        )
-        
-        # HACK: lerobot 3.0 will fix this
-        episode_data_index = []
-        end_index = 0
-        for dataset in self.multi_dataset._datasets:
-            multi_episode_data_index = {
-                "from": dataset.episode_data_index["from"] + end_index,
-                "to": dataset.episode_data_index["to"] + end_index,
-            }
-            episode_data_index.append(multi_episode_data_index)
-            end_index = multi_episode_data_index["to"][-1]
-
-        self.episode_data_index = {
-            "from": torch.cat([dataset["from"] for dataset in episode_data_index]),
-            "to": torch.cat([dataset["to"] for dataset in episode_data_index]),
-        }
-
-    @staticmethod
-    def _load_episode_indices(
-        *,
-        episode_indices: Optional[Sequence[int]],
-        episode_indices_path: Optional[str],
-        episode_indices_key: Optional[str],
-    ) -> Optional[list[int]]:
-        if episode_indices is not None and episode_indices_path is not None:
-            raise ValueError("Only one of `episode_indices` and `episode_indices_path` can be set.")
-        if episode_indices is not None:
-            return [int(i) for i in episode_indices]
-        if episode_indices_path is None:
-            return None
-
-        path = Path(episode_indices_path)
-        with path.open("r", encoding="utf-8") as f:
-            payload = json.load(f)
-        if episode_indices_key is not None:
-            if episode_indices_key not in payload:
-                raise KeyError(f"`{episode_indices_key}` not found in episode split file: {path}")
-            payload = payload[episode_indices_key]
-        if isinstance(payload, dict) and "episodes" in payload:
-            payload = payload["episodes"]
-        if not isinstance(payload, list):
-            raise ValueError(
-                f"Episode split in {path} must be a list, or a dict containing an `episodes` list."
-            )
-        return [int(i) for i in payload]
-
-    def _get_action(self, meta, lerobot_sample) -> torch.Tensor:
-        key, lerobot_key, raw_shape = meta["key"], meta["lerobot_key"], meta["raw_shape"]
-        action: torch.Tensor = lerobot_sample[lerobot_key] # [T, action_dim]
-        if action.ndim == 1: # for shape of 1, like gripper
-            action = action.unsqueeze(-1)
-        assert action.shape[-1] == raw_shape, f"Action '{key}' shape {action.shape[-1]} mismatch with meta {raw_shape}."
-        return action
-
-    def _get_state(self, meta, lerobot_sample) -> torch.Tensor:
-        key, lerobot_key, raw_shape = meta["key"], meta["lerobot_key"], meta["raw_shape"]
-        state: torch.Tensor = lerobot_sample[lerobot_key]
-        if state.ndim == 1: # for shape of 1, like gripper
-            state = state.unsqueeze(-1)
-        # state = state[..., :-1, :]  # use state_{t} as observation_t
-        assert state.shape[-1] == raw_shape, f"State '{key}' shape {state.shape[-1]} mismatch with meta {raw_shape}."
-        return state
-    
-    def _get_image(self, meta, lerobot_sample) -> torch.Tensor:
-        key, lerobot_key, raw_shape = meta["key"], meta["lerobot_key"], meta["raw_shape"]
-        image: torch.Tensor = lerobot_sample[lerobot_key]
-        if image.ndim == 3: # time dim will lost when obs_size is 1
-            image = image.unsqueeze(0)        
-        image = (image * 255).to(torch.uint8) # (1, 3, H, W)
-        # For config simplication
-        # assert image.shape[1:] == raw_shape, f"Image '{key}' shape {image.shape[1:]} mismatch with {raw_shape}."
-        return image
-    
-    def _split_lerobot_sample(self, lerobot_sample) -> Dict[str, Any]:
-        return lerobot_sample
-    
-    def _get_episode_data(self, episode_idx):
-        lerobot_sample = self.multi_dataset.get_episode_data(episode_idx)
-        lerobot_sample = self._split_lerobot_sample(lerobot_sample)
-        state, action = {}, {}
-        for meta in self.state_meta:
-            s = self._get_state(meta, lerobot_sample)
-            state[meta["key"]] = s.unsqueeze(1).float()
-        for meta in self.action_meta:
-            a = self._get_action(meta, lerobot_sample)
-            a = sliding_window_with_replication(a, self.action_size)
-            action[meta["key"]] = a.float()
-        return {"action": action, "state": state}
-
-    def _set_return_images(self, flag: bool):
-        self.return_images = flag
-        self.multi_dataset.set_during_training(flag)
-
-    def __len__(self):
-        return self.multi_dataset.num_frames
-
-    def _get_additional_data(self, sample, lerobot_sample):
-        return sample
-
-    def __getitem__(self, idx):
-        if idx >= len(self):
-            raise IndexError(f"Index {idx} out of bounds {len(self)}.")
-
-        # Cache construction and cache-backed training require index identity:
-        # a requested global index must never silently resolve to another
-        # sample. Other existing datasets retain the historical retry behavior.
-        sample_idx = idx
-        attempt = 0
-        last_exception: Optional[Exception] = None
-        strict_getitem = bool(getattr(self, "strict_getitem", False))
-        max_attempts = 1 if strict_getitem else MAX_GETITEM_ATTEMPT
-        while attempt < max_attempts:
-            try:
-                lerobot_sample = self.multi_dataset[sample_idx]
-                lerobot_sample = self._split_lerobot_sample(lerobot_sample)
-                break
-            except Exception as err:
-                attempt += 1
-                last_exception = err
-                if strict_getitem:
-                    raise RuntimeError(f"Strict sample load failed for index {idx}.") from err
-                logger.warning(
-                    f"Error loading sample {sample_idx} (attempt {attempt}). "
-                    "Retrying with a random index. "
-                    f"Error: {err}"
-                )
-                sample_idx = np.random.randint(len(self))
-                print(traceback.format_exc())
-        else:
-            raise RuntimeError(
-                f"Failed to load a valid sample after {MAX_GETITEM_ATTEMPT} attempts "
-                f"for index {idx}."
-            ) from last_exception
-
-        # Get data from lerobot, organized in nested dict
-        sample = {
-            "idx": sample_idx,
-            "task": lerobot_sample["task"],
-            "action": {},
-            "state": {},
-            "images": {},
-        }
-        image_only = bool(getattr(self, "image_only", False))
-        if not image_only:
-            for meta in self.state_meta:
-                sample["state"][meta["key"]] = self._get_state(meta, lerobot_sample)
-
-            for meta in self.action_meta:
-                sample["action"][meta["key"]] = self._get_action(meta, lerobot_sample)
-
-        if bool(getattr(self, "return_images", True)):
-            for meta in self.image_meta:
-                sample["images"][meta["key"]] = self._get_image(meta, lerobot_sample)
-
-        sample["image_is_pad"] = lerobot_sample[f"{self.image_meta[0]['lerobot_key']}_is_pad"]
-        if not image_only:
-            sample["action_is_pad"] = lerobot_sample[f"{self.action_meta[0]['lerobot_key']}_is_pad"]
-            sample["state_is_pad"] = lerobot_sample[f"{self.state_meta[0]['lerobot_key']}_is_pad"]
-
-        sample = self._get_additional_data(sample, lerobot_sample)
-
-        for key in lerobot_sample:
-            if key not in sample and "observation" not in key and "action" not in key:
-                sample[key] = lerobot_sample[key]
-
-        # Preprocess the sample using the processor
-        # for quick data loading
-        if self.processor is not None:
-            if image_only:
-                pixel_values = self.processor.preprocess_images(
-                    sample["images"],
-                    expected_num_obs_steps=len(self.image_sample_indices),
-                )
-                sample = {
-                    "idx": sample["idx"],
-                    "pixel_values": pixel_values,
-                    "image_is_pad": sample["image_is_pad"],
-                    **{
-                        key: sample[key]
-                        for key in ("dataset_index", "episode_index", "frame_index")
-                        if key in sample
-                    },
-                }
-            else:
-                sample = self.processor.preprocess(sample)
-
-        return sample
-
-    def set_processor(self, processor: BaseProcessor):
-        """Set processor instance from external initialization."""
-        self.processor = processor
-        if self.is_training_set:
-            self.processor.train()
-        else:
-            self.processor.eval()
-        return self
-
-    def get_dataset_stats(self, preprocessor: BaseProcessor):
-        state_min = DefaultDict(list)
-        state_max = DefaultDict(list)
-        state_mean = DefaultDict(list)
-        state_var = DefaultDict(list)
-        state_q01 = DefaultDict(list)
-        state_q99 = DefaultDict(list)
-
-        action_min = DefaultDict(list)
-        action_max = DefaultDict(list)
-        action_mean = DefaultDict(list)
-        action_var = DefaultDict(list)
-        action_q01 = DefaultDict(list)
-        action_q99 = DefaultDict(list)
-
-        episodes_num = self.multi_dataset.num_episodes
-        
-        def process_episode(episode_idx):
-            batch = self._get_episode_data(episode_idx) 
-            batch = preprocessor.action_state_transform(batch)
-            return batch
-        
-        multi_thread = True
-        if not multi_thread:
-            for episode_idx in tqdm(range(episodes_num), desc="Iterating dataset to get normalization"):
-                batch = process_episode(episode_idx)
-                for meta in self.state_meta:
-                    key = meta["key"]
-                    cur_state: torch.Tensor = batch["state"][key] # (B, T, dim)
-                    state_min[key].append(cur_state.amin(0))
-                    state_max[key].append(cur_state.amax(0))
-                    state_mean[key].append(cur_state.mean(0))
-                    state_var[key].append(cur_state.var(0))
-                    state_q01[key].append(torch.quantile(cur_state, 0.01, dim=0, keepdim=False))
-                    state_q99[key].append(torch.quantile(cur_state, 0.99, dim=0, keepdim=False))
-                for meta in self.action_meta:
-                    key = meta["key"]
-                    cur_action: torch.Tensor = batch["action"][key] # (B, T, dim)
-                    action_min[key].append(cur_action.amin(0))
-                    action_max[key].append(cur_action.amax(0))
-                    action_mean[key].append(cur_action.mean(0))
-                    action_var[key].append(cur_action.var(0))
-                    action_q01[key].append(torch.quantile(cur_action, 0.01, dim=0, keepdim=False))
-                    action_q99[key].append(torch.quantile(cur_action, 0.99, dim=0, keepdim=False))
-        
-        else:
-            with ThreadPoolExecutor() as executor:
-                futures = [executor.submit(process_episode, num) for num in range(episodes_num)]
-                
-                for future in tqdm(as_completed(futures), total=episodes_num, desc="Iterating dataset to get normalization"):
-                    try:
-                        batch = future.result()
-                        for meta in self.state_meta:
-                            key = meta["key"]
-                            cur_state: torch.Tensor = batch["state"][key] # (B, T, dim)
-                            state_min[key].append(cur_state.amin(0))
-                            state_max[key].append(cur_state.amax(0))
-                            state_mean[key].append(cur_state.mean(0))
-                            state_var[key].append(cur_state.var(0))
-                            state_q01[key].append(torch.quantile(cur_state, 0.01, dim=0, keepdim=False))
-                            state_q99[key].append(torch.quantile(cur_state, 0.99, dim=0, keepdim=False))
-
-                        for meta in self.action_meta:
-                            key = meta["key"]
-                            cur_action: torch.Tensor = batch["action"][key] # (B, T, dim)
-                            action_min[key].append(cur_action.amin(0))
-                            action_max[key].append(cur_action.amax(0))
-                            action_mean[key].append(cur_action.mean(0))
-                            action_var[key].append(cur_action.var(0))
-                            action_q01[key].append(torch.quantile(cur_action, 0.01, dim=0, keepdim=False))
-                            action_q99[key].append(torch.quantile(cur_action, 0.99, dim=0, keepdim=False))
-
-                    except Exception as e:
-                        logger.error(f"Error processing episode: {e}")
-                        print(traceback.format_exc())
-                        raise e
-
-        # assume that each minibatch has equal number of samples
-        def get_mean_std(means, vars):
-            means = torch.stack(means)
-            vars = torch.stack(vars)
-            stepwise_mean = means.mean(0)
-            stepwise_std = (vars + (means - stepwise_mean) ** 2).mean(0).sqrt()
-            global_mean = means.mean((0, 1))
-            global_std = (vars + (means - global_mean) ** 2).mean((0, 1)).sqrt()
-            return stepwise_mean, stepwise_std, global_mean, global_std
-
-        stats = {"state": DefaultDict(dict), "action": DefaultDict(dict), "num_episodes": episodes_num, "num_transition": self.multi_dataset.num_frames}
-        for meta in self.state_meta:
-            key = meta["key"]
-            stats["state"][key]["stepwise_min"] = torch.stack(state_min[key]).amin(0)
-            stats["state"][key]["stepwise_max"] = torch.stack(state_max[key]).amax(0)
-            stats["state"][key]["global_min"] = stats["state"][key]["stepwise_min"].amin(0)
-            stats["state"][key]["global_max"] = stats["state"][key]["stepwise_max"].amax(0)
-            stats["state"][key]["stepwise_q01"] = torch.stack(state_q01[key]).amin(0)
-            stats["state"][key]["stepwise_q99"] = torch.stack(state_q99[key]).amax(0)
-            stats["state"][key]["global_q01"] = stats["state"][key]["stepwise_q01"].amin(0)
-            stats["state"][key]["global_q99"] = stats["state"][key]["stepwise_q99"].amax(0)
-            (
-                stats["state"][key]["stepwise_mean"],
-                stats["state"][key]["stepwise_std"],
-                stats["state"][key]["global_mean"],
-                stats["state"][key]["global_std"],
-            ) = get_mean_std(state_mean[key], state_var[key])
-
-        for meta in self.action_meta:
-            key = meta["key"]
-            stats["action"][key]["stepwise_min"] = torch.stack(action_min[key]).amin(0)
-            stats["action"][key]["stepwise_max"] = torch.stack(action_max[key]).amax(0)
-            stats["action"][key]["global_min"] = stats["action"][key]["stepwise_min"].amin(0)
-            stats["action"][key]["global_max"] = stats["action"][key]["stepwise_max"].amax(0)
-            stats["action"][key]["stepwise_q01"] = torch.stack(action_q01[key]).amin(0)
-            stats["action"][key]["stepwise_q99"] = torch.stack(action_q99[key]).amax(0)
-            stats["action"][key]["global_q01"] = stats["action"][key]["stepwise_q01"].amin(0)
-            stats["action"][key]["global_q99"] = stats["action"][key]["stepwise_q99"].amax(0)
-            (
-                stats["action"][key]["stepwise_mean"], 
-                stats["action"][key]["stepwise_std"], 
-                stats["action"][key]["global_mean"], 
-                stats["action"][key]["global_std"],
-            ) = get_mean_std(action_mean[key], action_var[key])
-
-        return stats
-
-
-def sliding_window_with_replication(x: torch.Tensor, window_size: int) -> torch.Tensor:
-    """
-    Construct a sliding-window tensor from the input tensor x (shape: [N, D]).
-    The output shape is [N, window_size, D].
-    
-    For each starting index i:
-        out[i, j, :] =
-            x[i + j, :]      if i + j < N
-            x[-1, :]         otherwise (replicate the last row when out of bounds)
-    
-    Args:
-        x (torch.Tensor): Input tensor of shape [N, D]
-        window_size (int): Size of the sliding window
-    
-    Returns:
-        torch.Tensor: Tensor of shape [N, window_size, D]
-    """
-    assert x.dim() == 2
-    assert window_size > 0
-    
-    N, D = x.shape
-    
-    # shape [N, window_size]
-    # indices[i, j] = i + j
-    i_indices = torch.arange(N).unsqueeze(1)            # [N, 1]
-    j_indices = torch.arange(window_size).unsqueeze(0)  # [1, window_size]
-    indices = i_indices + j_indices                     # [N, window_size]
-
-    # N-1
-    # torch.clamp  [0, N-1]
-    clamped_indices = torch.clamp(indices, min=0, max=N - 1)
-
-    # clamped_indices [N, window_size]，x [N, D]
-    # out[i, j, :] = x[clamped_indices[i, j], :]
-    out = x[clamped_indices]  # [N, window_size, D]
-
-    return out

joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/constants.py

@@ -1,54 +0,0 @@
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# keys
-import os
-from pathlib import Path
-
-from huggingface_hub.constants import HF_HOME
-
-OBS_ENV_STATE = "observation.environment_state"
-OBS_STATE = "observation.state"
-OBS_IMAGE = "observation.image"
-OBS_IMAGES = "observation.images"
-ACTION = "action"
-REWARD = "next.reward"
-
-ROBOTS = "robots"
-ROBOT_TYPE = "robot_type"
-TELEOPERATORS = "teleoperators"
-
-# files & directories
-CHECKPOINTS_DIR = "checkpoints"
-LAST_CHECKPOINT_LINK = "last"
-PRETRAINED_MODEL_DIR = "pretrained_model"
-TRAINING_STATE_DIR = "training_state"
-RNG_STATE = "rng_state.safetensors"
-TRAINING_STEP = "training_step.json"
-OPTIMIZER_STATE = "optimizer_state.safetensors"
-OPTIMIZER_PARAM_GROUPS = "optimizer_param_groups.json"
-SCHEDULER_STATE = "scheduler_state.json"
-
-if "LEROBOT_HOME" in os.environ:
-    raise ValueError(
-        f"You have a 'LEROBOT_HOME' environment variable set to '{os.getenv('LEROBOT_HOME')}'.\n"
-        "'LEROBOT_HOME' is deprecated, please use 'HF_LEROBOT_HOME' instead."
-    )
-
-# cache dir
-default_cache_path = Path(HF_HOME) / "lerobot"
-HF_LEROBOT_HOME = Path(os.getenv("HF_LEROBOT_HOME", default_cache_path)).expanduser()
-
-# calibration dir
-default_calibration_path = HF_LEROBOT_HOME / "calibration"
-HF_LEROBOT_CALIBRATION = Path(os.getenv("HF_LEROBOT_CALIBRATION", default_calibration_path)).expanduser()

joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/lerobot/datasets/compute_stats.py

@@ -1,179 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import numpy as np
-
-from .utils import load_image_as_numpy
-
-
-def estimate_num_samples(
-    dataset_len: int, min_num_samples: int = 100, max_num_samples: int = 10_000, power: float = 0.75
-) -> int:
-    """Heuristic to estimate the number of samples based on dataset size.
-    The power controls the sample growth relative to dataset size.
-    Lower the power for less number of samples.
-
-    For default arguments, we have:
-    - from 1 to ~500, num_samples=100
-    - at 1000, num_samples=177
-    - at 2000, num_samples=299
-    - at 5000, num_samples=594
-    - at 10000, num_samples=1000
-    - at 20000, num_samples=1681
-    """
-    if dataset_len < min_num_samples:
-        min_num_samples = dataset_len
-    return max(min_num_samples, min(int(dataset_len**power), max_num_samples))
-
-
-def sample_indices(data_len: int) -> list[int]:
-    num_samples = estimate_num_samples(data_len)
-    return np.round(np.linspace(0, data_len - 1, num_samples)).astype(int).tolist()
-
-
-def auto_downsample_height_width(img: np.ndarray, target_size: int = 150, max_size_threshold: int = 300):
-    _, height, width = img.shape
-
-    if max(width, height) < max_size_threshold:
-        # no downsampling needed
-        return img
-
-    downsample_factor = int(width / target_size) if width > height else int(height / target_size)
-    return img[:, ::downsample_factor, ::downsample_factor]
-
-
-def sample_images(image_paths: list[str]) -> np.ndarray:
-    sampled_indices = sample_indices(len(image_paths))
-
-    images = None
-    for i, idx in enumerate(sampled_indices):
-        path = image_paths[idx]
-        # we load as uint8 to reduce memory usage
-        img = load_image_as_numpy(path, dtype=np.uint8, channel_first=True)
-        img = auto_downsample_height_width(img)
-
-        if images is None:
-            images = np.empty((len(sampled_indices), *img.shape), dtype=np.uint8)
-
-        images[i] = img
-
-    return images
-
-
-def get_feature_stats(array: np.ndarray, axis: tuple, keepdims: bool) -> dict[str, np.ndarray]:
-    return {
-        "min": np.min(array, axis=axis, keepdims=keepdims),
-        "max": np.max(array, axis=axis, keepdims=keepdims),
-        "mean": np.mean(array, axis=axis, keepdims=keepdims),
-        "std": np.std(array, axis=axis, keepdims=keepdims),
-        "count": np.array([len(array)]),
-    }
-
-
-def compute_episode_stats(episode_data: dict[str, list[str] | np.ndarray], features: dict, is_compute_episode_stats_image : bool) -> dict:
-    ep_stats = {}
-    for key, data in episode_data.items():
-        if features[key]["dtype"] == "string":
-            continue  # HACK: we should receive np.arrays of strings
-        elif features[key]["dtype"] in ["image", "video"]:
-            if is_compute_episode_stats_image:
-                ep_ft_array = sample_images(data)  # data is a list of image paths
-                axes_to_reduce = (0, 2, 3)  # keep channel dim
-                keepdims = True
-            else:
-                continue
-        else:
-            ep_ft_array = data  # data is already a np.ndarray
-            axes_to_reduce = 0  # compute stats over the first axis
-            keepdims = data.ndim == 1  # keep as np.array
-
-        ep_stats[key] = get_feature_stats(ep_ft_array, axis=axes_to_reduce, keepdims=keepdims)
-
-        # finally, we normalize and remove batch dim for images
-        if features[key]["dtype"] in ["image", "video"]:
-            ep_stats[key] = {
-                k: v if k == "count" else np.squeeze(v / 255.0, axis=0) for k, v in ep_stats[key].items()
-            }
-
-    return ep_stats
-
-
-def _assert_type_and_shape(stats_list: list[dict[str, dict]]):
-    for i in range(len(stats_list)):
-        for fkey in stats_list[i]:
-            for k, v in stats_list[i][fkey].items():
-                if not isinstance(v, np.ndarray):
-                    raise ValueError(
-                        f"Stats must be composed of numpy array, but key '{k}' of feature '{fkey}' is of type '{type(v)}' instead."
-                    )
-                if v.ndim == 0:
-                    raise ValueError("Number of dimensions must be at least 1, and is 0 instead.")
-                if k == "count" and v.shape != (1,):
-                    raise ValueError(f"Shape of 'count' must be (1), but is {v.shape} instead.")
-                if "image" in fkey and k != "count" and v.shape != (3, 1, 1):
-                    raise ValueError(f"Shape of '{k}' must be (3,1,1), but is {v.shape} instead.")
-
-
-def aggregate_feature_stats(stats_ft_list: list[dict[str, dict]]) -> dict[str, dict[str, np.ndarray]]:
-    """Aggregates stats for a single feature."""
-    means = np.stack([s["mean"] for s in stats_ft_list])
-    variances = np.stack([s["std"] ** 2 for s in stats_ft_list])
-    counts = np.stack([s["count"] for s in stats_ft_list])
-    total_count = counts.sum(axis=0)
-
-    # Prepare weighted mean by matching number of dimensions
-    while counts.ndim < means.ndim:
-        counts = np.expand_dims(counts, axis=-1)
-
-    # Compute the weighted mean
-    weighted_means = means * counts
-    total_mean = weighted_means.sum(axis=0) / total_count
-
-    # Compute the variance using the parallel algorithm
-    delta_means = means - total_mean
-    weighted_variances = (variances + delta_means**2) * counts
-    total_variance = weighted_variances.sum(axis=0) / total_count
-
-    return {
-        "min": np.min(np.stack([s["min"] for s in stats_ft_list]), axis=0),
-        "max": np.max(np.stack([s["max"] for s in stats_ft_list]), axis=0),
-        "mean": total_mean,
-        "std": np.sqrt(total_variance),
-        "count": total_count,
-    }
-
-
-def aggregate_stats(stats_list: list[dict[str, dict]]) -> dict[str, dict[str, np.ndarray]]:
-    """Aggregate stats from multiple compute_stats outputs into a single set of stats.
-
-    The final stats will have the union of all data keys from each of the stats dicts.
-
-    For instance:
-    - new_min = min(min_dataset_0, min_dataset_1, ...)
-    - new_max = max(max_dataset_0, max_dataset_1, ...)
-    - new_mean = (mean of all data, weighted by counts)
-    - new_std = (std of all data)
-    """
-
-    _assert_type_and_shape(stats_list)
-
-    data_keys = {key for stats in stats_list for key in stats}
-    aggregated_stats = {key: {} for key in data_keys}
-
-    for key in data_keys:
-        stats_with_key = [stats[key] for stats in stats_list if key in stats]
-        aggregated_stats[key] = aggregate_feature_stats(stats_with_key)
-
-    return aggregated_stats

joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/lerobot/datasets/utils.py

@@ -1,965 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import contextlib
-import importlib.resources
-import io
-import json
-import logging
-from collections.abc import Iterator
-from itertools import accumulate
-from pathlib import Path
-from pprint import pformat
-from types import SimpleNamespace
-from typing import Any
-import array
-
-import datasets
-import jsonlines
-import numpy as np
-import packaging.version
-import torch
-from datasets.table import embed_table_storage
-from huggingface_hub import DatasetCard, DatasetCardData, HfApi
-from huggingface_hub.errors import RevisionNotFoundError
-from PIL import Image as PILImage
-from torchvision import transforms
-
-from functools import partial
-
-# from lerobot.configs.types import DictLike, FeatureType, PolicyFeature
-# from lerobot.datasets.backward_compatibility import (
-#     V21_MESSAGE,
-#     BackwardCompatibilityError,
-#     ForwardCompatibilityError,
-# )
-# from lerobot.robots import Robot
-# from lerobot.utils.utils import is_valid_numpy_dtype_string
-
-DEFAULT_CHUNK_SIZE = 1000  # Max number of episodes per chunk
-
-INFO_PATH = "meta/info.json"
-EPISODES_PATH = "meta/episodes.jsonl"
-STATS_PATH = "meta/stats.json"
-EPISODES_STATS_PATH = "meta/episodes_stats.jsonl"
-TASKS_PATH = "meta/tasks.jsonl"
-
-ANNOTATION_PATHS = {
-    "subtask": "annotations/subtask_annotations.jsonl",
-    "scene": "annotations/scene_annotations.jsonl",
-    "gripper_mode": "annotations/gripper_mode_annotation.jsonl",
-    "gripper_activity": "annotations/gripper_activity_annotation.jsonl",
-    "eef_velocity": "annotations/eef_velocity_annotation.jsonl",
-    "eef_acc_mag": "annotations/eef_acc_mag_annotation.jsonl",
-    "eef_direction": "annotations/eef_direction_annotation.jsonl",
-}
-
-DEFAULT_VIDEO_PATH = "videos/chunk-{episode_chunk:03d}/{video_key}/episode_{episode_index:06d}.mp4"
-DEFAULT_PARQUET_PATH = "data/chunk-{episode_chunk:03d}/episode_{episode_index:06d}.parquet"
-DEFAULT_IMAGE_PATH = "images/{image_key}/episode_{episode_index:06d}/frame_{frame_index:06d}.jpeg"
-
-# v3.0 paths — multi-episode files, paths derived from per-episode metadata
-DEFAULT_DATA_PATH_V30 = "data/chunk-{chunk_index:03d}/file-{file_index:03d}.parquet"
-DEFAULT_VIDEO_PATH_V30 = "videos/{video_key}/chunk-{chunk_index:03d}/file-{file_index:03d}.mp4"
-EPISODES_DIR_V30 = "meta/episodes"
-TASKS_PATH_V30 = "meta/tasks.parquet"  # flat single-file in v3.0
-_TASKS_V30_CACHE = {}
-
-DATASET_CARD_TEMPLATE = """
----
-# Metadata will go there
----
-This dataset was created using [LeRobot](https://github.com/huggingface/lerobot).
-
-## {}
-
-"""
-
-DEFAULT_FEATURES = {
-    "timestamp": {"dtype": "float32", "shape": (1,), "names": None},
-    "frame_index": {"dtype": "int64", "shape": (1,), "names": None},
-    "episode_index": {"dtype": "int64", "shape": (1,), "names": None},
-    "index": {"dtype": "int64", "shape": (1,), "names": None},
-    "coarse_task_index": {"dtype": "int64", "shape": (1,), "names": None}, 
-    "task_index": {"dtype": "int64", "shape": (1,), "names": None},
-    "coarse_quality_index": {"dtype": "int64", "shape": (1,), "names": None}, 
-    "quality_index": {"dtype": "int64", "shape": (1,), "names": None},
-}
-
-
-def flatten_dict(d: dict, parent_key: str = "", sep: str = "/") -> dict:
-    """Flatten a nested dictionary structure by collapsing nested keys into one key with a separator.
-
-    For example:
-    ```
-    >>> dct = {"a": {"b": 1, "c": {"d": 2}}, "e": 3}`
-    >>> print(flatten_dict(dct))
-    {"a/b": 1, "a/c/d": 2, "e": 3}
-    """
-    items = []
-    for k, v in d.items():
-        new_key = f"{parent_key}{sep}{k}" if parent_key else k
-        if isinstance(v, dict):
-            items.extend(flatten_dict(v, new_key, sep=sep).items())
-        else:
-            items.append((new_key, v))
-    return dict(items)
-
-
-def unflatten_dict(d: dict, sep: str = "/") -> dict:
-    outdict = {}
-    for key, value in d.items():
-        parts = key.split(sep)
-        d = outdict
-        for part in parts[:-1]:
-            if part not in d:
-                d[part] = {}
-            d = d[part]
-        d[parts[-1]] = value
-    return outdict
-
-
-# def get_nested_item(obj: DictLike, flattened_key: str, sep: str = "/") -> Any:
-#     split_keys = flattened_key.split(sep)
-#     getter = obj[split_keys[0]]
-#     if len(split_keys) == 1:
-#         return getter
-
-#     for key in split_keys[1:]:
-#         getter = getter[key]
-
-#     return getter
-
-
-def serialize_dict(stats: dict[str, torch.Tensor | np.ndarray | dict]) -> dict:
-    serialized_dict = {}
-    for key, value in flatten_dict(stats).items():
-        if isinstance(value, (torch.Tensor, np.ndarray)):
-            serialized_dict[key] = value.tolist()
-        elif isinstance(value, np.generic):
-            serialized_dict[key] = value.item()
-        elif isinstance(value, (int, float)):
-            serialized_dict[key] = value
-        else:
-            raise NotImplementedError(f"The value '{value}' of type '{type(value)}' is not supported.")
-    return unflatten_dict(serialized_dict)
-
-
-def embed_images(dataset: datasets.Dataset) -> datasets.Dataset:
-    # Embed image bytes into the table before saving to parquet
-    format = dataset.format
-    dataset = dataset.with_format("arrow")
-    dataset = dataset.map(embed_table_storage, batched=False)
-    dataset = dataset.with_format(**format)
-    return dataset
-
-
-def load_json(fpath: Path) -> Any:
-    with open(fpath) as f:
-        return json.load(f)
-
-
-def write_json(data: dict, fpath: Path) -> None:
-    fpath.parent.mkdir(exist_ok=True, parents=True)
-    with open(fpath, "w") as f:
-        json.dump(data, f, indent=4, ensure_ascii=False)
-
-
-def load_jsonlines(fpath: Path) -> list[Any]:
-    # allow \t and \n
-    loose_loader = partial(json.loads, strict=False)
-    with jsonlines.open(fpath, "r", loads=loose_loader) as reader:
-        return list(reader)
-
-
-def write_jsonlines(data: dict, fpath: Path) -> None:
-    fpath.parent.mkdir(exist_ok=True, parents=True)
-    with jsonlines.open(fpath, "w") as writer:
-        writer.write_all(data)
-
-
-def append_jsonlines(data: dict, fpath: Path) -> None:
-    fpath.parent.mkdir(exist_ok=True, parents=True)
-    with jsonlines.open(fpath, "a") as writer:
-        writer.write(data)
-
-
-def write_info(info: dict, local_dir: Path):
-    write_json(info, local_dir / INFO_PATH)
-
-
-def load_info(local_dir: Path) -> dict:
-    info = load_json(local_dir / INFO_PATH)
-    for ft in info["features"].values():
-        ft["shape"] = tuple(ft["shape"])
-    return info
-
-
-def write_stats(stats: dict, local_dir: Path):
-    serialized_stats = serialize_dict(stats)
-    write_json(serialized_stats, local_dir / STATS_PATH)
-
-
-def cast_stats_to_numpy(stats) -> dict[str, dict[str, np.ndarray]]:
-    stats = {key: np.array(value) for key, value in flatten_dict(stats).items()}
-    return unflatten_dict(stats)
-
-
-def load_stats(local_dir: Path) -> dict[str, dict[str, np.ndarray]]:
-    if not (local_dir / STATS_PATH).exists():
-        return None
-    stats = load_json(local_dir / STATS_PATH)
-    return cast_stats_to_numpy(stats)
-
-
-def write_task(task_index: int, task: dict, local_dir: Path):
-    task_dict = {
-        "task_index": task_index,
-        "task": task,
-    }
-    append_jsonlines(task_dict, local_dir / TASKS_PATH)
-
-
-def load_tasks(local_dir: Path) -> tuple[dict, dict]:
-    tasks = load_jsonlines(local_dir / TASKS_PATH)
-    tasks = {item["task_index"]: item["task"] for item in sorted(tasks, key=lambda x: x["task_index"])}
-    task_to_task_index = {task: task_index for task_index, task in tasks.items()}
-    return tasks, task_to_task_index
-
-
-def load_tasks_v30(local_dir: Path) -> tuple[dict, dict]:
-    """Load tasks from v3.0 parquet format (meta/tasks.parquet).
-
-    The parquet has index=task_string, column="task_index" (integer).
-    Returns (tasks, task_to_task_index) matching the v2.1 interface.
-    """
-    import pandas as pd
-    path = local_dir / TASKS_PATH_V30
-    if not path.exists():
-        raise FileNotFoundError(f"Tasks parquet not found: {path}")
-    stat = path.stat()
-    cache_key = (path.name, stat.st_size, stat.st_mtime_ns)
-    if cache_key in _TASKS_V30_CACHE:
-        return _TASKS_V30_CACHE[cache_key]
-    df = pd.read_parquet(path)
-    # index = task string, column "task_index" = integer task index
-    tasks = {int(row["task_index"]): task_str for task_str, row in df.iterrows()}
-    task_to_task_index = {task_str: int(row["task_index"]) for task_str, row in df.iterrows()}
-    result = (tasks, task_to_task_index)
-    _TASKS_V30_CACHE[cache_key] = result
-    return result
-
-
-def load_episodes_v30(local_dir: Path) -> dict:
-    """Load episodes from v3.0 parquet format (meta/episodes/chunk-000/file-000.parquet).
-
-    Returns a dict mapping episode_index → row dict, compatible with get_episode_data_index.
-    Each row contains at minimum: episode_index, tasks, length, dataset_from_index,
-    dataset_to_index, data/chunk_index, data/file_index, videos/{key}/chunk_index,
-    videos/{key}/file_index, videos/{key}/from_timestamp, videos/{key}/to_timestamp.
-    """
-    import pandas as pd
-    paths = sorted((local_dir / EPISODES_DIR_V30).glob("*/*.parquet"))
-    if not paths:
-        raise FileNotFoundError(f"No episodes parquet found in {local_dir / EPISODES_DIR_V30}")
-    # Drop stats/* and tasks columns — arrays not needed for data loading
-    import numpy as np
-    dfs = []
-    for p in paths:
-        df_part = pd.read_parquet(p)
-        drop_cols = [c for c in df_part.columns if c.startswith("stats/") or c == "tasks"]
-        dfs.append(df_part.drop(columns=drop_cols))
-    df = pd.concat(dfs).reset_index(drop=True)
-    episodes = {}
-    for _, row in df.iterrows():
-        ep_idx = int(row["episode_index"])
-        episodes[ep_idx] = {
-            k: (int(v) if isinstance(v, (int, np.integer)) else
-                float(v) if isinstance(v, (float, np.floating)) else v)
-            for k, v in row.items()
-        }
-        episodes[ep_idx]["length"] = int(row["length"])
-    return episodes
-
-def load_annotations(local_dir: Path) -> dict[str, dict[int, str]]:
-    annotations = {}
-    for key, path in ANNOTATION_PATHS.items():
-        anno = load_jsonlines(local_dir / path)
-        anno = {item[f"{key}_index"]: item[key] for item in sorted(anno, key=lambda x: x[f"{key}_index"])}
-        annotations[key] = anno
-    return annotations
-
-def write_episode(episode: dict, local_dir: Path):
-    append_jsonlines(episode, local_dir / EPISODES_PATH)
-
-
-def load_episodes(local_dir: Path) -> dict:
-    episodes = load_jsonlines(local_dir / EPISODES_PATH)
-    return {item["episode_index"]: item for item in sorted(episodes, key=lambda x: x["episode_index"])}
-
-
-def write_episode_stats(episode_index: int, episode_stats: dict, local_dir: Path):
-    # We wrap episode_stats in a dictionary since `episode_stats["episode_index"]`
-    # is a dictionary of stats and not an integer.
-    episode_stats = {"episode_index": episode_index, "stats": serialize_dict(episode_stats)}
-    append_jsonlines(episode_stats, local_dir / EPISODES_STATS_PATH)
-
-
-def load_episodes_stats(local_dir: Path) -> dict:
-    episodes_stats = load_jsonlines(local_dir / EPISODES_STATS_PATH)
-    return {
-        item["episode_index"]: cast_stats_to_numpy(item["stats"])
-        for item in sorted(episodes_stats, key=lambda x: x["episode_index"])
-    }
-
-
-def backward_compatible_episodes_stats(
-    stats: dict[str, dict[str, np.ndarray]], episodes: list[int]
-) -> dict[str, dict[str, np.ndarray]]:
-    return dict.fromkeys(episodes, stats)
-
-
-def load_image_as_numpy(
-    fpath: str | Path, dtype: np.dtype = np.float32, channel_first: bool = True
-) -> np.ndarray:
-    img = PILImage.open(fpath).convert("RGB")
-    img_array = np.array(img, dtype=dtype)
-    if channel_first:  # (H, W, C) -> (C, H, W)
-        img_array = np.transpose(img_array, (2, 0, 1))
-    if np.issubdtype(dtype, np.floating):
-        img_array /= 255.0
-    return img_array
-
-
-def hf_transform_to_torch(items_dict: dict[torch.Tensor | None]):
-    """Get a transform function that convert items from Hugging Face dataset (pyarrow)
-    to torch tensors. Importantly, images are converted from PIL, which corresponds to
-    a channel last representation (h w c) of uint8 type, to a torch image representation
-    with channel first (c h w) of float32 type in range [0,1].
-    """
-    for key in items_dict:
-        first_item = items_dict[key][0]
-        if type(first_item) == dict and 'bytes' in first_item and first_item['bytes'] is not None:
-            to_pil = lambda img: PILImage.open(io.BytesIO(img['bytes']))
-            items_dict[key] = [to_pil(img) for img in items_dict[key]]
-            first_item = items_dict[key][0]
-        if isinstance(first_item, PILImage.Image):
-            to_tensor = transforms.ToTensor()
-            items_dict[key] = [to_tensor(img) for img in items_dict[key]]
-        elif first_item is None:
-            pass
-        else:
-            items_dict[key] = [x if isinstance(x, str) else torch.tensor(x) for x in items_dict[key]]
-    return items_dict
-
-
-def is_valid_version(version: str) -> bool:
-    try:
-        packaging.version.parse(version)
-        return True
-    except packaging.version.InvalidVersion:
-        return False
-
-
-# def check_version_compatibility(
-#     repo_id: str,
-#     version_to_check: str | packaging.version.Version,
-#     current_version: str | packaging.version.Version,
-#     enforce_breaking_major: bool = True,
-# ) -> None:
-#     v_check = (
-#         packaging.version.parse(version_to_check)
-#         if not isinstance(version_to_check, packaging.version.Version)
-#         else version_to_check
-#     )
-#     v_current = (
-#         packaging.version.parse(current_version)
-#         if not isinstance(current_version, packaging.version.Version)
-#         else current_version
-#     )
-#     if v_check.major < v_current.major and enforce_breaking_major:
-#         raise BackwardCompatibilityError(repo_id, v_check)
-#     elif v_check.minor < v_current.minor:
-#         logging.warning(V21_MESSAGE.format(repo_id=repo_id, version=v_check))
-
-
-def get_repo_versions(repo_id: str) -> list[packaging.version.Version]:
-    """Returns available valid versions (branches and tags) on given repo."""
-    api = HfApi()
-    repo_refs = api.list_repo_refs(repo_id, repo_type="dataset")
-    repo_refs = [b.name for b in repo_refs.branches + repo_refs.tags]
-    repo_versions = []
-    for ref in repo_refs:
-        with contextlib.suppress(packaging.version.InvalidVersion):
-            repo_versions.append(packaging.version.parse(ref))
-
-    return repo_versions
-
-
-# def get_safe_version(repo_id: str, version: str | packaging.version.Version) -> str:
-#     """
-#     Returns the version if available on repo or the latest compatible one.
-#     Otherwise, will throw a `CompatibilityError`.
-#     """
-#     target_version = (
-#         packaging.version.parse(version) if not isinstance(version, packaging.version.Version) else version
-#     )
-#     hub_versions = get_repo_versions(repo_id)
-
-#     if not hub_versions:
-#         raise RevisionNotFoundError(
-#             f"""Your dataset must be tagged with a codebase version.
-#             Assuming _version_ is the codebase_version value in the info.json, you can run this:
-#             ```python
-#             from huggingface_hub import HfApi
-
-#             hub_api = HfApi()
-#             hub_api.create_tag("{repo_id}", tag="_version_", repo_type="dataset")
-#             ```
-#             """
-#         )
-
-#     if target_version in hub_versions:
-#         return f"v{target_version}"
-
-#     compatibles = [
-#         v for v in hub_versions if v.major == target_version.major and v.minor <= target_version.minor
-#     ]
-#     if compatibles:
-#         return_version = max(compatibles)
-#         if return_version < target_version:
-#             logging.warning(f"Revision {version} for {repo_id} not found, using version v{return_version}")
-#         return f"v{return_version}"
-
-#     lower_major = [v for v in hub_versions if v.major < target_version.major]
-#     if lower_major:
-#         raise BackwardCompatibilityError(repo_id, max(lower_major))
-
-#     upper_versions = [v for v in hub_versions if v > target_version]
-#     assert len(upper_versions) > 0
-#     raise ForwardCompatibilityError(repo_id, min(upper_versions))
-
-
-def get_hf_features_from_features(features: dict) -> datasets.Features:
-    hf_features = {}
-    for key, ft in features.items():
-        if ft["dtype"] == "video":
-            continue
-        elif ft["dtype"] == "image":
-            hf_features[key] = datasets.Image()
-        elif ft["shape"] == (1,):
-            hf_features[key] = datasets.Value(dtype=ft["dtype"])
-        elif len(ft["shape"]) == 1:
-            hf_features[key] = datasets.Sequence(
-                length=ft["shape"][0], feature=datasets.Value(dtype=ft["dtype"])
-            )
-        elif len(ft["shape"]) == 2:
-            hf_features[key] = datasets.Array2D(shape=ft["shape"], dtype=ft["dtype"])
-        elif len(ft["shape"]) == 3:
-            hf_features[key] = datasets.Array3D(shape=ft["shape"], dtype=ft["dtype"])
-        elif len(ft["shape"]) == 4:
-            hf_features[key] = datasets.Array4D(shape=ft["shape"], dtype=ft["dtype"])
-        elif len(ft["shape"]) == 5:
-            hf_features[key] = datasets.Array5D(shape=ft["shape"], dtype=ft["dtype"])
-        else:
-            raise ValueError(f"Corresponding feature is not valid: {ft}")
-
-    return datasets.Features(hf_features)
-
-
-def _validate_feature_names(features: dict[str, dict]) -> None:
-    invalid_features = {name: ft for name, ft in features.items() if "/" in name}
-    if invalid_features:
-        raise ValueError(f"Feature names should not contain '/'. Found '/' in '{invalid_features}'.")
-
-
-def hw_to_dataset_features(
-    hw_features: dict[str, type | tuple], prefix: str, use_video: bool = True
-) -> dict[str, dict]:
-    features = {}
-    joint_fts = {key: ftype for key, ftype in hw_features.items() if ftype is float}
-    cam_fts = {key: shape for key, shape in hw_features.items() if isinstance(shape, tuple)}
-
-    if joint_fts and prefix == "action":
-        features[prefix] = {
-            "dtype": "float32",
-            "shape": (len(joint_fts),),
-            "names": list(joint_fts),
-        }
-
-    if joint_fts and prefix == "observation":
-        features[f"{prefix}.state"] = {
-            "dtype": "float32",
-            "shape": (len(joint_fts),),
-            "names": list(joint_fts),
-        }
-
-    for key, shape in cam_fts.items():
-        features[f"{prefix}.images.{key}"] = {
-            "dtype": "video" if use_video else "image",
-            "shape": shape,
-            "names": ["height", "width", "channels"],
-        }
-
-    _validate_feature_names(features)
-    return features
-
-
-def build_dataset_frame(
-    ds_features: dict[str, dict], values: dict[str, Any], prefix: str
-) -> dict[str, np.ndarray]:
-    frame = {}
-    for key, ft in ds_features.items():
-        if key in DEFAULT_FEATURES or not key.startswith(prefix):
-            continue
-        elif ft["dtype"] == "float32" and len(ft["shape"]) == 1:
-            frame[key] = np.array([values[name] for name in ft["names"]], dtype=np.float32)
-        elif ft["dtype"] in ["image", "video"]:
-            frame[key] = values[key.removeprefix(f"{prefix}.images.")]
-
-    return frame
-
-
-# def get_features_from_robot(robot: Robot, use_videos: bool = True) -> dict:
-#     camera_ft = {}
-#     if robot.cameras:
-#         camera_ft = {
-#             key: {"dtype": "video" if use_videos else "image", **ft}
-#             for key, ft in robot.camera_features.items()
-#         }
-#     return {**robot.motor_features, **camera_ft, **DEFAULT_FEATURES}
-
-
-# def dataset_to_policy_features(features: dict[str, dict]) -> dict[str, PolicyFeature]:
-#     # TODO(aliberts): Implement "type" in dataset features and simplify this
-#     policy_features = {}
-#     for key, ft in features.items():
-#         shape = ft["shape"]
-#         if ft["dtype"] in ["image", "video"]:
-#             type = FeatureType.VISUAL
-#             if len(shape) != 3:
-#                 raise ValueError(f"Number of dimensions of {key} != 3 (shape={shape})")
-
-#             names = ft["names"]
-#             # Backward compatibility for "channel" which is an error introduced in LeRobotDataset v2.0 for ported datasets.
-#             if names[2] in ["channel", "channels"]:  # (h, w, c) -> (c, h, w)
-#                 shape = (shape[2], shape[0], shape[1])
-#         elif key == "observation.environment_state":
-#             type = FeatureType.ENV
-#         elif key.startswith("observation"):
-#             type = FeatureType.STATE
-#         elif key.startswith("action"):
-#             type = FeatureType.ACTION
-#         else:
-#             continue
-
-#         policy_features[key] = PolicyFeature(
-#             type=type,
-#             shape=shape,
-#         )
-
-#     return policy_features
-
-
-def create_empty_dataset_info(
-    codebase_version: str,
-    fps: int,
-    features: dict,
-    use_videos: bool,
-    robot_type: str | None = None,
-) -> dict:
-    return {
-        "codebase_version": codebase_version,
-        "robot_type": robot_type,
-        "total_episodes": 0,
-        "total_frames": 0,
-        "total_tasks": 0,
-        "total_videos": 0,
-        "total_chunks": 0,
-        "chunks_size": DEFAULT_CHUNK_SIZE,
-        "fps": fps,
-        "splits": {},
-        "data_path": DEFAULT_PARQUET_PATH,
-        "video_path": DEFAULT_VIDEO_PATH if use_videos else None,
-        "features": features,
-    }
-
-
-def get_episode_data_index(
-    episode_dicts: dict[dict], episodes: list[int] | None = None
-) -> dict[str, torch.Tensor]:
-    episode_lengths = {ep_idx: ep_dict["length"] for ep_idx, ep_dict in episode_dicts.items()}
-    if episodes is not None:
-        episode_lengths = {ep_idx: episode_lengths[ep_idx] for ep_idx in episodes}
-
-    cumulative_lengths = list(accumulate(episode_lengths.values()))
-    return {
-        "from": torch.LongTensor([0] + cumulative_lengths[:-1]),
-        "to": torch.LongTensor(cumulative_lengths),
-    }
-
-
-def check_timestamps_sync(
-    timestamps: np.ndarray,
-    episode_indices: np.ndarray,
-    episode_data_index: dict[str, np.ndarray],
-    fps: int,
-    tolerance_s: float,
-    raise_value_error: bool = True,
-) -> bool:
-    """
-    This check is to make sure that each timestamp is separated from the next by (1/fps) +/- tolerance
-    to account for possible numerical error.
-
-    Args:
-        timestamps (np.ndarray): Array of timestamps in seconds.
-        episode_indices (np.ndarray): Array indicating the episode index for each timestamp.
-        episode_data_index (dict[str, np.ndarray]): A dictionary that includes 'to',
-            which identifies indices for the end of each episode.
-        fps (int): Frames per second. Used to check the expected difference between consecutive timestamps.
-        tolerance_s (float): Allowed deviation from the expected (1/fps) difference.
-        raise_value_error (bool): Whether to raise a ValueError if the check fails.
-
-    Returns:
-        bool: True if all checked timestamp differences lie within tolerance, False otherwise.
-
-    Raises:
-        ValueError: If the check fails and `raise_value_error` is True.
-    """
-    if timestamps.shape != episode_indices.shape:
-        raise ValueError(
-            "timestamps and episode_indices should have the same shape. "
-            f"Found {timestamps.shape=} and {episode_indices.shape=}."
-        )
-
-    # Consecutive differences
-    diffs = np.diff(timestamps)
-    within_tolerance = np.abs(diffs - (1.0 / fps)) <= tolerance_s
-
-    # Mask to ignore differences at the boundaries between episodes
-    mask = np.ones(len(diffs), dtype=bool)
-    ignored_diffs = episode_data_index["to"][:-1] - 1  # indices at the end of each episode
-    mask[ignored_diffs] = False
-    filtered_within_tolerance = within_tolerance[mask]
-
-    # Check if all remaining diffs are within tolerance
-    if not np.all(filtered_within_tolerance):
-        # Track original indices before masking
-        original_indices = np.arange(len(diffs))
-        filtered_indices = original_indices[mask]
-        outside_tolerance_filtered_indices = np.nonzero(~filtered_within_tolerance)[0]
-        outside_tolerance_indices = filtered_indices[outside_tolerance_filtered_indices]
-
-        outside_tolerances = []
-        for idx in outside_tolerance_indices:
-            entry = {
-                "timestamps": [timestamps[idx], timestamps[idx + 1]],
-                "diff": diffs[idx],
-                "episode_index": episode_indices[idx].item()
-                if hasattr(episode_indices[idx], "item")
-                else episode_indices[idx],
-            }
-            outside_tolerances.append(entry)
-
-        if raise_value_error:
-            raise ValueError(
-                f"""One or several timestamps unexpectedly violate the tolerance inside episode range.
-                This might be due to synchronization issues during data collection.
-                \n{pformat(outside_tolerances)}"""
-            )
-        return False
-
-    return True
-
-
-def check_delta_timestamps(
-    delta_timestamps: dict[str, list[float]], fps: int, tolerance_s: float, raise_value_error: bool = True
-) -> bool:
-    """This will check if all the values in delta_timestamps are multiples of 1/fps +/- tolerance.
-    This is to ensure that these delta_timestamps added to any timestamp from a dataset will themselves be
-    actual timestamps from the dataset.
-    """
-    outside_tolerance = {}
-    for key, delta_ts in delta_timestamps.items():
-        within_tolerance = [abs(ts * fps - round(ts * fps)) / fps <= tolerance_s for ts in delta_ts]
-        if not all(within_tolerance):
-            outside_tolerance[key] = [
-                ts for ts, is_within in zip(delta_ts, within_tolerance, strict=True) if not is_within
-            ]
-
-    if len(outside_tolerance) > 0:
-        if raise_value_error:
-            raise ValueError(
-                f"""
-                The following delta_timestamps are found outside of tolerance range.
-                Please make sure they are multiples of 1/{fps} +/- tolerance and adjust
-                their values accordingly.
-                \n{pformat(outside_tolerance)}
-                """
-            )
-        return False
-
-    return True
-
-
-def get_delta_indices(delta_timestamps: dict[str, list[float]], fps: int) -> dict[str, list[int]]:
-    delta_indices = {}
-    for key, delta_ts in delta_timestamps.items():
-        delta_indices[key] = [round(d * fps) for d in delta_ts]
-
-    return delta_indices
-
-
-def cycle(iterable):
-    """The equivalent of itertools.cycle, but safe for Pytorch dataloaders.
-
-    See https://github.com/pytorch/pytorch/issues/23900 for information on why itertools.cycle is not safe.
-    """
-    iterator = iter(iterable)
-    while True:
-        try:
-            yield next(iterator)
-        except StopIteration:
-            iterator = iter(iterable)
-
-
-def create_branch(repo_id, *, branch: str, repo_type: str | None = None) -> None:
-    """Create a branch on a existing Hugging Face repo. Delete the branch if it already
-    exists before creating it.
-    """
-    api = HfApi()
-
-    branches = api.list_repo_refs(repo_id, repo_type=repo_type).branches
-    refs = [branch.ref for branch in branches]
-    ref = f"refs/heads/{branch}"
-    if ref in refs:
-        api.delete_branch(repo_id, repo_type=repo_type, branch=branch)
-
-    api.create_branch(repo_id, repo_type=repo_type, branch=branch)
-
-
-def create_lerobot_dataset_card(
-    tags: list | None = None,
-    dataset_info: dict | None = None,
-    **kwargs,
-) -> DatasetCard:
-    """
-    Keyword arguments will be used to replace values in src/lerobot/datasets/card_template.md.
-    Note: If specified, license must be one of https://huggingface.co/docs/hub/repositories-licenses.
-    """
-    card_tags = ["LeRobot"]
-
-    if tags:
-        card_tags += tags
-    if dataset_info:
-        dataset_structure = "[meta/info.json](meta/info.json):\n"
-        dataset_structure += f"```json\n{json.dumps(dataset_info, indent=4)}\n```\n"
-        kwargs = {**kwargs, "dataset_structure": dataset_structure}
-    card_data = DatasetCardData(
-        license=kwargs.get("license"),
-        tags=card_tags,
-        task_categories=["robotics"],
-        configs=[
-            {
-                "config_name": "default",
-                "data_files": "data/*/*.parquet",
-            }
-        ],
-    )
-
-    card_template = (importlib.resources.files("lerobot.datasets") / "card_template.md").read_text()
-
-    return DatasetCard.from_template(
-        card_data=card_data,
-        template_str=card_template,
-        **kwargs,
-    )
-
-
-class IterableNamespace(SimpleNamespace):
-    """
-    A namespace object that supports both dictionary-like iteration and dot notation access.
-    Automatically converts nested dictionaries into IterableNamespaces.
-
-    This class extends SimpleNamespace to provide:
-    - Dictionary-style iteration over keys
-    - Access to items via both dot notation (obj.key) and brackets (obj["key"])
-    - Dictionary-like methods: items(), keys(), values()
-    - Recursive conversion of nested dictionaries
-
-    Args:
-        dictionary: Optional dictionary to initialize the namespace
-        **kwargs: Additional keyword arguments passed to SimpleNamespace
-
-    Examples:
-        >>> data = {"name": "Alice", "details": {"age": 25}}
-        >>> ns = IterableNamespace(data)
-        >>> ns.name
-        'Alice'
-        >>> ns.details.age
-        25
-        >>> list(ns.keys())
-        ['name', 'details']
-        >>> for key, value in ns.items():
-        ...     print(f"{key}: {value}")
-        name: Alice
-        details: IterableNamespace(age=25)
-    """
-
-    def __init__(self, dictionary: dict[str, Any] = None, **kwargs):
-        super().__init__(**kwargs)
-        if dictionary is not None:
-            for key, value in dictionary.items():
-                if isinstance(value, dict):
-                    setattr(self, key, IterableNamespace(value))
-                else:
-                    setattr(self, key, value)
-
-    def __iter__(self) -> Iterator[str]:
-        return iter(vars(self))
-
-    def __getitem__(self, key: str) -> Any:
-        return vars(self)[key]
-
-    def items(self):
-        return vars(self).items()
-
-    def values(self):
-        return vars(self).values()
-
-    def keys(self):
-        return vars(self).keys()
-
-
-def validate_frame(frame: dict, features: dict):
-    expected_features = set(features) - set(DEFAULT_FEATURES)
-    actual_features = set(frame)
-
-    error_message = validate_features_presence(actual_features, expected_features)
-
-    common_features = actual_features & expected_features
-    for name in common_features - {"task"}:
-        error_message += validate_feature_dtype_and_shape(name, features[name], frame[name])
-
-    if error_message:
-        raise ValueError(error_message)
-
-
-def validate_features_presence(actual_features: set[str], expected_features: set[str]):
-    error_message = ""
-    missing_features = expected_features - actual_features
-    extra_features = actual_features - expected_features
-
-    if missing_features or extra_features:
-        error_message += "Feature mismatch in `frame` dictionary:\n"
-        if missing_features:
-            error_message += f"Missing features: {missing_features}\n"
-        if extra_features:
-            error_message += f"Extra features: {extra_features}\n"
-
-    return error_message
-
-def is_valid_numpy_dtype_string(dtype_str: str) -> bool:
-    """
-    Return True if a given string can be converted to a numpy dtype.
-    """
-    try:
-        # Attempt to convert the string to a numpy dtype
-        np.dtype(dtype_str)
-        return True
-    except TypeError:
-        # If a TypeError is raised, the string is not a valid dtype
-        return False
-def validate_feature_dtype_and_shape(name: str, feature: dict, value: np.ndarray | PILImage.Image | str | bytes):
-    if isinstance(value, bytes) or isinstance(value, array.array): # ROS 1 and 2
-        #TODO fix bytes
-        return ""
-    expected_dtype = feature["dtype"]
-    expected_shape = feature["shape"]
-    if is_valid_numpy_dtype_string(expected_dtype):
-        return validate_feature_numpy_array(name, expected_dtype, expected_shape, value)
-    elif expected_dtype in ["image", "video"]:
-        return validate_feature_image_or_video(name, expected_shape, value)
-    elif expected_dtype == "string":
-        return validate_feature_string(name, value)
-    else:
-        raise NotImplementedError(f"The feature dtype '{expected_dtype}' is not implemented yet.")
-
-
-def validate_feature_numpy_array(
-    name: str, expected_dtype: str, expected_shape: list[int], value: np.ndarray
-):
-    error_message = ""
-    if isinstance(value, np.ndarray):
-        actual_dtype = value.dtype
-        actual_shape = value.shape
-
-        if actual_dtype != np.dtype(expected_dtype):
-            error_message += f"The feature '{name}' of dtype '{actual_dtype}' is not of the expected dtype '{expected_dtype}'.\n"
-
-        if actual_shape != expected_shape:
-            error_message += f"The feature '{name}' of shape '{actual_shape}' does not have the expected shape '{expected_shape}'.\n"
-    else:
-        error_message += f"The feature '{name}' is not a 'np.ndarray'. Expected type is '{expected_dtype}', but type '{type(value)}' provided instead.\n"
-
-    return error_message
-
-
-def validate_feature_image_or_video(name: str, expected_shape: list[str], value: np.ndarray | PILImage.Image):
-    # Note: The check of pixels range ([0,1] for float and [0,255] for uint8) is done by the image writer threads.
-    error_message = ""
-    if isinstance(value, np.ndarray):
-        actual_shape = value.shape
-        c, h, w = expected_shape
-        if len(actual_shape) != 3 or (actual_shape != (c, h, w) and actual_shape != (h, w, c)):
-            error_message += f"The feature '{name}' of shape '{actual_shape}' does not have the expected shape '{(c, h, w)}' or '{(h, w, c)}'.\n"
-    elif isinstance(value, PILImage.Image):
-        pass
-    else:
-        error_message += f"The feature '{name}' is expected to be of type 'PIL.Image' or 'np.ndarray' channel first or channel last, but type '{type(value)}' provided instead.\n"
-
-    return error_message
-
-
-def validate_feature_string(name: str, value: str):
-    if not isinstance(value, str):
-        return f"The feature '{name}' is expected to be of type 'str', but type '{type(value)}' provided instead.\n"
-    return ""
-
-
-def validate_episode_buffer(episode_buffer: dict, total_episodes: int, features: dict):
-    if "size" not in episode_buffer:
-        raise ValueError("size key not found in episode_buffer")
-
-    if "task" not in episode_buffer:
-        raise ValueError("task key not found in episode_buffer")
-
-    if episode_buffer["episode_index"] != total_episodes:
-        # TODO(aliberts): Add option to use existing episode_index
-        raise NotImplementedError(
-            "You might have manually provided the episode_buffer with an episode_index that doesn't "
-            "match the total number of episodes already in the dataset. This is not supported for now."
-        )
-
-    if episode_buffer["size"] == 0:
-        raise ValueError("You must add one or several frames with `add_frame` before calling `add_episode`.")
-
-    buffer_keys = set(episode_buffer.keys()) - {"task", "size"}
-    if not buffer_keys == set(features):
-        raise ValueError(
-            f"Features from `episode_buffer` don't match the ones in `features`."
-            f"In episode_buffer not in features: {buffer_keys - set(features)}"
-            f"In features not in episode_buffer: {set(features) - buffer_keys}"
-        )

joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/lerobot/datasets/video_utils.py

@@ -1,527 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import glob
-import importlib
-import logging
-import warnings
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, ClassVar
-
-import av
-import pyarrow as pa
-import torch
-import torchvision
-from datasets.features.features import register_feature
-from PIL import Image
-
-
-def get_safe_default_codec():
-    if importlib.util.find_spec("torchcodec"):
-        return "torchcodec"
-    else:
-        logging.warning(
-            "'torchcodec' is not available in your platform, falling back to 'pyav' as a default decoder"
-        )
-        return "pyav"
-
-
-def decode_video_frames(
-    video_path: Path | str,
-    timestamps: list[float],
-    tolerance_s: float,
-    backend: str | None = None,
-) -> torch.Tensor:
-    """
-    Decodes video frames using the specified backend.
-
-    Args:
-        video_path (Path): Path to the video file.
-        timestamps (list[float]): List of timestamps to extract frames.
-        tolerance_s (float): Allowed deviation in seconds for frame retrieval.
-        backend (str, optional): Backend to use for decoding. Defaults to "torchcodec" when available in the platform; otherwise, defaults to "pyav"..
-
-    Returns:
-        torch.Tensor: Decoded frames.
-
-    Currently supports torchcodec on cpu and pyav.
-    """
-    if backend is None:
-        backend = get_safe_default_codec()
-    if backend == "torchcodec":
-        try:
-            return decode_video_frames_torchcodec(video_path, timestamps, tolerance_s)
-        except Exception as err:
-            warnings.warn(
-                f"torchcodec video decode failed ({type(err).__name__}: {err}); falling back to torchvision/pyav."
-            )
-            return decode_video_frames_torchvision(video_path, timestamps, tolerance_s, backend="pyav")
-    elif backend in ["pyav", "video_reader"]:
-        return decode_video_frames_torchvision(video_path, timestamps, tolerance_s, backend)
-    else:
-        raise ValueError(f"Unsupported video backend: {backend}")
-
-
-def decode_video_frames_torchvision(
-    video_path: Path | str,
-    timestamps: list[float],
-    tolerance_s: float,
-    backend: str = "pyav",
-    log_loaded_timestamps: bool = False,
-) -> torch.Tensor:
-    """Loads frames associated to the requested timestamps of a video
-
-    The backend can be either "pyav" (default) or "video_reader".
-    "video_reader" requires installing torchvision from source, see:
-    https://github.com/pytorch/vision/blob/main/torchvision/csrc/io/decoder/gpu/README.rst
-    (note that you need to compile against ffmpeg<4.3)
-
-    While both use cpu, "video_reader" is supposedly faster than "pyav" but requires additional setup.
-    For more info on video decoding, see `benchmark/video/README.md`
-
-    See torchvision doc for more info on these two backends:
-    https://pytorch.org/vision/0.18/index.html?highlight=backend#torchvision.set_video_backend
-
-    Note: Video benefits from inter-frame compression. Instead of storing every frame individually,
-    the encoder stores a reference frame (or a key frame) and subsequent frames as differences relative to
-    that key frame. As a consequence, to access a requested frame, we need to load the preceding key frame,
-    and all subsequent frames until reaching the requested frame. The number of key frames in a video
-    can be adjusted during encoding to take into account decoding time and video size in bytes.
-    """
-    video_path = str(video_path)
-
-    # set backend
-    keyframes_only = False
-    torchvision.set_video_backend(backend)
-    if backend == "pyav":
-        keyframes_only = True  # pyav doesn't support accurate seek
-
-    # set a video stream reader
-    # TODO(rcadene): also load audio stream at the same time
-    reader = torchvision.io.VideoReader(video_path, "video")
-
-    # set the first and last requested timestamps
-    # Note: previous timestamps are usually loaded, since we need to access the previous key frame
-    first_ts = min(timestamps)
-    last_ts = max(timestamps)
-
-    # access closest key frame of the first requested frame
-    # Note: closest key frame timestamp is usually smaller than `first_ts` (e.g. key frame can be the first frame of the video)
-    # for details on what `seek` is doing see: https://pyav.basswood-io.com/docs/stable/api/container.html?highlight=inputcontainer#av.container.InputContainer.seek
-    reader.seek(first_ts, keyframes_only=keyframes_only)
-
-    # load all frames until last requested frame
-    loaded_frames = []
-    loaded_ts = []
-    for frame in reader:
-        current_ts = frame["pts"]
-        if log_loaded_timestamps:
-            logging.info(f"frame loaded at timestamp={current_ts:.4f}")
-        loaded_frames.append(frame["data"])
-        loaded_ts.append(current_ts)
-        if current_ts >= last_ts:
-            break
-
-    if backend == "pyav":
-        reader.container.close()
-
-    reader = None
-
-    # Use float32 for timestamp distance computation (torch.cdist doesn't support bfloat16).
-    query_ts = torch.tensor(timestamps, dtype=torch.float32)
-    loaded_ts = torch.tensor(loaded_ts, dtype=torch.float32)
-
-    # compute distances between each query timestamp and timestamps of all loaded frames
-    dist = torch.cdist(query_ts[:, None], loaded_ts[:, None], p=1)
-    min_, argmin_ = dist.min(1)
-
-    is_within_tol = min_ < tolerance_s
-    assert is_within_tol.all(), (
-        f"One or several query timestamps unexpectedly violate the tolerance ({min_[~is_within_tol]} > {tolerance_s=})."
-        "It means that the closest frame that can be loaded from the video is too far away in time."
-        "This might be due to synchronization issues with timestamps during data collection."
-        "To be safe, we advise to ignore this item during training."
-        f"\nqueried timestamps: {query_ts}"
-        f"\nloaded timestamps: {loaded_ts}"
-        f"\nvideo: {video_path}"
-        f"\nbackend: {backend}"
-    )
-
-    # get closest frames to the query timestamps
-    closest_frames = torch.stack([loaded_frames[idx] for idx in argmin_])
-    closest_ts = loaded_ts[argmin_]
-
-    if log_loaded_timestamps:
-        logging.info(f"{closest_ts=}")
-
-    # convert to the pytorch format which is float32 in [0,1] range (and channel first)
-    closest_frames = closest_frames.type(torch.float32) / 255
-
-    assert len(timestamps) == len(closest_frames)
-    return closest_frames
-
-
-def decode_video_frames_torchcodec(
-    video_path: Path | str,
-    timestamps: list[float],
-    tolerance_s: float,
-    device: str = "cpu",
-    log_loaded_timestamps: bool = False,
-) -> torch.Tensor:
-    """Loads frames associated with the requested timestamps of a video using torchcodec.
-
-    Note: Setting device="cuda" outside the main process, e.g. in data loader workers, will lead to CUDA initialization errors.
-
-    Note: Video benefits from inter-frame compression. Instead of storing every frame individually,
-    the encoder stores a reference frame (or a key frame) and subsequent frames as differences relative to
-    that key frame. As a consequence, to access a requested frame, we need to load the preceding key frame,
-    and all subsequent frames until reaching the requested frame. The number of key frames in a video
-    can be adjusted during encoding to take into account decoding time and video size in bytes.
-    """
-
-    if importlib.util.find_spec("torchcodec"):
-        from torchcodec.decoders import VideoDecoder
-    else:
-        raise ImportError("torchcodec is required but not available.")
-
-    # initialize video decoder
-    decoder = VideoDecoder(video_path, device=device, seek_mode="approximate")
-    loaded_frames = []
-    loaded_ts = []
-    # get metadata for frame information
-    metadata = decoder.metadata
-    average_fps = metadata.average_fps
-
-    # convert timestamps to frame indices
-    frame_indices = [round(ts * average_fps) for ts in timestamps]
-
-    # retrieve frames based on indices
-    frames_batch = decoder.get_frames_at(indices=frame_indices)
-
-    for frame, pts in zip(frames_batch.data, frames_batch.pts_seconds, strict=False):
-        loaded_frames.append(frame)
-        loaded_ts.append(pts.item())
-        if log_loaded_timestamps:
-            logging.info(f"Frame loaded at timestamp={pts:.4f}")
-
-    # Use float32 for timestamp distance computation (torch.cdist doesn't support bfloat16).
-    query_ts = torch.tensor(timestamps, dtype=torch.float32)
-    loaded_ts = torch.tensor(loaded_ts, dtype=torch.float32)
-
-    # compute distances between each query timestamp and loaded timestamps
-    dist = torch.cdist(query_ts[:, None], loaded_ts[:, None], p=1)
-    min_, argmin_ = dist.min(1)
-
-    is_within_tol = min_ < tolerance_s
-    assert is_within_tol.all(), (
-        f"One or several query timestamps unexpectedly violate the tolerance ({min_[~is_within_tol]} > {tolerance_s=})."
-        "It means that the closest frame that can be loaded from the video is too far away in time."
-        "This might be due to synchronization issues with timestamps during data collection."
-        "To be safe, we advise to ignore this item during training."
-        f"\nqueried timestamps: {query_ts}"
-        f"\nloaded timestamps: {loaded_ts}"
-        f"\nvideo: {video_path}"
-    )
-
-    # get closest frames to the query timestamps
-    closest_frames = torch.stack([loaded_frames[idx] for idx in argmin_])
-    closest_ts = loaded_ts[argmin_]
-
-    if log_loaded_timestamps:
-        logging.info(f"{closest_ts=}")
-
-    # convert to float32 in [0,1] range (channel first)
-    closest_frames = closest_frames.type(torch.float32) / 255
-
-    assert len(timestamps) == len(closest_frames)
-    return closest_frames
-
-def encode_video_frames(
-    imgs_dir: Path | str,
-    video_path: Path | str,
-    fps: int,
-    vcodec: str = "libsvtav1",
-    pix_fmt: str = "yuv420p",
-    g: int | None = 2,
-    crf: int | None = 30,
-    fast_decode: int = 0,
-    log_level: int | None = av.logging.ERROR,
-    overwrite: bool = False,
-) -> None:
-    """More info on ffmpeg arguments tuning on `benchmark/video/README.md`"""
-    # Check encoder availability
-    if vcodec == "h264_nvenc" :
-        return encode_video_frames_ffmpeg(
-            imgs_dir, video_path, fps, pix_fmt = pix_fmt, overwrite=overwrite
-        )
-
-    if vcodec not in ["h264", "hevc", "libsvtav1"]:
-        raise ValueError(f"Unsupported video codec: {vcodec}. Supported codecs are: h264, hevc, libsvtav1.")
-
-    video_path = Path(video_path)
-    imgs_dir = Path(imgs_dir)
-
-    video_path.parent.mkdir(parents=True, exist_ok=overwrite)
-
-    # Encoders/pixel formats incompatibility check
-    if (vcodec == "libsvtav1" or vcodec == "hevc") and pix_fmt == "yuv444p":
-        logging.warning(
-            f"Incompatible pixel format 'yuv444p' for codec {vcodec}, auto-selecting format 'yuv420p'"
-        )
-        pix_fmt = "yuv420p"
-
-    # Get input frames
-    template = "frame_" + ("[0-9]" * 6) + ".jpeg"
-    input_list = sorted(
-        glob.glob(str(imgs_dir / template)), key=lambda x: int(x.split("_")[-1].split(".")[0])
-    )
-
-    # Define video output frame size (assuming all input frames are the same size)
-    if len(input_list) == 0:
-        raise FileNotFoundError(f"No images found in {imgs_dir}.")
-    dummy_image = Image.open(input_list[0])
-    width, height = dummy_image.size
-
-    # Define video codec options
-    video_options = {}
-
-    if g is not None:
-        video_options["g"] = str(g)
-
-    if crf is not None:
-        video_options["crf"] = str(crf)
-
-    if fast_decode:
-        key = "svtav1-params" if vcodec == "libsvtav1" else "tune"
-        value = f"fast-decode={fast_decode}" if vcodec == "libsvtav1" else "fastdecode"
-        video_options[key] = value
-
-    # Set logging level
-    if log_level is not None:
-        # "While less efficient, it is generally preferable to modify logging with Python’s logging"
-        logging.getLogger("libav").setLevel(log_level)
-
-    # Create and open output file (overwrite by default)
-    with av.open(str(video_path), "w") as output:
-        output_stream = output.add_stream(vcodec, fps, options=video_options)
-        output_stream.pix_fmt = pix_fmt
-        output_stream.width = width
-        output_stream.height = height
-
-        # Loop through input frames and encode them
-        for input_data in input_list:
-            input_image = Image.open(input_data).convert("RGB")
-            input_frame = av.VideoFrame.from_image(input_image)
-            packet = output_stream.encode(input_frame)
-            if packet:
-                output.mux(packet)
-
-        # Flush the encoder
-        packet = output_stream.encode()
-        if packet:
-            output.mux(packet)
-
-    # Reset logging level
-    if log_level is not None:
-        av.logging.restore_default_callback()
-
-    if not video_path.exists():
-        raise OSError(f"Video encoding did not work. File not found: {video_path}.")
-
-# GPU speed up video encoding
-def encode_video_frames_ffmpeg(
-    imgs_dir: Path | str,
-    video_path: Path | str,
-    fps: int,
-    vcodec: str = "h264_nvenc",
-    pix_fmt: str = "yuv420p",
-    g: int | None = 4,
-    crf: int | None = 30,
-    overwrite: bool = False,
-) -> None:
-    import subprocess
-    import shutil
-    
-    video_path = Path(video_path)
-    imgs_dir = Path(imgs_dir)
-    
-    video_path.parent.mkdir(parents=True, exist_ok=True)
-    
-    # Check if ffmpeg is available
-    ffmpeg_path = shutil.which("ffmpeg")
-    if ffmpeg_path is None:
-        raise RuntimeError("ffmpeg is not installed or not in system PATH")
-    
-    # Build ffmpeg command
-    cmd = [
-        ffmpeg_path,
-        "-y" if overwrite else "-n",
-        "-framerate", str(fps),
-        "-pattern_type", "sequence",
-        "-i", str(imgs_dir / "frame_%06d.jpeg"),
-        "-vcodec", vcodec,
-        "-pix_fmt", pix_fmt,
-    ]
-    
-    if g is not None:
-        cmd.extend(["-g", str(g)])
-        
-    if crf is not None:
-        cmd.extend(["-crf", str(crf)])
-        
-    cmd.append(str(video_path))
-    
-    try:
-        result = subprocess.run(
-            cmd, 
-            capture_output=True, 
-            text=True, 
-            check=True
-        )
-    except subprocess.CalledProcessError as e:
-        error_msg = f"FFmpeg failed:\nCommand: {' '.join(cmd)}\nStdout: {e.stdout}\nStderr: {e.stderr}"
-        logging.error(error_msg)
-        logging.error(video_path)
-        logging.error(vcodec)
-        print(f"ffmpeg {' '.join(cmd)}")
-        raise RuntimeError(error_msg)
-    except Exception as e:
-        error_msg = f"Failed to run FFmpeg command: {' '.join(cmd)}\nError: {str(e)}"
-        logging.error(error_msg)
-        raise RuntimeError(error_msg)
-
-
-@dataclass
-class VideoFrame:
-    # TODO(rcadene, lhoestq): move to Hugging Face `datasets` repo
-    """
-    Provides a type for a dataset containing video frames.
-
-    Example:
-
-    ```python
-    data_dict = [{"image": {"path": "videos/episode_0.mp4", "timestamp": 0.3}}]
-    features = {"image": VideoFrame()}
-    Dataset.from_dict(data_dict, features=Features(features))
-    ```
-    """
-
-    pa_type: ClassVar[Any] = pa.struct({"path": pa.string(), "timestamp": pa.float32()})
-    _type: str = field(default="VideoFrame", init=False, repr=False)
-
-    def __call__(self):
-        return self.pa_type
-
-
-with warnings.catch_warnings():
-    warnings.filterwarnings(
-        "ignore",
-        "'register_feature' is experimental and might be subject to breaking changes in the future.",
-        category=UserWarning,
-    )
-    # to make VideoFrame available in HuggingFace `datasets`
-    register_feature(VideoFrame, "VideoFrame")
-
-
-def get_audio_info(video_path: Path | str) -> dict:
-    # Set logging level
-    logging.getLogger("libav").setLevel(av.logging.ERROR)
-
-    # Getting audio stream information
-    audio_info = {}
-    with av.open(str(video_path), "r") as audio_file:
-        try:
-            audio_stream = audio_file.streams.audio[0]
-        except IndexError:
-            # Reset logging level
-            av.logging.restore_default_callback()
-            return {"has_audio": False}
-
-        audio_info["audio.channels"] = audio_stream.channels
-        audio_info["audio.codec"] = audio_stream.codec.canonical_name
-        # In an ideal loseless case : bit depth x sample rate x channels = bit rate.
-        # In an actual compressed case, the bit rate is set according to the compression level : the lower the bit rate, the more compression is applied.
-        audio_info["audio.bit_rate"] = audio_stream.bit_rate
-        audio_info["audio.sample_rate"] = audio_stream.sample_rate  # Number of samples per second
-        # In an ideal loseless case : fixed number of bits per sample.
-        # In an actual compressed case : variable number of bits per sample (often reduced to match a given depth rate).
-        audio_info["audio.bit_depth"] = audio_stream.format.bits
-        audio_info["audio.channel_layout"] = audio_stream.layout.name
-        audio_info["has_audio"] = True
-
-    # Reset logging level
-    av.logging.restore_default_callback()
-
-    return audio_info
-
-
-def get_video_info(video_path: Path | str) -> dict:
-    # Set logging level
-    logging.getLogger("libav").setLevel(av.logging.ERROR)
-
-    # Getting video stream information
-    video_info = {}
-    with av.open(str(video_path), "r") as video_file:
-        try:
-            video_stream = video_file.streams.video[0]
-        except IndexError:
-            # Reset logging level
-            av.logging.restore_default_callback()
-            return {}
-
-        video_info["video.height"] = video_stream.height
-        video_info["video.width"] = video_stream.width
-        video_info["video.codec"] = video_stream.codec.canonical_name
-        video_info["video.pix_fmt"] = video_stream.pix_fmt
-        video_info["video.is_depth_map"] = False
-
-        # Calculate fps from r_frame_rate
-        video_info["video.fps"] = int(video_stream.base_rate)
-
-        pixel_channels = get_video_pixel_channels(video_stream.pix_fmt)
-        video_info["video.channels"] = pixel_channels
-
-    # Reset logging level
-    av.logging.restore_default_callback()
-
-    # Adding audio stream information
-    video_info.update(**get_audio_info(video_path))
-
-    return video_info
-
-
-def get_video_pixel_channels(pix_fmt: str) -> int:
-    if "gray" in pix_fmt or "depth" in pix_fmt or "monochrome" in pix_fmt:
-        return 1
-    elif "rgba" in pix_fmt or "yuva" in pix_fmt:
-        return 4
-    elif "rgb" in pix_fmt or "yuv" in pix_fmt:
-        return 3
-    else:
-        raise ValueError("Unknown format")
-
-
-def get_image_pixel_channels(image: Image):
-    if image.mode == "L":
-        return 1  # Grayscale
-    elif image.mode == "LA":
-        return 2  # Grayscale + Alpha
-    elif image.mode == "RGB":
-        return 3  # RGB
-    elif image.mode == "RGBA":
-        return 4  # RGBA
-    else:
-        raise ValueError("Unknown format")

joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/lerobot/lerobot_dataset.py

@@ -1,1404 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright 2024 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import contextlib
-import logging
-import shutil
-from pathlib import Path
-from typing import Callable, List, Literal
-import warnings
-
-import datasets
-import numpy as np
-import packaging.version
-import PIL.Image
-import torch
-import torch.utils
-import pyarrow.parquet as pq
-from datasets import concatenate_datasets, load_dataset
-from huggingface_hub import HfApi, snapshot_download
-from huggingface_hub.constants import REPOCARD_NAME
-from huggingface_hub.errors import RevisionNotFoundError
-
-# adapte to own path
-from ..constants import HF_LEROBOT_HOME
-from .datasets.compute_stats import aggregate_stats, compute_episode_stats
-from .datasets.utils import (
-    DEFAULT_FEATURES,
-    DEFAULT_IMAGE_PATH,
-    DEFAULT_DATA_PATH_V30,
-    DEFAULT_VIDEO_PATH_V30,
-    INFO_PATH,
-    TASKS_PATH,
-    _validate_feature_names,
-    append_jsonlines,
-    backward_compatible_episodes_stats,
-    check_delta_timestamps,
-    check_timestamps_sync,
-    # check_version_compatibility,
-    create_empty_dataset_info,
-    create_lerobot_dataset_card,
-    embed_images,
-    get_delta_indices,
-    get_episode_data_index,
-    get_hf_features_from_features,
-    # get_safe_version,
-    hf_transform_to_torch,
-    is_valid_version,
-    load_episodes,
-    load_episodes_stats,
-    load_episodes_v30,
-    load_info,
-    load_stats,
-    load_tasks,
-    load_tasks_v30,
-    load_annotations,
-    validate_episode_buffer,
-    validate_frame,
-    write_episode,
-    write_episode_stats,
-    write_info,
-    write_json,
-)
-from .datasets.video_utils import (
-    VideoFrame,
-    decode_video_frames,
-    encode_video_frames,
-    get_safe_default_codec,
-    get_video_info,
-)
-import traceback
-
-CODEBASE_VERSION = "v2.1"
-
-
-def dataset_dir_to_repo_id(dataset_dir: str | Path) -> str:
-    """Return a valid repo id while preserving local paths as dataset roots.
-
-    LeRobot accepts a local ``root`` and a Hub-style ``repo_id``. Several local
-    training configs pass paths such as ``./data/libero_...`` as
-    ``dataset_dirs``; using that path string as ``repo_id`` trips HuggingFace
-    validation even though the dataset is local. For local paths, use the leaf
-    directory name as a stable, valid dataset id while keeping the original path
-    for ``root``.
-    """
-    ds_path = Path(dataset_dir)
-    ds_str = str(dataset_dir)
-    if ds_path.is_absolute() or ds_str.startswith(".") or ds_path.exists():
-        return ds_path.name
-    return ds_str
-
-
-class LeRobotDatasetMetadata:
-    def __init__(
-        self,
-        repo_id: str,
-        root: str | Path | None = None,
-        revision: str | None = None,
-        force_cache_sync: bool = False,
-    ):
-        self.repo_id = repo_id
-        self.revision = revision if revision else CODEBASE_VERSION
-        self.root = Path(root) if root is not None else HF_LEROBOT_HOME / repo_id
-
-        try:
-            if force_cache_sync:
-                raise FileNotFoundError
-            self.load_metadata()
-        except (FileNotFoundError, NotADirectoryError):
-            # if is_valid_version(self.revision):
-            #     self.revision = get_safe_version(self.repo_id, self.revision)
-
-            (self.root / "meta").mkdir(exist_ok=True, parents=True)
-            self.pull_from_repo(allow_patterns="meta/")
-            self.load_metadata()
-
-    def load_metadata(self):
-        self.info = load_info(self.root)
-        # TODO add new check
-        # check_version_compatibility(self.repo_id, self._version, CODEBASE_VERSION)
-        if self._version >= packaging.version.parse("v3.0"):
-            self.tasks, self.task_to_task_index = load_tasks_v30(self.root)
-            self.episodes = load_episodes_v30(self.root)
-            self.episodes_stats = {}
-            self.stats = load_stats(self.root) or {}
-        elif self._version < packaging.version.parse("v2.1"):
-            self.tasks, self.task_to_task_index = load_tasks(self.root)
-            if (self.root / "annotations").exists():
-                self.annotations = load_annotations(self.root)
-            self.episodes = load_episodes(self.root)
-            self.stats = load_stats(self.root)
-            self.episodes_stats = backward_compatible_episodes_stats(self.stats, self.episodes)
-        else:
-            self.tasks, self.task_to_task_index = load_tasks(self.root)
-            if (self.root / "annotations").exists():
-                self.annotations = load_annotations(self.root)
-            self.episodes = load_episodes(self.root)
-            self.episodes_stats = load_episodes_stats(self.root)
-            self.stats = aggregate_stats(list(self.episodes_stats.values()))
-
-    def pull_from_repo(
-        self,
-        allow_patterns: list[str] | str | None = None,
-        ignore_patterns: list[str] | str | None = None,
-    ) -> None:
-        snapshot_download(
-            self.repo_id,
-            repo_type="dataset",
-            revision=self.revision,
-            local_dir=self.root,
-            allow_patterns=allow_patterns,
-            ignore_patterns=ignore_patterns,
-        )
-
-    @property
-    def _version(self) -> packaging.version.Version:
-        """Codebase version used to create this dataset."""
-        return packaging.version.parse(self.info["codebase_version"])
-
-    def get_data_file_path(self, ep_index: int) -> Path:
-        if self._version >= packaging.version.parse("v3.0"):
-            ep = self.episodes[ep_index]
-            fpath = DEFAULT_DATA_PATH_V30.format(
-                chunk_index=int(ep["data/chunk_index"]),
-                file_index=int(ep["data/file_index"]),
-            )
-        else:
-            ep_chunk = self.get_episode_chunk(ep_index)
-            fpath = self.data_path.format(episode_chunk=ep_chunk, episode_index=ep_index)
-        return Path(fpath)
-
-    def get_video_file_path(self, ep_index: int, vid_key: str) -> Path:
-        if self._version >= packaging.version.parse("v3.0"):
-            ep = self.episodes[ep_index]
-            fpath = DEFAULT_VIDEO_PATH_V30.format(
-                video_key=vid_key,
-                chunk_index=int(ep[f"videos/{vid_key}/chunk_index"]),
-                file_index=int(ep[f"videos/{vid_key}/file_index"]),
-            )
-        else:
-            ep_chunk = self.get_episode_chunk(ep_index)
-            fpath = self.video_path.format(episode_chunk=ep_chunk, video_key=vid_key, episode_index=ep_index)
-        return Path(fpath)
-
-    def get_episode_chunk(self, ep_index: int) -> int:
-        return ep_index // self.chunks_size
-
-    @property
-    def data_path(self) -> str:
-        """Formattable string for the parquet files."""
-        return self.info["data_path"]
-
-    @property
-    def video_path(self) -> str | None:
-        """Formattable string for the video files."""
-        return self.info["video_path"]
-
-    @property
-    def robot_type(self) -> str | None:
-        """Robot type used in recording this dataset."""
-        return self.info["robot_type"]
-
-    @property
-    def fps(self) -> int:
-        """Frames per second used during data collection."""
-        return self.info["fps"]
-
-    @property
-    def features(self) -> dict[str, dict]:
-        """All features contained in the dataset."""
-        return self.info["features"]
-
-    @property
-    def image_keys(self) -> list[str]:
-        """Keys to access visual modalities stored as images."""
-        return [key for key, ft in self.features.items() if ft["dtype"] == "image"]
-
-    @property
-    def video_keys(self) -> list[str]:
-        """Keys to access visual modalities stored as videos."""
-        return [key for key, ft in self.features.items() if ft["dtype"] == "video"]
-
-    @property
-    def camera_keys(self) -> list[str]:
-        """Keys to access visual modalities (regardless of their storage method)."""
-        return [key for key, ft in self.features.items() if ft["dtype"] in ["video", "image"]]
-
-    @property
-    def names(self) -> dict[str, list | dict]:
-        """Names of the various dimensions of vector modalities."""
-        return {key: ft["names"] for key, ft in self.features.items()}
-
-    @property
-    def shapes(self) -> dict:
-        """Shapes for the different features."""
-        return {key: tuple(ft["shape"]) for key, ft in self.features.items()}
-
-    @property
-    def total_episodes(self) -> int:
-        """Total number of episodes available."""
-        return self.info["total_episodes"]
-
-    @property
-    def total_frames(self) -> int:
-        """Total number of frames saved in this dataset."""
-        return self.info["total_frames"]
-
-    @property
-    def total_tasks(self) -> int:
-        """Total number of different tasks performed in this dataset."""
-        return self.info["total_tasks"]
-
-    @property
-    def total_chunks(self) -> int:
-        """Total number of chunks (groups of episodes)."""
-        return self.info["total_chunks"]
-
-    @property
-    def chunks_size(self) -> int:
-        """Max number of episodes per chunk."""
-        return self.info["chunks_size"]
-
-    def get_task_index(self, task: str) -> int | None:
-        """
-        Given a task in natural language, returns its task_index if the task already exists in the dataset,
-        otherwise return None.
-        """
-        return self.task_to_task_index.get(task, None)
-
-    def add_task(self, task: str):
-        """
-        Given a task in natural language, add it to the dictionary of tasks.
-        """
-        if task in self.task_to_task_index:
-            raise ValueError(f"The task '{task}' already exists and can't be added twice.")
-
-        task_index = self.info["total_tasks"]
-        self.task_to_task_index[task] = task_index
-        self.tasks[task_index] = task
-        self.info["total_tasks"] += 1
-
-        task_dict = {
-            "task_index": task_index,
-            "task": task,
-        }
-        append_jsonlines(task_dict, self.root / TASKS_PATH)
-
-    def save_episode(
-        self,
-        episode_index: int,
-        episode_length: int,
-        episode_tasks: list[str],
-        episode_stats: dict[str, dict],
-        raw_file_name: str | None = None, 
-    ) -> None:
-        self.info["total_episodes"] += 1
-        self.info["total_frames"] += episode_length
-
-        chunk = self.get_episode_chunk(episode_index)
-        if chunk >= self.total_chunks:
-            self.info["total_chunks"] += 1
-
-        self.info["splits"] = {"train": f"0:{self.info['total_episodes']}"}
-        self.info["total_videos"] += len(self.video_keys)
-        if len(self.video_keys) > 0:
-            self.update_video_info()
-
-        write_info(self.info, self.root)
-
-        episode_dict = {
-            "episode_index": episode_index,
-            "tasks": episode_tasks,
-            "length": episode_length,
-        }
-        if raw_file_name is not None:
-            episode_dict["raw_file_name"] = raw_file_name
-
-        self.episodes[episode_index] = episode_dict
-        write_episode(episode_dict, self.root)
-
-        self.episodes_stats[episode_index] = episode_stats
-        self.stats = aggregate_stats([self.stats, episode_stats]) if self.stats else episode_stats
-        write_episode_stats(episode_index, episode_stats, self.root)
-
-    def update_video_info(self) -> None:
-        """
-        Warning: this function writes info from first episode videos, implicitly assuming that all videos have
-        been encoded the same way. Also, this means it assumes the first episode exists.
-        """
-        for key in self.video_keys:
-            if not self.features[key].get("info", None):
-                video_path = self.root / self.get_video_file_path(ep_index=0, vid_key=key)
-                self.info["features"][key]["info"] = get_video_info(video_path)
-
-    def __repr__(self):
-        feature_keys = list(self.features)
-        return (
-            f"{self.__class__.__name__}({{\n"
-            f"    Repository ID: '{self.repo_id}',\n"
-            f"    Total episodes: '{self.total_episodes}',\n"
-            f"    Total frames: '{self.total_frames}',\n"
-            f"    Features: '{feature_keys}',\n"
-            "})',\n"
-        )
-
-    @classmethod
-    def create(
-        cls,
-        repo_id: str,
-        fps: int,
-        features: dict,
-        robot_type: str | None = None,
-        root: str | Path | None = None,
-        use_videos: bool = True,
-    ) -> "LeRobotDatasetMetadata":
-        """Creates metadata for a LeRobotDataset."""
-        obj = cls.__new__(cls)
-        obj.repo_id = repo_id
-        obj.root = Path(root) if root is not None else HF_LEROBOT_HOME / repo_id
-
-        obj.root.mkdir(parents=True, exist_ok=False)
-
-        # TODO(aliberts, rcadene): implement sanity check for features
-        features = {**features, **DEFAULT_FEATURES}
-        _validate_feature_names(features)
-
-        obj.tasks, obj.task_to_task_index = {}, {}
-        obj.episodes_stats, obj.stats, obj.episodes = {}, {}, {}
-        obj.info = create_empty_dataset_info(CODEBASE_VERSION, fps, features, use_videos, robot_type)
-        if len(obj.video_keys) > 0 and not use_videos:
-            raise ValueError()
-        write_json(obj.info, obj.root / INFO_PATH)
-        obj.revision = None
-        return obj
-
-
-class LeRobotDataset(torch.utils.data.Dataset):
-    def __init__(
-        self,
-        repo_id: str,
-        root: str | Path | None = None,
-        episodes: list[int] | None = None,
-        image_transforms: Callable | None = None,
-        delta_timestamps: dict[list[float]] | None = None,
-        tolerance_s: float = 1e-4,
-        revision: str | None = None,
-        force_cache_sync: bool = False,
-        download_videos: bool = True,
-        video_backend: str | None = None,
-        video_codec: Literal["h264", "hevc", "libsvtav1", "h264_nvenc"] = "libsvtav1", 
-        is_compute_episode_stats_image: bool = True,
-    ):
-        """
-        2 modes are available for instantiating this class, depending on 2 different use cases:
-
-        1. Your dataset already exists:
-            - On your local disk in the 'root' folder. This is typically the case when you recorded your
-              dataset locally and you may or may not have pushed it to the hub yet. Instantiating this class
-              with 'root' will load your dataset directly from disk. This can happen while you're offline (no
-              internet connection).
-
-            - On the Hugging Face Hub at the address https://huggingface.co/datasets/{repo_id} and not on
-              your local disk in the 'root' folder. Instantiating this class with this 'repo_id' will download
-              the dataset from that address and load it, pending your dataset is compliant with
-              codebase_version v2.0. If your dataset has been created before this new format, you will be
-              prompted to convert it using our conversion script from v1.6 to v2.0, which you can find at
-              lerobot/datasets/v2/convert_dataset_v1_to_v2.py.
-
-
-        2. Your dataset doesn't already exists (either on local disk or on the Hub): you can create an empty
-           LeRobotDataset with the 'create' classmethod. This can be used for recording a dataset or port an
-           existing dataset to the LeRobotDataset format.
-
-
-        In terms of files, LeRobotDataset encapsulates 3 main things:
-            - metadata:
-                - info contains various information about the dataset like shapes, keys, fps etc.
-                - stats stores the dataset statistics of the different modalities for normalization
-                - tasks contains the prompts for each task of the dataset, which can be used for
-                  task-conditioned training.
-            - hf_dataset (from datasets.Dataset), which will read any values from parquet files.
-            - videos (optional) from which frames are loaded to be synchronous with data from parquet files.
-
-        A typical LeRobotDataset looks like this from its root path:
-        .
-        ├── data
-        │   ├── chunk-000
-        │   │   ├── episode_000000.parquet
-        │   │   ├── episode_000001.parquet
-        │   │   ├── episode_000002.parquet
-        │   │   └── ...
-        │   ├── chunk-001
-        │   │   ├── episode_001000.parquet
-        │   │   ├── episode_001001.parquet
-        │   │   ├── episode_001002.parquet
-        │   │   └── ...
-        │   └── ...
-        ├── meta
-        │   ├── episodes.jsonl
-        │   ├── info.json
-        │   ├── stats.json
-        │   └── tasks.jsonl
-        └── videos
-            ├── chunk-000
-            │   ├── observation.images.laptop
-            │   │   ├── episode_000000.mp4
-            │   │   ├── episode_000001.mp4
-            │   │   ├── episode_000002.mp4
-            │   │   └── ...
-            │   ├── observation.images.phone
-            │   │   ├── episode_000000.mp4
-            │   │   ├── episode_000001.mp4
-            │   │   ├── episode_000002.mp4
-            │   │   └── ...
-            ├── chunk-001
-            └── ...
-
-        Note that this file-based structure is designed to be as versatile as possible. The files are split by
-        episodes which allows a more granular control over which episodes one wants to use and download. The
-        structure of the dataset is entirely described in the info.json file, which can be easily downloaded
-        or viewed directly on the hub before downloading any actual data. The type of files used are very
-        simple and do not need complex tools to be read, it only uses .parquet, .json and .mp4 files (and .md
-        for the README).
-
-        Args:
-            repo_id (str): This is the repo id that will be used to fetch the dataset. Locally, the dataset
-                will be stored under root/repo_id.
-            root (Path | None, optional): Local directory to use for downloading/writing files. You can also
-                set the LEROBOT_HOME environment variable to point to a different location. Defaults to
-                '~/.cache/huggingface/lerobot'.
-            episodes (list[int] | None, optional): If specified, this will only load episodes specified by
-                their episode_index in this list. Defaults to None.
-            image_transforms (Callable | None, optional): You can pass standard v2 image transforms from
-                torchvision.transforms.v2 here which will be applied to visual modalities (whether they come
-                from videos or images). Defaults to None.
-            delta_timestamps (dict[list[float]] | None, optional): _description_. Defaults to None.
-            tolerance_s (float, optional): Tolerance in seconds used to ensure data timestamps are actually in
-                sync with the fps value. It is used at the init of the dataset to make sure that each
-                timestamps is separated to the next by 1/fps +/- tolerance_s. This also applies to frames
-                decoded from video files. It is also used to check that `delta_timestamps` (when provided) are
-                multiples of 1/fps. Defaults to 1e-4.
-            revision (str, optional): An optional Git revision id which can be a branch name, a tag, or a
-                commit hash. Defaults to current codebase version tag.
-            sync_cache_first (bool, optional): Flag to sync and refresh local files first. If True and files
-                are already present in the local cache, this will be faster. However, files loaded might not
-                be in sync with the version on the hub, especially if you specified 'revision'. Defaults to
-                False.
-            download_videos (bool, optional): Flag to download the videos. Note that when set to True but the
-                video files are already present on local disk, they won't be downloaded again. Defaults to
-                True.
-            video_backend (str | None, optional): Video backend to use for decoding videos. Defaults to torchcodec when available int the platform; otherwise, defaults to 'pyav'.
-                You can also use the 'pyav' decoder used by Torchvision, which used to be the default option, or 'video_reader' which is another decoder of Torchvision.
-        """
-        super().__init__()
-        self.repo_id = repo_id
-        self.root = Path(root) if root else HF_LEROBOT_HOME / repo_id
-        self.image_transforms = image_transforms
-        self.delta_timestamps = delta_timestamps
-        self.episodes = episodes
-        self.tolerance_s = tolerance_s
-        self.revision = revision if revision else CODEBASE_VERSION
-        self.video_backend = video_backend if video_backend else get_safe_default_codec()
-        self.video_codec = video_codec
-        self.is_compute_episode_stats_image = is_compute_episode_stats_image
-        self.delta_indices = None
-        self.during_training = True
-
-        # Unused attributes
-        self.image_writer = None
-        self.episode_buffer = None
-
-        self.root.mkdir(exist_ok=True, parents=True)
-
-        # Load metadata
-        self.meta = LeRobotDatasetMetadata(
-            self.repo_id, self.root, self.revision, force_cache_sync=force_cache_sync
-        )
-        # v3.0 RoboTwin task shards keep global episode ids. When episodes is None,
-        # range(total_episodes) is wrong for every shard after the first and also
-        # disables parquet filtering. Default to the ids declared by this shard.
-        if self.episodes is None and self.meta._version >= packaging.version.parse("v3.0"):
-            self.episodes = sorted(self.meta.episodes.keys())
-        if (self.episodes is not None
-                and self.meta._version >= packaging.version.parse("v2.1")
-                and self.meta._version < packaging.version.parse("v3.0")):
-            episodes_stats = [self.meta.episodes_stats[ep_idx] for ep_idx in self.episodes]
-            self.stats = aggregate_stats(episodes_stats)
-
-        # v3.0: Dataset.from_parquet with isin() returns rows in parquet storage order
-        # (episode_index order), regardless of the order in self.episodes. Sort episodes
-        # so episode_data_index aligns with the HF dataset row ordering.
-        if self.episodes is not None and self.meta._version >= packaging.version.parse("v3.0"):
-            self.episodes = sorted(self.episodes)
-
-        # Load actual data
-        try:
-            if force_cache_sync:
-                raise FileNotFoundError
-            assert all((self.root / fpath).is_file() for fpath in self.get_episodes_file_paths())
-            self.hf_dataset = self.load_hf_dataset()
-        except (AssertionError, FileNotFoundError, NotADirectoryError):
-            # self.revision = get_safe_version(self.repo_id, self.revision)
-            self.revision = CODEBASE_VERSION
-            self.download_episodes(download_videos)
-            self.hf_dataset = self.load_hf_dataset()
-
-        self.episode_data_index = get_episode_data_index(self.meta.episodes, self.episodes)
-
-        # check_timestamps_sync skipped (requires decoded column access not compatible with set_transform)
-
-        # Setup delta_indices
-        if self.delta_timestamps is not None:
-            # check_delta_timestamps(self.delta_timestamps, self.fps, self.tolerance_s)
-            self.delta_indices = get_delta_indices(self.delta_timestamps, self.fps)
-
-    def push_to_hub(
-        self,
-        branch: str | None = None,
-        tags: list | None = None,
-        license: str | None = "apache-2.0",
-        tag_version: bool = True,
-        push_videos: bool = True,
-        private: bool = False,
-        allow_patterns: list[str] | str | None = None,
-        upload_large_folder: bool = False,
-        **card_kwargs,
-    ) -> None:
-        ignore_patterns = ["images/"]
-        if not push_videos:
-            ignore_patterns.append("videos/")
-
-        hub_api = HfApi()
-        hub_api.create_repo(
-            repo_id=self.repo_id,
-            private=private,
-            repo_type="dataset",
-            exist_ok=True,
-        )
-        if branch:
-            hub_api.create_branch(
-                repo_id=self.repo_id,
-                branch=branch,
-                revision=self.revision,
-                repo_type="dataset",
-                exist_ok=True,
-            )
-
-        upload_kwargs = {
-            "repo_id": self.repo_id,
-            "folder_path": self.root,
-            "repo_type": "dataset",
-            "revision": branch,
-            "allow_patterns": allow_patterns,
-            "ignore_patterns": ignore_patterns,
-        }
-        if upload_large_folder:
-            hub_api.upload_large_folder(**upload_kwargs)
-        else:
-            hub_api.upload_folder(**upload_kwargs)
-
-        if not hub_api.file_exists(self.repo_id, REPOCARD_NAME, repo_type="dataset", revision=branch):
-            card = create_lerobot_dataset_card(
-                tags=tags, dataset_info=self.meta.info, license=license, **card_kwargs
-            )
-            card.push_to_hub(repo_id=self.repo_id, repo_type="dataset", revision=branch)
-
-        if tag_version:
-            with contextlib.suppress(RevisionNotFoundError):
-                hub_api.delete_tag(self.repo_id, tag=CODEBASE_VERSION, repo_type="dataset")
-            hub_api.create_tag(self.repo_id, tag=CODEBASE_VERSION, revision=branch, repo_type="dataset")
-
-    def pull_from_repo(
-        self,
-        allow_patterns: list[str] | str | None = None,
-        ignore_patterns: list[str] | str | None = None,
-    ) -> None:
-        snapshot_download(
-            self.repo_id,
-            repo_type="dataset",
-            revision=self.revision,
-            local_dir=self.root,
-            allow_patterns=allow_patterns,
-            ignore_patterns=ignore_patterns,
-        )
-
-    def download_episodes(self, download_videos: bool = True) -> None:
-        """Downloads the dataset from the given 'repo_id' at the provided version. If 'episodes' is given, this
-        will only download those episodes (selected by their episode_index). If 'episodes' is None, the whole
-        dataset will be downloaded. Thanks to the behavior of snapshot_download, if the files are already present
-        in 'local_dir', they won't be downloaded again.
-        """
-        # TODO(rcadene, aliberts): implement faster transfer
-        # https://huggingface.co/docs/huggingface_hub/en/guides/download#faster-downloads
-        files = None
-        ignore_patterns = None if download_videos else "videos/"
-        if self.episodes is not None:
-            files = self.get_episodes_file_paths()
-
-        self.pull_from_repo(allow_patterns=files, ignore_patterns=ignore_patterns)
-
-    def get_episodes_file_paths(self) -> list[Path]:
-        episodes = (
-            self.episodes
-            if self.episodes is not None
-            else sorted(self.meta.episodes.keys())
-        )
-        fpaths = [str(self.meta.get_data_file_path(ep_idx)) for ep_idx in episodes]
-        if len(self.meta.video_keys) > 0:
-            video_files = [
-                str(self.meta.get_video_file_path(ep_idx, vid_key))
-                for vid_key in self.meta.video_keys
-                for ep_idx in episodes
-            ]
-            fpaths += video_files
-        # v3.0 multi-episode files: many episodes share one file — deduplicate
-        return list(dict.fromkeys(fpaths))
-
-    def load_hf_dataset(self) -> datasets.Dataset:
-        """hf_dataset contains all the observations, states, actions, rewards, etc."""
-        if self.meta._version >= packaging.version.parse("v3.0"):
-            return self._load_hf_dataset_v30()
-        if self.episodes is None:
-            path = str(self.root / "data")
-            hf_dataset = load_dataset("parquet", data_dir=path, split="train")
-        else:
-            files = [str(self.root / self.meta.get_data_file_path(ep_idx)) for ep_idx in self.episodes]
-            hf_dataset = load_dataset("parquet", data_files=files, split="train")
-
-        # TODO(aliberts): hf_dataset.set_format("torch")
-        hf_dataset.set_transform(hf_transform_to_torch)
-        return hf_dataset
-
-    def _load_hf_dataset_v30(self) -> datasets.Dataset:
-        """v3.0 loader: multi-episode parquet files with predicate pushdown filtering."""
-        import pyarrow.dataset as pa_ds
-        features = get_hf_features_from_features(self.meta.features)
-        paths = sorted((self.root / "data").glob("*/*.parquet"))
-        if not paths:
-            raise FileNotFoundError(f"No parquet files found in {self.root / 'data'}")
-        filters = pa_ds.field("episode_index").isin(self.episodes) if self.episodes is not None else None
-        hf_dataset = datasets.Dataset.from_parquet(
-            [str(p) for p in paths], filters=filters, features=features
-        )
-        hf_dataset.set_transform(hf_transform_to_torch)
-        return hf_dataset
-
-    def create_hf_dataset(self) -> datasets.Dataset:
-        features = get_hf_features_from_features(self.features)
-        ft_dict = {col: [] for col in features}
-        hf_dataset = datasets.Dataset.from_dict(ft_dict, features=features, split="train")
-
-        # TODO(aliberts): hf_dataset.set_format("torch")
-        hf_dataset.set_transform(hf_transform_to_torch)
-        return hf_dataset
-
-    @property
-    def fps(self) -> int:
-        """Frames per second used during data collection."""
-        return self.meta.fps
-
-    @property
-    def num_frames(self) -> int:
-        """Number of frames in selected episodes."""
-        return len(self.hf_dataset) if self.hf_dataset is not None else self.meta.total_frames
-
-    @property
-    def num_episodes(self) -> int:
-        """Number of episodes selected."""
-        return len(self.episodes) if self.episodes is not None else self.meta.total_episodes
-
-    @property
-    def features(self) -> dict[str, dict]:
-        return self.meta.features
-
-    @property
-    def hf_features(self) -> datasets.Features:
-        """Features of the hf_dataset."""
-        if self.hf_dataset is not None:
-            return self.hf_dataset.features
-        else:
-            return get_hf_features_from_features(self.features)
-
-    def _get_query_indices(self, idx: int, ep_idx: int) -> tuple[dict[str, list[int | bool]]]:
-        ep_start = self.episode_data_index["from"][ep_idx]
-        ep_end = self.episode_data_index["to"][ep_idx]
-        query_indices = {
-            key: [max(ep_start.item(), min(ep_end.item() - 1, idx + delta)) for delta in delta_idx]
-            for key, delta_idx in self.delta_indices.items()
-        }
-        padding = {  # Pad values outside of current episode range
-            f"{key}_is_pad": torch.BoolTensor(
-                [(idx + delta < ep_start.item()) | (idx + delta >= ep_end.item()) for delta in delta_idx]
-            )
-            for key, delta_idx in self.delta_indices.items()
-        }
-        return query_indices, padding
-
-    def _get_query_timestamps(
-        self,
-        current_ts: float,
-        query_indices: dict[str, list[int]] | None = None,
-    ) -> dict[str, list[float]]:
-        query_timestamps = {}
-        for key in self.meta.video_keys:
-            if query_indices is not None and key in query_indices:
-                timestamps = self.hf_dataset.select(query_indices[key])["timestamp"]
-                query_timestamps[key] = torch.stack(timestamps).tolist()
-            else:
-                query_timestamps[key] = [current_ts]
-
-        return query_timestamps
-
-    def _query_hf_dataset(self, query_indices: dict[str, list[int]]) -> dict:
-        return {
-            key: torch.stack(self.hf_dataset.select(q_idx)[key])
-            for key, q_idx in query_indices.items()
-            if key not in self.meta.video_keys
-        }
-
-    def _query_hf_dataset_fast(self, query_indices: dict[str, list[int]]) -> dict:
-        result = {}
-        processed_indices = set()
-        index_to_selected = {}
-        for key, q_idx in query_indices.items():
-            if key not in self.meta.video_keys :
-                if 'images' in key and not self.during_training:
-                    continue
-                q_idx_tuple = tuple(q_idx)
-                if q_idx_tuple not in processed_indices:
-                    # List-index access triggers set_transform and returns a batch dict.
-                    # .select() returns a Dataset whose column access bypasses the transform.
-                    selected_data = self.hf_dataset[list(q_idx)]
-                    index_to_selected[q_idx_tuple] = selected_data
-                    processed_indices.add(q_idx_tuple)
-                else:
-                    selected_data = index_to_selected[q_idx_tuple]
-                col = selected_data[key]
-                result[key] = col if isinstance(col, torch.Tensor) else torch.stack(col)
-        return result
-    
-    # no videos
-    def get_episode_data(self, episode_id: int) -> dict:
-        ep_start = self.episode_data_index["from"][episode_id].item()
-        ep_end = self.episode_data_index["to"][episode_id].item()
-        q_idx = list(range(ep_start, ep_end))
-        # selected_data = self.hf_dataset.select(q_idx)
-        selected_data = self.hf_dataset[q_idx]
-        res_keys = self.meta.features.keys() - set(self.meta.video_keys)
-        res = {key : torch.stack(selected_data[key]) for key in res_keys}
-        return res
-
-    def _query_videos(self, query_timestamps: dict[str, list[float]], ep_idx: int) -> dict[str, torch.Tensor]:
-        """Note: When using data workers (e.g. DataLoader with num_workers>0), do not call this function
-        in the main process (e.g. by using a second Dataloader with num_workers=0). It will result in a
-        Segmentation Fault. This probably happens because a memory reference to the video loader is created in
-        the main process and a subprocess fails to access it.
-        """
-        item = {}
-        for vid_key, query_ts in query_timestamps.items():
-            video_path = self.root / self.meta.get_video_file_path(ep_idx, vid_key)
-            if self.meta._version >= packaging.version.parse("v3.0"):
-                # In v3.0, episodes are concatenated into shared video files.
-                # Timestamps in the parquet are episode-relative; shift by from_timestamp
-                # to get the seek position within the concatenated file.
-                from_ts = float(self.meta.episodes[ep_idx][f"videos/{vid_key}/from_timestamp"])
-                query_ts = [from_ts + ts for ts in query_ts]
-            frames = decode_video_frames(video_path, query_ts, self.tolerance_s, self.video_backend)
-            item[vid_key] = frames.squeeze(0)
-
-        return item
-
-    def _add_padding_keys(self, item: dict, padding: dict[str, list[bool]]) -> dict:
-        for key, val in padding.items():
-            item[key] = torch.BoolTensor(val)
-        return item
-
-    def __len__(self):
-        return self.num_frames
-
-    def __getitem__(self, idx) -> dict:
-        item = self.hf_dataset[idx]
-        ep_idx = item["episode_index"].item()
-
-        query_indices = None
-        if self.delta_indices is not None:
-            current_ep_idx = self.episodes.index(ep_idx) if self.episodes is not None else ep_idx
-            query_indices, padding = self._get_query_indices(idx, current_ep_idx)
-            query_result = self._query_hf_dataset_fast(query_indices)
-            item = {**item, **padding}
-            for key, val in query_result.items():
-                item[key] = val
-
-        if len(self.meta.video_keys) > 0 and self.during_training:
-            current_ts = item["timestamp"].item()
-            query_timestamps = self._get_query_timestamps(current_ts, query_indices)
-            video_frames = self._query_videos(query_timestamps, ep_idx)
-            item = {**video_frames, **item}
-
-        if self.image_transforms is not None:
-            image_keys = self.meta.camera_keys
-            for cam in image_keys:
-                item[cam] = self.image_transforms(item[cam])
-
-        # Add task as a string
-        task_idx = item["task_index"].item()
-        item["task"] = self.meta.tasks[task_idx]
-        if "coarse_task_index" in item:
-            coarse_task_index = item["coarse_task_index"].item()
-            item["coarse_task"] = self.meta.tasks[coarse_task_index]
-
-        if "operating_hand_index" in item:
-            operating_hand_index = item["operating_hand_index"].item()
-            item["operating_hand"] = self.meta.tasks[operating_hand_index]
-        
-        if "subtask_annotation" in item and hasattr(self.meta, "annotations"):
-            index = item["subtask_annotation"][0].item()
-            item["subtask"] = self.meta.annotations["subtask"][index]
-        
-        if "atomic_task_index" in item and item["atomic_task_index"] is not None:
-            atomic_task_index = item["atomic_task_index"].item()
-            item["subtask"] = self.meta.tasks[int(atomic_task_index)]
-            
-        return item
-
-    def __repr__(self):
-        feature_keys = list(self.features)
-        return (
-            f"{self.__class__.__name__}({{\n"
-            f"    Repository ID: '{self.repo_id}',\n"
-            f"    Number of selected episodes: '{self.num_episodes}',\n"
-            f"    Number of selected samples: '{self.num_frames}',\n"
-            f"    Features: '{feature_keys}',\n"
-            "})',\n"
-        )
-
-    def create_episode_buffer(self, episode_index: int | None = None) -> dict:
-        current_ep_idx = self.meta.total_episodes if episode_index is None else episode_index
-        ep_buffer = {}
-        # size and task are special cases that are not in self.features
-        ep_buffer["size"] = 0
-        ep_buffer["task"] = []
-        for key in self.features:
-            ep_buffer[key] = current_ep_idx if key == "episode_index" else []
-        return ep_buffer
-
-    def _get_image_file_path(self, episode_index: int, image_key: str, frame_index: int) -> Path:
-        fpath = DEFAULT_IMAGE_PATH.format(
-            image_key=image_key, episode_index=episode_index, frame_index=frame_index
-        )
-        return self.root / fpath
-
-    # def _save_image(self, image: torch.Tensor | np.ndarray | PIL.Image.Image | bytes, fpath: Path) -> None:
-    #     if self.image_writer is None:
-    #         if isinstance(image, torch.Tensor):
-    #             image = image.cpu().numpy()
-    #         write_image(image, fpath)
-    #     else:
-    #         self.image_writer.save_image(image=image, fpath=fpath)
-
-    def add_frame(self, frame: dict, task: List[str], timestamp: float | None = None) -> None:
-        """
-        This function only adds the frame to the episode_buffer. Apart from images — which are written in a
-        temporary directory — nothing is written to disk. To save those frames, the 'save_episode()' method
-        then needs to be called.
-        """
-        # Convert torch to numpy if needed
-        assert len(task) == 4, "Task frame must be of two elements"
-        for name in frame:
-            if isinstance(frame[name], torch.Tensor):
-                frame[name] = frame[name].numpy()
-
-        validate_frame(frame, self.features)
-
-        if self.episode_buffer is None:
-            self.episode_buffer = self.create_episode_buffer()
-
-        # Automatically add frame_index and timestamp to episode buffer
-        frame_index = self.episode_buffer["size"]
-        if timestamp is None:
-            timestamp = frame_index / self.fps
-        self.episode_buffer["frame_index"].append(frame_index)
-        self.episode_buffer["timestamp"].append(timestamp)
-        self.episode_buffer["task"].append(task)
-
-        # Add frame features to episode_buffer
-        for key in frame:
-            if key not in self.features:
-                raise ValueError(
-                    f"An element of the frame is not in the features. '{key}' not in '{self.features.keys()}'."
-                )
-
-            if self.features[key]["dtype"] in ["image", "video"]:
-                img_path = self._get_image_file_path(
-                    episode_index=self.episode_buffer["episode_index"], image_key=key, frame_index=frame_index
-                )
-                if frame_index == 0:
-                    img_path.parent.mkdir(parents=True, exist_ok=True)
-                # self._save_image(frame[key], img_path)
-                self.episode_buffer[key].append(str(img_path))
-            else:
-                self.episode_buffer[key].append(frame[key])
-
-        self.episode_buffer["size"] += 1
-
-    def save_episode(self, episode_data: dict | None = None, raw_file_name: str | None = None) -> None:
-        """
-        This will save to disk the current episode in self.episode_buffer.
-
-        Args:
-            episode_data (dict | None, optional): Dict containing the episode data to save. If None, this will
-                save the current episode in self.episode_buffer, which is filled with 'add_frame'. Defaults to
-                None.
-        """
-        if not episode_data:
-            episode_buffer = self.episode_buffer
-
-        validate_episode_buffer(episode_buffer, self.meta.total_episodes, self.features)
-
-        # size and task are special cases that won't be added to hf_dataset
-        episode_length = episode_buffer.pop("size")
-        tasks = episode_buffer.pop("task")
-        episode_tasks = list(set([item for sublist in tasks for item in sublist]))
-        episode_index = episode_buffer["episode_index"]
-
-        episode_buffer["index"] = np.arange(self.meta.total_frames, self.meta.total_frames + episode_length)
-        episode_buffer["episode_index"] = np.full((episode_length,), episode_index)
-
-        # Add new tasks to the tasks dictionary
-        for task in episode_tasks:
-            task_index = self.meta.get_task_index(task)
-            if task_index is None:
-                self.meta.add_task(task)
-
-        # Given tasks in natural language, find their corresponding task indices
-        episode_buffer["coarse_task_index"] = np.array([self.meta.get_task_index(task[0]) for task in tasks])
-        episode_buffer["task_index"] = np.array([self.meta.get_task_index(task[1]) for task in tasks])
-        episode_buffer["coarse_quality_index"] = np.array([self.meta.get_task_index(task[2]) for task in tasks])
-        episode_buffer["quality_index"] = np.array([self.meta.get_task_index(task[3]) for task in tasks])
-
-        for key, ft in self.features.items():
-            # index, episode_index, task_index are already processed above, and image and video
-            # are processed separately by storing image path and frame info as meta data
-            if key in ["index", "episode_index", "coarse_task_index", "task_index", "coarse_quality_index", "quality_index"] or ft["dtype"] in ["image", "video"]:
-                continue
-            episode_buffer[key] = np.stack(episode_buffer[key])
-
-        self._wait_image_writer()
-        self._save_episode_table(episode_buffer, episode_index)
-        ep_stats = compute_episode_stats(episode_buffer, self.features, self.is_compute_episode_stats_image)
-
-        if len(self.meta.video_keys) > 0:
-            video_paths = self.encode_episode_videos(episode_index)
-            for key in self.meta.video_keys:
-                episode_buffer[key] = video_paths[key]
-
-        # `meta.save_episode` be executed after encoding the videos
-        self.meta.save_episode(episode_index, episode_length, episode_tasks, ep_stats, raw_file_name)
-
-        ep_data_index = get_episode_data_index(self.meta.episodes, [episode_index])
-        ep_data_index_np = {k: t.numpy() for k, t in ep_data_index.items()}
-        check_timestamps_sync(
-            episode_buffer["timestamp"],
-            episode_buffer["episode_index"],
-            ep_data_index_np,
-            self.fps,
-            self.tolerance_s,
-        )
-
-        video_files = list(self.root.rglob("*.mp4"))
-        assert len(video_files) == self.num_episodes * len(self.meta.video_keys)
-
-        parquet_files = list(self.root.rglob("*.parquet"))
-        assert len(parquet_files) == self.num_episodes
-
-        # delete images
-        img_dir = self.root / "images"
-        if img_dir.is_dir():
-            shutil.rmtree(self.root / "images")
-
-        if not episode_data:  # Reset the buffer
-            self.episode_buffer = self.create_episode_buffer()
-
-    def _save_episode_table(self, episode_buffer: dict, episode_index: int) -> None:
-        episode_dict = {key: episode_buffer[key] for key in self.hf_features}
-        ep_dataset = datasets.Dataset.from_dict(episode_dict, features=self.hf_features, split="train")
-        ep_dataset = embed_images(ep_dataset)
-        self.hf_dataset = concatenate_datasets([self.hf_dataset, ep_dataset])
-        self.hf_dataset.set_transform(hf_transform_to_torch)
-        ep_data_path = self.root / self.meta.get_data_file_path(ep_index=episode_index)
-        ep_data_path.parent.mkdir(parents=True, exist_ok=True)
-        ep_dataset.to_parquet(ep_data_path)
-
-    def clear_episode_buffer(self) -> None:
-        episode_index = self.episode_buffer["episode_index"]
-        if self.image_writer is not None:
-            for cam_key in self.meta.camera_keys:
-                img_dir = self._get_image_file_path(
-                    episode_index=episode_index, image_key=cam_key, frame_index=0
-                ).parent
-                if img_dir.is_dir():
-                    shutil.rmtree(img_dir)
-
-        # Reset the buffer
-        self.episode_buffer = self.create_episode_buffer()
-
-    # def start_image_writer(self, num_processes: int = 0, num_threads: int = 4) -> None:
-    #     if isinstance(self.image_writer, AsyncImageWriter):
-    #         logging.warning(
-    #             "You are starting a new AsyncImageWriter that is replacing an already existing one in the dataset."
-    #         )
-
-    #     self.image_writer = AsyncImageWriter(
-    #         num_processes=num_processes,
-    #         num_threads=num_threads,
-    #     )
-
-    def stop_image_writer(self) -> None:
-        """
-        Whenever wrapping this dataset inside a parallelized DataLoader, this needs to be called first to
-        remove the image_writer in order for the LeRobotDataset object to be picklable and parallelized.
-        """
-        if self.image_writer is not None:
-            self.image_writer.stop()
-            self.image_writer = None
-
-    def _wait_image_writer(self) -> None:
-        """Wait for asynchronous image writer to finish."""
-        if self.image_writer is not None:
-            self.image_writer.wait_until_done()
-
-    def encode_videos(self) -> None:
-        """
-        Use ffmpeg to convert frames stored as png into mp4 videos.
-        Note: `encode_video_frames` is a blocking call. Making it asynchronous shouldn't speedup encoding,
-        since video encoding with ffmpeg is already using multithreading.
-        """
-        for ep_idx in range(self.meta.total_episodes):
-            self.encode_episode_videos(ep_idx)
-
-    def encode_episode_videos(self, episode_index: int) -> dict:
-        """
-        Use ffmpeg to convert frames stored as png into mp4 videos.
-        Note: `encode_video_frames` is a blocking call. Making it asynchronous shouldn't speedup encoding,
-        since video encoding with ffmpeg is already using multithreading.
-        """
-        video_paths = {}
-        for key in self.meta.video_keys:
-            video_path = self.root / self.meta.get_video_file_path(episode_index, key)
-            video_paths[key] = str(video_path)
-            if video_path.is_file():
-                # Skip if video is already encoded. Could be the case when resuming data recording.
-                continue
-            img_dir = self._get_image_file_path(
-                episode_index=episode_index, image_key=key, frame_index=0
-            ).parent
-            encode_video_frames(img_dir, video_path, self.fps, overwrite=True, vcodec=self.video_codec)
-
-        return video_paths
-
-    @classmethod
-    def create(
-        cls,
-        repo_id: str,
-        fps: int,
-        features: dict,
-        root: str | Path | None = None,
-        robot_type: str | None = None,
-        use_videos: bool = True,
-        tolerance_s: float = 1e-4,
-        image_writer_processes: int = 0,
-        image_writer_threads: int = 0,
-        video_backend: str | None = None,
-        video_codec: Literal["h264", "hevc", "libsvtav1", "h264_nvenc"] = "libsvtav1", 
-        is_compute_episode_stats_image = True,
-    ) -> "LeRobotDataset":
-        """Create a LeRobot Dataset from scratch in order to record data."""
-        obj = cls.__new__(cls)
-        obj.meta = LeRobotDatasetMetadata.create(
-            repo_id=repo_id,
-            fps=fps,
-            robot_type=robot_type,
-            features=features,
-            root=root,
-            use_videos=use_videos,
-        )
-        obj.repo_id = obj.meta.repo_id
-        obj.root = obj.meta.root
-        obj.revision = None
-        obj.tolerance_s = tolerance_s
-        obj.image_writer = None
-
-        # if image_writer_processes or image_writer_threads:
-        #     obj.start_image_writer(image_writer_processes, image_writer_threads)
-
-        # TODO(aliberts, rcadene, alexander-soare): Merge this with OnlineBuffer/DataBuffer
-        obj.episode_buffer = obj.create_episode_buffer()
-
-        obj.episodes = None
-        obj.hf_dataset = obj.create_hf_dataset()
-        obj.image_transforms = None
-        obj.delta_timestamps = None
-        obj.delta_indices = None
-        obj.episode_data_index = None
-        obj.video_backend = video_backend if video_backend is not None else get_safe_default_codec()
-        obj.video_codec = video_codec
-        obj.is_compute_episode_stats_image = is_compute_episode_stats_image
-        return obj
-
-
-class MultiLeRobotDataset(torch.utils.data.Dataset):
-    """A dataset consisting of multiple underlying `LeRobotDataset`s.
-
-    The underlying `LeRobotDataset`s are effectively concatenated, and this class adopts much of the API
-    structure of `LeRobotDataset`.
-    """
-
-    def __init__(
-        self,
-        dataset_dirs: list[str],
-        episodes: dict | None = None,
-        image_transforms: Callable | None = None,
-        delta_timestamps: dict[list[float]] | None = None,
-        tolerances_s: dict | None = None,
-        download_videos: bool = True,
-        video_backend: str | None = None,
-    ):
-        super().__init__()
-        self.dataset_dirs = dataset_dirs
-        ds_roots = [Path(ds_dir) for ds_dir in dataset_dirs]
-        ds_names = [dataset_dir_to_repo_id(ds_dir) for ds_dir in dataset_dirs]
-        self.ds_names = ds_names
-        self.ds_roots = ds_roots
-        self.tolerances_s = tolerances_s if tolerances_s else dict.fromkeys(ds_names, 0.0001)
-        # Construct the underlying datasets passing everything but `transform` and `delta_timestamps` which
-        # are handled by this class.
-        self._datasets = []
-        for ds_root, ds_name in zip(ds_roots, ds_names, strict=True):
-            try:
-                _dataset = LeRobotDataset(
-                    ds_name,
-                    root=ds_root,
-                    episodes=episodes[ds_name] if episodes else None,
-                    image_transforms=image_transforms,
-                    delta_timestamps=delta_timestamps,
-                    tolerance_s=self.tolerances_s[ds_name],
-                    download_videos=download_videos,
-                    video_backend=video_backend,
-                )
-                self._datasets.append(_dataset)
-            except Exception as e:
-                # logging.error(e)
-                logging.error(f"Exception while process ds_root: {ds_root}, ds_name: {ds_name}")
-                traceback.print_exc()
-                raise e
-
-        # Disable any data keys that are not common across all of the datasets. Note: we may relax this
-        # restriction in future iterations of this class. For now, this is necessary at least for being able
-        # to use PyTorch's default DataLoader collate function.
-        self.disabled_features = set()
-        intersection_features = set(self._datasets[0].features)
-        for ds in self._datasets:
-            intersection_features.intersection_update(ds.features)
-        if len(intersection_features) == 0:
-            raise RuntimeError(
-                "Multiple datasets were provided but they had no keys common to all of them. "
-                "The multi-dataset functionality currently only keeps common keys."
-            )
-        for ds_name, ds in zip(self.ds_names, self._datasets, strict=True):
-            # Disable warning of empty extra keys do
-            extra_keys = set(ds.features).difference(intersection_features)
-            if extra_keys:
-                logging.warning(
-                    f"keys {extra_keys} of {ds_name} were disabled as they are not contained in all the "
-                    "other datasets."
-                )
-            self.disabled_features.update(extra_keys)
-
-        self.image_transforms = image_transforms
-        self.delta_timestamps = delta_timestamps
-        # TODO(rcadene, aliberts): We should not perform this aggregation for datasets
-        # with multiple robots of different ranges. Instead we should have one normalization
-        # per robot.
-        try:
-            self.stats = aggregate_stats([dataset.meta.stats for dataset in self._datasets])
-        except ValueError as err:
-            logging.warning(
-                "Failed to aggregate metadata stats across datasets; using the first "
-                "dataset stats instead. Error: %s",
-                err,
-            )
-            self.stats = self._datasets[0].meta.stats
-
-    def set_during_training(self, during_training: bool):
-        for dataset in self._datasets:
-            dataset.during_training = during_training
-
-    @property
-    def repo_id_to_index(self):
-        """Return a mapping from dataset repo_id to a dataset index automatically created by this class.
-
-        This index is incorporated as a data key in the dictionary returned by `__getitem__`.
-        """
-        return {repo_id: i for i, repo_id in enumerate(self.ds_names)}
-
-    @property
-    def repo_index_to_id(self):
-        """Return the inverse mapping if repo_id_to_index."""
-        return {v: k for k, v in self.repo_id_to_index}
-
-    @property
-    def fps(self) -> int:
-        """Frames per second used during data collection.
-
-        NOTE: Fow now, this relies on a check in __init__ to make sure all sub-datasets have the same info.
-        """
-        return self._datasets[0].meta.info["fps"]
-
-    @property
-    def video(self) -> bool:
-        """Returns True if this dataset loads video frames from mp4 files.
-
-        Returns False if it only loads images from png files.
-
-        NOTE: Fow now, this relies on a check in __init__ to make sure all sub-datasets have the same info.
-        """
-        return self._datasets[0].meta.info.get("video", False)
-
-    @property
-    def features(self) -> datasets.Features:
-        features = {}
-        for dataset in self._datasets:
-            features.update({k: v for k, v in dataset.hf_features.items() if k not in self.disabled_features})
-        return features
-
-    @property
-    def camera_keys(self) -> list[str]:
-        """Keys to access image and video stream from cameras."""
-        keys = []
-        for key, feats in self.features.items():
-            if isinstance(feats, (datasets.Image, VideoFrame)):
-                keys.append(key)
-        return keys
-
-    @property
-    def video_frame_keys(self) -> list[str]:
-        """Keys to access video frames that requires to be decoded into images.
-
-        Note: It is empty if the dataset contains images only,
-        or equal to `self.cameras` if the dataset contains videos only,
-        or can even be a subset of `self.cameras` in a case of a mixed image/video dataset.
-        """
-        video_frame_keys = []
-        for key, feats in self.features.items():
-            if isinstance(feats, VideoFrame):
-                video_frame_keys.append(key)
-        return video_frame_keys
-
-    @property
-    def num_frames(self) -> int:
-        """Number of samples/frames."""
-        return sum(d.num_frames for d in self._datasets)
-
-    @property
-    def num_episodes(self) -> int:
-        """Number of episodes."""
-        return sum(d.num_episodes for d in self._datasets)
-
-    @property
-    def tolerance_s(self) -> float:
-        """Tolerance in seconds used to discard loaded frames when their timestamps
-        are not close enough from the requested frames. It is only used when `delta_timestamps`
-        is provided or when loading video frames from mp4 files.
-        """
-        # 1e-4 to account for possible numerical error
-        return 1 / self.fps - 1e-4
-    
-    def get_episode_data(self, episode_idx: int) -> dict:
-        for dataset in self._datasets:
-            if episode_idx < dataset.num_episodes:
-                actual_ep_idx = (
-                    dataset.episodes[episode_idx]
-                    if dataset.episodes is not None
-                    else sorted(dataset.meta.episodes.keys())[episode_idx]
-                )
-                file = str(dataset.root / dataset.meta.get_data_file_path(actual_ep_idx))
-                if dataset.meta._version >= packaging.version.parse("v3.0"):
-                    # v3.0: shared files contain multiple episodes; filter to this one
-                    table = pq.read_table(file, filters=[("episode_index", "=", actual_ep_idx)])
-                else:
-                    table = pq.read_table(file)
-
-                result_dict = {}
-                for col_name in table.column_names:
-                    col = table[col_name]
-                    try:
-                        np_arr = col.to_numpy(zero_copy_only=True)
-                    except Exception:
-                        raw = col.to_numpy()
-                        np_arr = np.stack(raw) if raw.dtype == object else raw
-                    with warnings.catch_warnings():
-                        warnings.filterwarnings(
-                            "ignore",
-                            message="The given NumPy array is not writable",
-                            category=UserWarning,
-                        )
-                        # deal with string in parquet file
-                        if np_arr.dtype == 'O':
-                            result_dict[col_name] = np_arr
-                        else:
-                            result_dict[col_name] = torch.from_numpy(np_arr)
-                return result_dict
-            else:
-                episode_idx -= dataset.num_episodes
-        raise IndexError(f"Episode index {episode_idx} out of bounds.")
-
-    def __len__(self):
-        return self.num_frames
-
-    def __getitem__(self, idx: int) -> dict[str, torch.Tensor]:
-        if idx >= len(self):
-            raise IndexError(f"Index {idx} out of bounds.")
-        # Determine which dataset to get an item from based on the index.
-        start_idx = 0
-        dataset_idx = 0
-        for dataset in self._datasets:
-            if idx >= start_idx + dataset.num_frames:
-                start_idx += dataset.num_frames
-                dataset_idx += 1
-                continue
-            break
-        else:
-            raise AssertionError("We expect the loop to break out as long as the index is within bounds.")
-        item = self._datasets[dataset_idx][idx - start_idx]
-        item["dataset_index"] = torch.tensor(dataset_idx)
-        for data_key in self.disabled_features:
-            if data_key in item:
-                del item[data_key]
-
-        return item
-
-    def __repr__(self):
-        return (
-            f"{self.__class__.__name__}(\n"
-            f"  Dataset Names: '{self.ds_names}',\n"
-            f"  Number of Samples: {self.num_frames},\n"
-            f"  Number of Episodes: {self.num_episodes},\n"
-            f"  Type: {'video (.mp4)' if self.video else 'image (.png)'},\n"
-            f"  Recorded Frames per Second: {self.fps},\n"
-            f"  Camera Keys: {self.camera_keys},\n"
-            f"  Video Frame Keys: {self.video_frame_keys if self.video else 'N/A'},\n"
-            f"  Transformations: {self.image_transforms},\n"
-            f")"
-        )

joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/processors/base_processor.py

@@ -1,263 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Dict, Any, Optional, List, Literal
-
-import torch
-import numpy as np
-from copy import deepcopy
-from ..utils.normalizer import LinearNormalizer, NormMode
-from fastwam.utils.pytorch_utils import dict_apply
-
-
-class BaseProcessor(ABC):
-    def __init__(
-        self,
-        # keys
-        shape_meta: Dict[str, Any],
-        num_obs_steps: int,
-        num_output_cameras: int, 
-        action_output_dim: int,
-        proprio_output_dim: int,
-
-        action_state_transforms: Optional[List[Any]], 
-
-        # action & state normalization
-        use_stepwise_action_norm: bool,
-        norm_default_mode: NormMode,
-        norm_exception_mode: Dict[str, Dict[str, NormMode]], 
-
-        action_state_merger, 
-
-        # image transform
-        train_transforms: Dict[str, List[Any]] | None,
-        val_transforms: Dict[str, List[Any]] | None, 
-
-        # instruction transform
-        drop_high_level_prob: float,
-        use_zh_instruction: bool,
-
-        tokenizer: Any
-    ):
-        self.shape_meta = shape_meta
-        self.num_obs_steps = num_obs_steps
-        self.num_output_cameras = num_output_cameras
-        self.action_output_dim = action_output_dim
-        self.proprio_output_dim = proprio_output_dim
-
-        self.drop_high_level_prob = drop_high_level_prob
-        self.use_zh_instruction = use_zh_instruction
-
-        # image
-        self.train_transforms = train_transforms
-        self.val_transforms = val_transforms
-
-        self._is_train = None
-
-        self.action_state_transforms = action_state_transforms
-        self.action_state_merger = action_state_merger
-        self.action_state_merger.set_shape_meta(self.shape_meta)
-
-        self.use_stepwise_action_norm = use_stepwise_action_norm
-        self.norm_default_mode = norm_default_mode
-        self.norm_exception_mode = norm_exception_mode
-        self._normalizer = None
-
-        self.tokenizer = tokenizer
-
-    @property
-    def is_train(self):
-        if self._is_train is None:
-            raise ValueError("is_train has not been set. Please call train() and eval() first.")
-        return self._is_train
-
-    @property
-    def normalizer(self) -> LinearNormalizer:
-        if self._normalizer is None:
-            raise ValueError("normalizer has not been set. Please call set_normalizer_from_stats() first.")
-        return self._normalizer
-
-    def train(self):
-        self._is_train = True
-        return self
-
-    def eval(self):
-        self._is_train = False
-        return self
-
-    def set_normalizer_from_stats(self, dataset_stats: Dict[str, Any] = None):
-        self._normalizer = LinearNormalizer(
-            use_stepwise_action_norm=self.use_stepwise_action_norm,
-            shape_meta=self.shape_meta,
-            default_mode=self.norm_default_mode,
-            exception_mode=self.norm_exception_mode,
-            stats=dataset_stats,
-        )
-
-    def augment_instruction(self, data: Dict[str, str] | List[str]) -> List[str]:
-        """
-        Args:
-            data: Dict[str, str] | List[str], lerobot sample in raw mcap
-
-        Returns:
-            List[str], processed instructions
-        """
-        # if single instruction, convert to list
-        if "coarse_task" in data:
-            high_level_instruction = data["coarse_task"]
-        else:
-            high_level_instruction = ""
-        if "task" not in data:
-            return f"[high] {high_level_instruction}"
-
-        low_level_instruction = data["task"]
-        # Galaxea lerobot use @ to split Chinese and English instruction
-        if "@" in low_level_instruction:
-            zh, eng = low_level_instruction.split("@")
-            low_level_instruction = zh if self.use_zh_instruction else eng
-
-        if np.random.rand() < self.drop_high_level_prob:
-            instruction = f"[Low]: {low_level_instruction}"
-        else: 
-            instruction = f"[High]: {high_level_instruction}, [Low]: {low_level_instruction}"
-        
-        return instruction
-
-    def action_state_transform(self, batch):
-        if "action" in batch:
-            for meta in self.shape_meta["action"]:
-                k, meta_shape = meta["key"], meta["raw_shape"]
-                actual_shape = batch["action"][k].shape[-1]
-                assert actual_shape == meta_shape, \
-                    f"Action key {k} actual raw shape {actual_shape} mismatch with meta raw shape {meta_shape}."
-                    
-        for meta in self.shape_meta["state"]:
-            k, meta_shape = meta["key"], meta["raw_shape"]
-            actual_shape = batch["state"][k].shape[-1]
-            assert actual_shape == meta_shape, \
-                f"State key {k} actual raw shape {actual_shape} mismatch with meta raw shape{meta_shape}."
-        
-        if self.action_state_transforms is not None: 
-            for trans in self.action_state_transforms:
-                batch = trans.forward(batch)
-        
-        if "action" in batch:
-            for meta in self.shape_meta["action"]:
-                k, meta_shape = meta["key"], meta["shape"]
-                actual_shape = batch["action"][k].shape[-1]
-                assert actual_shape == meta_shape, \
-                    f"Action key {k} actual transformed shape {actual_shape} mismatch with meta shape {meta_shape}."
-        
-        for meta in self.shape_meta["state"]:
-            k, meta_shape = meta["key"], meta["shape"]
-            actual_shape = batch["state"][k].shape[-1]
-            assert actual_shape == meta_shape, \
-                f"State key {k} actual transformed shape {actual_shape} mismatch with meta raw shape {meta_shape}."
-        
-        return batch
-
-    def preprocess(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Preprocess the data for the policy model.
-        
-        Args:
-            Data: Dict[str, Any], lerobot sample in raw mcap obtained from dataset __getitem__:
-                - "action": Optional, Dict[str, torch.Tensor] -> [action_horizon, action_dim]
-                - "state": Dict[str, torch.Tensor] -> [num_obs_steps, state_dim]
-                - "images": Dict[str, torch.Tensor] -> [num_obs_steps, C, H, W]
-                - "action_is_pad": Optional, torch.Tensor -> [action_horizon,]
-                - "state_is_pad": torch.Tensor -> [num_obs_steps,]
-                - "image_is_pad": torch.Tensor -> [num_obs_steps,]
-                - "idx": int, sample index
-                
-        Returns:
-            Sample: Dict[str, Any], which can collated:
-                - "input_ids": torch.Tensor -> [max_image_text_tokens,]
-                - "attention_mask": torch.Tensor -> [max_image_text_tokens,]
-                - "pixel_values": torch.Tensor -> [num_input_cameras, C, H, W]
-                - "image_is_pad": torch.Tensor -> [num_obs_steps,]
-                - "proprio": torch.Tensor -> [num_obs_steps, proprio_dim]
-                - "state_is_pad": torch.Tensor -> [num_obs_steps,]
-                - "action": Optional, torch.Tensor -> [action_horizon, action_dim]
-                - "action_is_pad": Optional, torch.Tensor -> [action_horizon,]
-                - "gt_action: Optional, deepcopy of input action for open loop eval, which is left untouched
-                - "idx": int, sample index
-        """
-        sample = {}
-        # 1. instruction
-        sample["instruction"] = self.augment_instruction(data)
-        sample["image_is_pad"] = data["image_is_pad"]
-
-        # 2. image
-        processed_images = []
-        for meta in self.shape_meta["images"]:
-            key, shape = meta["key"], meta["shape"]
-            image = data["images"][key]  # [num_obs_steps, C, H, W]
-            assert image.ndim == 4, f"Expected 4 dimensions (num_obs_steps, C, H, W), got shape {image.shape}"
-            
-            # Apply transforms efficiently on the merged batch
-            transforms = self.train_transforms if self.is_train else self.val_transforms
-            for trans in transforms[key]:
-                image = trans(image)
-            
-            meta_shape = [self.num_obs_steps] + shape
-            assert image.shape == meta_shape, \
-                f"Expected shape {meta_shape}, got {image.shape} after transforms for key {key}"
-
-            processed_images.append(image)
-        
-        pixel_values = torch.cat(processed_images, dim=0) # [num_input_cameras, C, H, W]
-        if self.num_output_cameras > pixel_values.shape[0]:
-            out = torch.zeros((self.num_output_cameras,) + pixel_values.shape[1:], device=pixel_values.device, dtype=pixel_values.dtype)
-            out[0: pixel_values.shape[0]] = pixel_values
-            sample["pixel_values"] = out
-        else:
-            sample["pixel_values"] = pixel_values
-
-        # Copy action before transform for open-loop evaluation, 
-        # disabled for training dataset as it may cause collating key problem.
-        if not self.is_train and "action" in data:
-            sample["gt_action"] = deepcopy(data["action"])
-
-        # 3. action & state
-        data = self.action_state_transform(data)
-        data = self.normalizer.forward(data)
-        data = self.action_state_merger.forward(data)
-
-        if "action" in data:
-            sample["action"] = data["action"] # [action_horizon, action_dim]
-            sample["action_is_pad"] = data["action_is_pad"] # [action_horizon,]
-            sample["action_dim_is_pad"] = data["action_dim_is_pad"] # [action_dim,]
-            assert sample["action"].shape[-1] == self.action_output_dim
-        
-        # TODO: rename all "state" into "proprio"
-        sample["proprio"] = data["state"] # [num_obs_steps, proprio_dim]
-        sample["proprio_is_pad"] = data["state_is_pad"] # [num_obs_steps,]
-        sample["proprio_dim_is_pad"] = data["state_dim_is_pad"] # [proprio_dim,]
-        assert sample["proprio"].shape[-1] == self.proprio_output_dim
-
-        sample["idx"] = data["idx"]
-
-        sample = self.tokenizer(sample)
-        
-        return sample
-
-    def postprocess(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Postprocess the data for the policy model.
-        
-        Args:
-            data: Dict[str, Any], lerobot sample in raw mcap
-
-        Returns:
-            data: Dict[str, Any], processed data including unnormalized action
-        """
-        assert "action" in data, "Action is required in postprocess"
-        data["state"] = data.pop("proprio")
-        data = self.action_state_merger.backward(data)
-        data = self.normalizer.backward(data)
-        if self.action_state_transforms is not None:
-            for trans in reversed(self.action_state_transforms):
-                data = trans.backward(data)
-
-        start_obs_step = self.num_obs_steps - 1
-        data["action"] = dict_apply(data["action"], lambda x: x[:, start_obs_step:, :])
-        return data

joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/processors/fastwam_processor.py

@@ -1,362 +0,0 @@
-# Author: Rui Heng Yang
-
-from abc import ABC, abstractmethod
-from typing import Dict, Any, Optional, List, Literal
-
-import torch
-import numpy as np
-from copy import deepcopy
-from ..utils.normalizer import LinearNormalizer, NormMode
-from fastwam.utils.pytorch_utils import dict_apply
-from fastwam.utils.logging_config import get_logger
-from .base_processor import BaseProcessor
-
-logger = get_logger(__name__)
-
-# Sample-identity keys that `preprocess()` forwards untouched. Consumers that
-# need to know *which* episode/frame a sample came from (e.g. the EEF-anchor
-# lookup in `RobotVideoDataset`) must read them off the returned sample, since
-# both resample paths mean the requested index is not the delivered one.
-IDENTITY_KEYS = ("dataset_index", "episode_index", "frame_index")
-
-
-class FastWAMProcessor(BaseProcessor):
-    def __init__(
-        self,
-        # keys
-        shape_meta: Dict[str, Any],
-        num_obs_steps: int,
-        num_output_cameras: int, 
-        action_output_dim: int,
-        proprio_output_dim: int,
-
-        action_state_transforms: Optional[List[Any]], 
-
-        # action & state normalization
-        use_stepwise_action_norm: bool,
-        norm_default_mode: NormMode,
-        norm_exception_mode: Dict[str, Dict[str, NormMode]], 
-
-        action_state_merger, 
-
-        # image transform
-        train_transforms: Dict[str, List[Any]] | None,
-        val_transforms: Dict[str, List[Any]] | None, 
-
-        # instruction transform
-        drop_high_level_prob: float = 1.0,
-        use_zh_instruction: bool = False,
-
-        tokenizer: Optional[Any] = None,
-        delta_action_dim_mask: Optional[Dict[str, List[bool]]] = None,
-    ):
-        self.shape_meta = shape_meta
-        self.num_obs_steps = num_obs_steps
-        self.num_output_cameras = num_output_cameras
-        self.action_output_dim = action_output_dim
-        self.proprio_output_dim = proprio_output_dim
-
-        self.drop_high_level_prob = drop_high_level_prob
-        self.use_zh_instruction = use_zh_instruction
-
-        # image
-        self.train_transforms = train_transforms
-        self.val_transforms = val_transforms
-
-        self._is_train = None
-
-        self.action_state_transforms = action_state_transforms
-        self.action_state_merger = action_state_merger
-        self.action_state_merger.set_shape_meta(self.shape_meta)
-
-        self.use_stepwise_action_norm = use_stepwise_action_norm
-        self.norm_default_mode = norm_default_mode
-        self.norm_exception_mode = norm_exception_mode
-        self._normalizer = None
-
-        self.tokenizer = tokenizer
-        if delta_action_dim_mask is None:
-            self.delta_action_dim_mask = None
-        else:
-            action_meta = self.shape_meta["action"]
-            expected_keys = [m["key"] for m in action_meta]
-            provided_keys = list(delta_action_dim_mask.keys())
-            if set(provided_keys) != set(expected_keys):
-                raise ValueError(
-                    f"`delta_action_dim_mask` keys mismatch. Expected {expected_keys}, got {provided_keys}."
-                )
-
-            self.delta_action_dim_mask = {}
-            for meta in action_meta:
-                key = meta["key"]
-                expected_dim = meta["shape"]
-                mask = delta_action_dim_mask[key]
-                if len(mask) != expected_dim:
-                    raise ValueError(
-                        f"`delta_action_dim_mask[{key}]` length must be {expected_dim}, got {len(mask)}."
-                    )
-                self.delta_action_dim_mask[key] = torch.as_tensor(mask, dtype=torch.bool)
-
-    @property
-    def is_train(self):
-        if self._is_train is None:
-            raise ValueError("is_train has not been set. Please call train() and eval() first.")
-        return self._is_train
-
-    @property
-    def normalizer(self) -> LinearNormalizer:
-        if self._normalizer is None:
-            raise ValueError("normalizer has not been set. Please call set_normalizer_from_stats() first.")
-        return self._normalizer
-
-    def train(self):
-        self._is_train = True
-        return self
-
-    def eval(self):
-        self._is_train = False
-        return self
-
-    def set_normalizer_from_stats(self, dataset_stats: Dict[str, Any] = None):
-        self._normalizer = LinearNormalizer(
-            use_stepwise_action_norm=self.use_stepwise_action_norm,
-            shape_meta=self.shape_meta,
-            default_mode=self.norm_default_mode,
-            exception_mode=self.norm_exception_mode,
-            stats=dataset_stats,
-        )
-
-    def augment_instruction(self, data: Dict[str, str] | List[str]) -> List[str]:
-        """
-        Args:
-            data: Dict[str, str] | List[str], lerobot sample in raw mcap
-
-        Returns:
-            List[str], processed instructions
-        """
-        # if single instruction, convert to list
-        if "coarse_task" in data:
-            high_level_instruction = data["coarse_task"]
-        else:
-            high_level_instruction = ""
-        if "task" not in data:
-            return f"[high] {high_level_instruction}"
-
-        low_level_instruction = data["task"]
-        # Galaxea lerobot use @ to split Chinese and English instruction
-        if "@" in low_level_instruction:
-            zh, eng = low_level_instruction.split("@")
-            low_level_instruction = zh if self.use_zh_instruction else eng
-
-        if np.random.rand() < self.drop_high_level_prob:
-            instruction = f"{low_level_instruction}"
-        else: 
-            instruction = f"[High]: {high_level_instruction}, [Low]: {low_level_instruction}"
-        
-        return instruction
-
-    def action_state_transform(self, batch):
-        if "action" in batch:
-            for meta in self.shape_meta["action"]:
-                k, meta_shape = meta["key"], meta["raw_shape"]
-                actual_shape = batch["action"][k].shape[-1]
-                assert actual_shape == meta_shape, \
-                    f"Action key {k} actual raw shape {actual_shape} mismatch with meta raw shape {meta_shape}."
-                    
-        for meta in self.shape_meta["state"]:
-            k, meta_shape = meta["key"], meta["raw_shape"]
-            actual_shape = batch["state"][k].shape[-1]
-            assert actual_shape == meta_shape, \
-                f"State key {k} actual raw shape {actual_shape} mismatch with meta raw shape {meta_shape}."
-        
-        if self.action_state_transforms is not None: 
-            for trans in self.action_state_transforms:
-                batch = trans.forward(batch)
-        
-        if "action" in batch:
-            for meta in self.shape_meta["action"]:
-                k, meta_shape = meta["key"], meta["shape"]
-                actual_shape = batch["action"][k].shape[-1]
-                assert actual_shape == meta_shape, \
-                    f"Action key {k} actual transformed shape {actual_shape} mismatch with meta shape {meta_shape}."
-        
-        for meta in self.shape_meta["state"]:
-            k, meta_shape = meta["key"], meta["shape"]
-            actual_shape = batch["state"][k].shape[-1]
-            assert actual_shape == meta_shape, \
-                f"State key {k} actual transformed shape {actual_shape} mismatch with meta raw shape {meta_shape}."
-        
-        return batch
-
-    def preprocess_images(
-        self,
-        images: Dict[str, torch.Tensor],
-        *,
-        expected_num_obs_steps: Optional[int] = None,
-    ) -> torch.Tensor:
-        """Transform and stack camera images without processing action or state.
-
-        Parameters
-        ----------
-        images:
-            Mapping from configured camera key to ``[T,C,H,W]`` uint8 tensors.
-        expected_num_obs_steps:
-            Expected temporal length. Defaults to the training dataset's full
-            observation horizon; precompute uses the nine VAE-sampled frames.
-
-        Returns
-        -------
-        torch.Tensor
-            Camera-major tensor ``[num_output_cameras,T,C,H,W]``.
-        """
-
-        num_obs_steps = (
-            self.num_obs_steps
-            if expected_num_obs_steps is None
-            else int(expected_num_obs_steps)
-        )
-        processed_images = []
-        for meta in self.shape_meta["images"]:
-            key, shape = meta["key"], meta["shape"]
-            image = images[key]
-            if image.ndim != 4:
-                raise ValueError(
-                    "Expected image dimensions [T,C,H,W], "
-                    f"got {tuple(image.shape)} for key {key}"
-                )
-
-            transforms = self.train_transforms if self.is_train else self.val_transforms
-            current_transforms = transforms[key] if isinstance(transforms, dict) else transforms
-            for transform in current_transforms:
-                image = transform(image)
-
-            expected_shape = [num_obs_steps] + shape
-            if list(image.shape) != expected_shape:
-                raise ValueError(
-                    f"Expected shape {expected_shape}, got {tuple(image.shape)} "
-                    f"after transforms for key {key}"
-                )
-            processed_images.append(image)
-
-        pixel_values = torch.stack(processed_images, dim=0)
-        if self.num_output_cameras > pixel_values.shape[0]:
-            output = torch.zeros(
-                (self.num_output_cameras,) + pixel_values.shape[1:],
-                device=pixel_values.device,
-                dtype=pixel_values.dtype,
-            )
-            output[: pixel_values.shape[0]] = pixel_values
-            return output
-        if self.num_output_cameras < pixel_values.shape[0]:
-            logger.warning(
-                "num_output_cameras %d is less than input cameras %d; truncating.",
-                self.num_output_cameras,
-                pixel_values.shape[0],
-            )
-            return pixel_values[: self.num_output_cameras]
-        return pixel_values
-
-    def preprocess(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Preprocess the data for the policy model.
-        
-        Args:
-            Data: Dict[str, Any], lerobot sample in raw mcap obtained from dataset __getitem__:
-                - "action": Optional, Dict[str, torch.Tensor] -> [action_horizon, action_dim]
-                - "state": Dict[str, torch.Tensor] -> [num_obs_steps, state_dim]
-                - "images": Dict[str, torch.Tensor] -> [num_obs_steps, C, H, W]
-                - "action_is_pad": Optional, torch.Tensor -> [action_horizon,]
-                - "state_is_pad": torch.Tensor -> [num_obs_steps,]
-                - "image_is_pad": torch.Tensor -> [num_obs_steps,]
-                - "idx": int, sample index
-                
-        Returns:
-            Sample: Dict[str, Any], which can collated:
-                - "input_ids": torch.Tensor -> [max_image_text_tokens,]
-                - "attention_mask": torch.Tensor -> [max_image_text_tokens,]
-                - "pixel_values": torch.Tensor -> [num_input_cameras, C, H, W]
-                - "image_is_pad": torch.Tensor -> [num_obs_steps,]
-                - "proprio": torch.Tensor -> [num_obs_steps, proprio_dim]
-                - "state_is_pad": torch.Tensor -> [num_obs_steps,]
-                - "action": Optional, torch.Tensor -> [action_horizon, action_dim]
-                - "action_is_pad": Optional, torch.Tensor -> [action_horizon,]
-                - "gt_action: Optional, deepcopy of input action for open loop eval, which is left untouched
-                - "idx": int, sample index
-        """
-        sample = {}
-        # 1. instruction
-        sample["instruction"] = self.augment_instruction(data)
-        sample["image_is_pad"] = data["image_is_pad"]
-
-        # 2. image
-        if data["images"]:
-            sample["pixel_values"] = self.preprocess_images(data["images"])
-
-        # Copy action before transform for open-loop evaluation, 
-        # disabled for training dataset as it may cause collating key problem.
-        if not self.is_train and "action" in data:
-            sample["gt_action"] = deepcopy(data["action"])
-
-        # 3. action & state
-        if "action" in data and self.delta_action_dim_mask is not None:
-            action_is_pad = torch.as_tensor(data["action_is_pad"], dtype=torch.bool)
-            if bool(action_is_pad.any().item()):
-                for key, dim_mask in self.delta_action_dim_mask.items():
-                    cur_action = data["action"][key]
-                    cur_action_is_pad = action_is_pad.to(device=cur_action.device)
-                    cur_dim_mask = dim_mask.to(device=cur_action.device)
-                    pad_delta_mask = cur_action_is_pad.unsqueeze(1) & cur_dim_mask.unsqueeze(0)
-                    cur_action[pad_delta_mask] = 0.0
-        data = self.action_state_transform(data)
-        data = self.normalizer.forward(data)
-        data = self.action_state_merger.forward(data)
-
-        if "action" in data:
-            sample["action"] = data["action"] # [action_horizon, action_dim]
-            sample["action_is_pad"] = data["action_is_pad"] # [action_horizon,]
-            sample["action_dim_is_pad"] = data["action_dim_is_pad"] # [action_dim,]
-            assert sample["action"].shape[-1] == self.action_output_dim
-            # sample["action"][sample["action_is_pad"], :-1] = 0.0 # NOTE: we assume use delta_eef_pose + gripper， so pad action is 0
-
-        
-        # TODO: rename all "state" into "proprio"
-        sample["proprio"] = data["state"] # [num_obs_steps, proprio_dim]
-        sample["proprio_is_pad"] = data["state_is_pad"] # [num_obs_steps,]
-        sample["proprio_dim_is_pad"] = data["state_dim_is_pad"] # [proprio_dim,]
-        assert sample["proprio"].shape[-1] == self.proprio_output_dim
-
-        sample["idx"] = data["idx"]
-
-        # Episode/frame identity, forwarded verbatim. `preprocess` builds a fresh
-        # dict, so anything not copied here is dropped before the caller sees it.
-        # `RobotVideoDataset` keys its EEF-anchor lookup off these and consumes
-        # them, so they never reach the collater.
-        for key in IDENTITY_KEYS:
-            if key in data:
-                sample[key] = data[key]
-
-        # sample = self.tokenizer(sample)
-
-        return sample
-
-    def postprocess(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Postprocess the data for the policy model.
-        
-        Args:
-            data: Dict[str, Any], lerobot sample in raw mcap
-
-        Returns:
-            data: Dict[str, Any], processed data including unnormalized action
-        """
-        assert "action" in data, "Action is required in postprocess"
-        data["state"] = data.pop("proprio")
-        data = self.action_state_merger.backward(data)
-        data = self.normalizer.backward(data)
-        if self.action_state_transforms is not None:
-            for trans in reversed(self.action_state_transforms):
-                data = trans.backward(data)
-
-        start_obs_step = self.num_obs_steps - 1
-        data["action"] = dict_apply(data["action"], lambda x: x[:, start_obs_step:, :])
-        return data

joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/robot_video_dataset.py

@@ -1,446 +0,0 @@
-# Author: Rui Heng Yang
-
-import hashlib
-import os
-from pathlib import Path
-from typing import Any, Optional
-import numpy as np
-import traceback
-import torch
-import torchvision.transforms.functional as transforms_F
-
-from omegaconf import DictConfig, OmegaConf
-
-from hydra.utils import instantiate
-from .base_lerobot_dataset import BaseLerobotDataset
-from ..video_latent_cache import VideoLatentCache, build_video_preprocess_spec
-from .utils.normalizer import save_dataset_stats_to_json, load_dataset_stats_from_json
-from ..dataset_utils import ResizeSmallestSideAspectPreserving, CenterCrop, Normalize
-from fastwam.utils.logging_config import get_logger
-from fastwam.utils import misc, pytorch_utils
-logger = get_logger(__name__)
-
-
-DEFAULT_PROMPT = "A video recorded from a robot's point of view executing the following instruction: {task}"
-
-
-def _is_main_process_without_init() -> bool:
-    return pytorch_utils._resolve_global_rank() == 0
-
-class RobotVideoDataset(torch.utils.data.Dataset):
-    def __init__(
-        self,
-        dataset_dirs,
-        shape_meta,
-        num_frames=33,
-        video_size=[384, 640],
-        camera_key=None,
-        processor=None,
-        text_embedding_cache_dir=None,
-        context_len=128,
-        pretrained_norm_stats=None,
-        val_set_proportion=0.05,
-        is_training_set=False,
-        episode_indices=None,
-        episode_indices_path=None,
-        episode_indices_key=None,
-        global_sample_stride=1,
-        action_video_freq_ratio: int = 1,
-        skip_padding_as_possible: bool = False,
-        max_padding_retry: int = 3,
-        concat_multi_camera: str = "horizontal", # "horizontal", "vertical", "robotwin", or None
-        video_backend: Optional[str] = None,
-        video_latent_cache_dir: Optional[str] = None,
-        video_latent_cache_vae_identity: Optional[dict[str, str]] = None,
-        strict_getitem: bool = False,
-        precompute_video_only: bool = False,
-        override_instruction: Optional[str] = None, # whether to hardcode a specific instruction for all samples, for debugging
-        eef_anchor_calibration_path: Optional[str] = None,
-        eef_anchor_raw_resolution: int = 512,
-    ):
-        if video_latent_cache_dir is not None and not strict_getitem:
-            raise ValueError(
-                "`strict_getitem=true` is required with `video_latent_cache_dir` "
-                "to prevent latent/action sample misalignment."
-            )
-        if video_latent_cache_dir is not None and video_backend is None:
-            raise ValueError(
-                "`video_backend` must be explicitly pinned when using a video latent cache."
-            )
-        if video_latent_cache_dir is not None and video_latent_cache_vae_identity is None:
-            raise ValueError(
-                "`video_latent_cache_vae_identity` is required with a video latent cache."
-            )
-        if strict_getitem and skip_padding_as_possible:
-            raise ValueError(
-                "`skip_padding_as_possible` must be false in strict/cache mode because "
-                "padding retries substitute a random global sample index."
-            )
-        if precompute_video_only and (not strict_getitem or video_latent_cache_dir is not None):
-            raise ValueError(
-                "`precompute_video_only` requires strict_getitem=true and no latent cache."
-            )
-
-        if (num_frames - 1) % action_video_freq_ratio != 0:
-            raise ValueError(
-                "num_frames-1 must be divisible by action_video_freq_ratio, got "
-                f"{num_frames - 1} and {action_video_freq_ratio}"
-            )
-        if ((num_frames - 1) // action_video_freq_ratio) % 4 != 0:
-            raise ValueError(
-                "video transitions must be divisible by 4 for tokenization, got "
-                f"{(num_frames - 1) // action_video_freq_ratio}"
-            )
-        video_sample_indices = list(range(0, num_frames, action_video_freq_ratio))
-
-        shape_meta_container = OmegaConf.to_container(shape_meta, resolve=True)
-        processor_config: dict[str, Any] | None = None
-        if isinstance(processor, DictConfig):
-            processor_config = OmegaConf.to_container(processor, resolve=True)
-
-        self.lerobot_dataset = BaseLerobotDataset(
-            dataset_dirs=dataset_dirs,
-            shape_meta=shape_meta_container,
-            obs_size=num_frames,
-            action_size=num_frames - 1,
-            val_set_proportion=val_set_proportion,
-            is_training_set=is_training_set,
-            episode_indices=episode_indices,
-            episode_indices_path=episode_indices_path,
-            episode_indices_key=episode_indices_key,
-            global_sample_stride=global_sample_stride,
-            video_backend=video_backend,
-            strict_getitem=strict_getitem,
-            image_only=precompute_video_only,
-            image_sample_indices=(video_sample_indices if precompute_video_only else None),
-        )
-    
-        self.num_frames = num_frames
-        self.action_video_freq_ratio = action_video_freq_ratio
-        
-        self.video_sample_indices = video_sample_indices
-
-        self.camera_key = camera_key
-        self.video_latent_cache_dir = video_latent_cache_dir
-        self.strict_getitem = bool(strict_getitem)
-        self.precompute_video_only = bool(precompute_video_only)
-        self.lerobot_dataset._set_return_images(video_latent_cache_dir is None)
-
-        self.video_size = video_size
-        self.text_embedding_cache_dir = text_embedding_cache_dir
-        self.context_len = context_len
-        self.skip_padding_as_possible = skip_padding_as_possible
-        self.max_padding_retry = max_padding_retry
-        self.concat_multi_camera = concat_multi_camera
-        self.override_instruction = override_instruction
-
-        resolved_episode_indices_path = None
-        episode_indices_path_sha256 = None
-        if episode_indices_path is not None:
-            resolved_path = Path(episode_indices_path).expanduser().resolve()
-            if not resolved_path.is_file():
-                raise FileNotFoundError(f"Episode split file not found: {resolved_path}")
-            resolved_episode_indices_path = str(resolved_path)
-            episode_indices_path_sha256 = hashlib.sha256(resolved_path.read_bytes()).hexdigest()
-
-        preprocess_spec = build_video_preprocess_spec(
-            dataset_dirs=dataset_dirs,
-            shape_meta=shape_meta_container,
-            processor_config=processor_config,
-            num_frames=num_frames,
-            action_video_freq_ratio=action_video_freq_ratio,
-            video_size=video_size,
-            concat_multi_camera=concat_multi_camera,
-            video_backend=str(video_backend),
-            global_sample_stride=global_sample_stride,
-            sample_selection={
-                "val_set_proportion": float(val_set_proportion),
-                "is_training_set": bool(is_training_set),
-                "episode_indices": (
-                    None if episode_indices is None else [int(value) for value in episode_indices]
-                ),
-                "episode_indices_path": (
-                    resolved_episode_indices_path
-                ),
-                "episode_indices_path_sha256": episode_indices_path_sha256,
-                "episode_indices_key": episode_indices_key,
-            },
-        )
-        self.video_preprocess_spec = preprocess_spec
-        self.video_latent_cache = None
-        if video_latent_cache_dir is not None:
-            expected_vae_identity = OmegaConf.to_container(
-                video_latent_cache_vae_identity, resolve=True
-            ) if isinstance(video_latent_cache_vae_identity, DictConfig) else dict(
-                video_latent_cache_vae_identity
-            )
-            self.video_latent_cache = VideoLatentCache(
-                video_latent_cache_dir,
-                expected_sample_count=len(self.lerobot_dataset),
-                expected_preprocess_spec=preprocess_spec,
-                expected_vae_identity=expected_vae_identity,
-            )
-
-        self.resize_transform = ResizeSmallestSideAspectPreserving(
-            args={"img_w": self.video_size[1], "img_h": self.video_size[0]},
-        )
-        self.crop_transform = CenterCrop(
-            args={"img_w": self.video_size[1], "img_h": self.video_size[0]},
-        )
-        self.normalize_transform = Normalize(
-            args={"mean": 0.5, "std": 0.5},
-        )
-        if processor is not None:
-            if isinstance(processor, DictConfig):
-                processor = instantiate(processor)
-            if not pretrained_norm_stats:
-                if not is_training_set:
-                    raise ValueError("pretrained_norm_stats must be provided for validation/test sets since we don't want to calculate stats on them.")
-                dist_initialized = (
-                    torch.distributed.is_available() and torch.distributed.is_initialized()
-                )
-                if _is_main_process_without_init() or not dist_initialized:
-                    logger.info("Calculating dataset stats for normalization...")
-                    dataset_stats = self.lerobot_dataset.get_dataset_stats(processor)
-                    work_dir = misc.get_work_dir()
-                    if _is_main_process_without_init():
-                        save_dataset_stats_to_json(dataset_stats, os.path.join(work_dir, "dataset_stats.json"))
-                else:
-                    dataset_stats = None
-                if dist_initialized:
-                    obj_list = [dataset_stats]
-                    torch.distributed.broadcast_object_list(obj_list, src=0)
-                    dataset_stats = obj_list[0]
-            else:
-                dataset_stats = load_dataset_stats_from_json(pretrained_norm_stats)
-                logger.info(f"Using dataset stats: {pretrained_norm_stats}")
-                if _is_main_process_without_init():
-                    work_dir = misc.get_work_dir()
-                    save_dataset_stats_to_json(dataset_stats, os.path.join(work_dir, "dataset_stats.json"))
-
-            processor.set_normalizer_from_stats(dataset_stats)
-            self.lerobot_dataset.set_processor(processor)
-        
-        # EEF-relative camera RoPE: resolve every episode's anchors once, here,
-        # and hold them in RAM. No sidecar exists (plan Section 15). Disabled
-        # unless a calibration path is configured, so every other mode keeps its
-        # existing sample keys and behavior byte for byte.
-        self.eef_anchor_index = None
-        if eef_anchor_calibration_path:
-            from fastwam.datasets.eef_anchors import EpisodeAnchorIndex
-            from fastwam.geometry import EEFProjector, load_calibration
-
-            calibration = load_calibration(eef_anchor_calibration_path)
-            self.eef_anchor_index = EpisodeAnchorIndex.build(
-                [str(d) for d in dataset_dirs],
-                calibration_path=eef_anchor_calibration_path,
-                projector=EEFProjector(calibration, int(eef_anchor_raw_resolution)),
-            )
-
-    def __len__(self):
-        return len(self.lerobot_dataset)
-
-    def _get(self, idx):
-        sample_idx = idx
-        sample = None
-        for attempt in range(self.max_padding_retry + 1):
-            sample = self.lerobot_dataset[sample_idx]
-
-            if not self.skip_padding_as_possible:
-                break
-
-            action_is_pad = sample["action_is_pad"]
-            image_is_pad = sample["image_is_pad"]
-            proprio_is_pad = sample["proprio_is_pad"]
-            has_pad = False
-            if bool(action_is_pad.any().item()):
-                has_pad = True
-            if bool(image_is_pad.any().item()):
-                has_pad = True
-            if bool(proprio_is_pad.any().item()):
-                has_pad = True
-
-            if not has_pad or attempt >= self.max_padding_retry:
-                break
-
-            sample_idx = np.random.randint(len(self.lerobot_dataset))
-        
-        image_is_pad = sample["image_is_pad"]
-
-        if not self.precompute_video_only:
-            image_is_pad = image_is_pad[self.video_sample_indices]
-        video = None
-        video_latents = None
-        if self.video_latent_cache is None:
-            video = sample["pixel_values"]  # [T, C, H, W] or [num_cameras, T, C, H, W]
-            num_cameras = 1
-            if video.ndim == 5:
-                if not self.precompute_video_only:
-                    video = video[:, self.video_sample_indices, :, :, :]
-                num_cameras, T_video, C, H, W = video.shape
-            else:
-                assert video.ndim == 4, f"Expected video to have shape [T, C, H, W], but got {video.shape}"
-                if not self.precompute_video_only:
-                    video = video[self.video_sample_indices, :, :, :]
-                T_video, C, H, W = video.shape
-
-            video = video.view(num_cameras, T_video, C, H, W)  # [num_cameras, T_video, C, H, W]
-            if self.concat_multi_camera == "robotwin":
-                if num_cameras != 3:
-                    raise ValueError(
-                        f"`concat_multi_camera='robotwin'` requires exactly 3 cameras, got {num_cameras}"
-                    )
-                cam_top = transforms_F.resize(
-                    video[0],
-                    size=[256, 320],
-                    interpolation=transforms_F.InterpolationMode.BILINEAR,
-                    antialias=True,
-                )  # [T_video, C, 256, 320]
-                cam_left = transforms_F.resize(
-                    video[1],
-                    size=[128, 160],
-                    interpolation=transforms_F.InterpolationMode.BILINEAR,
-                    antialias=True,
-                )  # [T_video, C, 128, 160]
-                cam_right = transforms_F.resize(
-                    video[2],
-                    size=[128, 160],
-                    interpolation=transforms_F.InterpolationMode.BILINEAR,
-                    antialias=True,
-                )  # [T_video, C, 128, 160]
-                bottom = torch.cat([cam_left, cam_right], dim=-1)  # [T_video, C, 128, 320]
-                video = torch.cat([cam_top, bottom], dim=-2)  # [T_video, C, 384, 320]
-            elif num_cameras > 1:
-                if self.concat_multi_camera == "horizontal":
-                    video = torch.cat([video[i] for i in range(num_cameras)], dim=-1)  # [T_video, C, H, num_cameras*W]
-                elif self.concat_multi_camera == "vertical":
-                    video = torch.cat([video[i] for i in range(num_cameras)], dim=-2)  # [T_video, C, num_cameras*H, W]
-                else:
-                    raise ValueError(
-                        f"Invalid concat_multi_camera: {self.concat_multi_camera}. "
-                        "Expected one of: horizontal, vertical, robotwin."
-                    )
-            else:
-                video = video.squeeze(0)  # [T_video, C, H, W]
-
-            # final resize and normalization
-            video = self.resize_transform(video)
-            video = self.crop_transform(video)
-            video = self.normalize_transform(video)  # [T_video, C, H, W]
-
-            video = video.permute(1, 0, 2, 3) # [C, T_video, H, W], range [-1, 1]
-        else:
-            returned_index = int(sample["idx"])
-            video_latents = self.video_latent_cache[returned_index]
-
-        if self.precompute_video_only:
-            if video is None:
-                raise RuntimeError("precompute_video_only unexpectedly resolved cached latents.")
-            return {"video": video}
-
-        # Proxy (from lerobot): 
-        #   action: [num_frames-1, action_dim] # start from t0, except the last frame
-        #   proprio: [num_frames, proprio_dim] # start from t0 to the last frame, aligned with video frames
-        action = sample["action"] # [T-1, action_dim]
-        proprio = sample["proprio"][:-1, :] # [T-1, state_dim]， to align with action
-        sampled_video_frames = len(self.video_sample_indices)
-        if sampled_video_frames <= 1:
-            raise ValueError(f"At least two sampled video frames are required, got {sampled_video_frames}")
-        if action.shape[0] % (sampled_video_frames - 1) != 0:
-            raise ValueError(
-                f"`action` horizon must be divisible by `video` transitions, got {action.shape[0]} and {sampled_video_frames - 1}"
-            )
-
-        task = sample["instruction"]
-        
-        # FIXME
-        if self.override_instruction is not None:
-            task = self.override_instruction
-        instruction = DEFAULT_PROMPT.format(task=task)
-
-        context, context_mask = self._get_cached_text_context(instruction)
-        # NOTE: to keep consistent with wan2.2's behavior
-        context[~context_mask] = 0.0
-        context_mask = torch.ones_like(context_mask)
-        
-        data = {
-            "action": action,
-            "proprio": proprio,
-            "prompt": instruction,
-            "context": context,
-            "context_mask": context_mask,
-            "image_is_pad": image_is_pad,
-            "action_is_pad": sample["action_is_pad"],
-            "proprio_is_pad": sample["proprio_is_pad"],
-        }
-        if video is not None:
-            data["video"] = video
-        else:
-            data["video_latents"] = video_latents
-            data["source_video_shape"] = torch.tensor(
-                [3, sampled_video_frames, int(self.video_size[0]), int(self.video_size[1])],
-                dtype=torch.int64,
-            )
-        if self.eef_anchor_index is not None:
-            # Key off the RETURNED sample, never the requested idx. Both the
-            # padding retry above and __getitem__'s exception handler resample
-            # to a random global index, so an idx-keyed lookup would pair these
-            # frames with another episode's gripper position -- silently.
-            # Indexed, not `.get(..., 0)`: a missing `dataset_index` would
-            # silently key every directory of a concatenated MultiLeRobotDataset
-            # to directory 0, serving one suite's geometry for another's frames.
-            data["eef_anchor_token"] = torch.from_numpy(
-                self.eef_anchor_index.lookup(
-                    dataset_index=int(sample["dataset_index"]),
-                    episode_index=int(sample["episode_index"]),
-                    frame_index=int(sample["frame_index"]),
-                ).copy()
-            )
-        return data
-
-    def _get_cached_text_context(self, prompt: str):
-        if self.text_embedding_cache_dir is None:
-            raise ValueError("text_embedding_cache_dir is not set.")
-        cache_dir = self.text_embedding_cache_dir
-        os.makedirs(cache_dir, exist_ok=True)
-        hashed = hashlib.sha256(prompt.encode("utf-8")).hexdigest()
-        cache_path = os.path.join(cache_dir, f"{hashed}.t5_len{self.context_len}.wan22ti2v5b.pt")
-        if not os.path.exists(cache_path):
-            raise FileNotFoundError(
-                f"Missing text embedding cache: {cache_path}. "
-                "Run scripts/precompute_text_embeds.py first."
-            )
-        payload = torch.load(cache_path, map_location="cpu")
-        context = payload["context"]
-        context_mask = payload["mask"].bool()
-        if context.ndim != 2:
-            raise ValueError(
-                f"Cached `context` must be 2D [L, D], got shape {tuple(context.shape)} in {cache_path}"
-            )
-        if context_mask.ndim != 1:
-            raise ValueError(
-                f"Cached `mask` must be 1D [L], got shape {tuple(context_mask.shape)} in {cache_path}"
-            )
-        if context.shape[0] != self.context_len:
-            raise ValueError(
-                f"Cached context_len mismatch: expected {self.context_len}, got {context.shape[0]} in {cache_path}"
-            )
-        if context_mask.shape[0] != self.context_len:
-            raise ValueError(
-                f"Cached mask_len mismatch: expected {self.context_len}, got {context_mask.shape[0]} in {cache_path}"
-            )
-
-        return context, context_mask
-
-    def __getitem__(self, idx):
-        if self.strict_getitem:
-            return self._get(idx)
-        try:
-            data = self._get(idx)
-        except Exception as e:
-            print(f"Error processing sample idx {idx}: {e}. Returning a random sample instead.")
-            # trace back
-            print(traceback.format_exc())
-            random_idx = np.random.randint(len(self))
-            data = self._get(random_idx)
-        return data

joint/fasterwam/train90_joint_job4247/training_code/fastwam/src/fastwam/datasets/lerobot/transforms/action_state_merger.py

@@ -1,78 +0,0 @@
-from typing import Dict
-
-import torch
-from torch.nn.functional import pad
-
-
-class ConcatLeftAlign:
-    def __init__(
-        self, 
-        action_target_dim: int | None = None, 
-        state_target_dim: int | None = None
-    ):
-        self.action_target_dim = action_target_dim
-        self.state_target_dim = state_target_dim
-
-    def set_shape_meta(self, shape_meta):
-        self.action_meta = shape_meta["action"]
-        self.state_meta = shape_meta["state"]
-
-    def forward(self, batch):
-        if "action" in batch:
-            batch["action"] = self._concat(batch["action"], self.action_meta)
-            batch["action"], batch["action_dim_is_pad"] = self._pad(batch["action"], self.action_target_dim)
-
-        batch["state"] = self._concat(batch["state"], self.state_meta)
-        batch["state"], batch["state_dim_is_pad"] = self._pad(batch["state"], self.state_target_dim)
-
-        return batch
-
-    def backward(self, batch):
-        if self.state_target_dim is not None:
-            assert batch["state"].shape[-1] == self.state_target_dim
-        batch["state"] = self._crop(batch["state"], self.state_meta)
-        batch["state"] = self._split(batch["state"], self.state_meta)
-        
-        if self.action_target_dim is not None:
-            assert batch["action"].shape[-1] == self.action_target_dim
-        batch["action"] = self._crop(batch["action"], self.action_meta)
-        batch["action"] = self._split(batch["action"], self.action_meta)
-
-        return batch
-
-    @staticmethod
-    def _pad(x: torch.Tensor, dim: int):
-        if dim is None:
-            dim = x.shape[-1]
-        
-        assert x.ndim == 2 and x.shape[-1] <= dim
-        pad_dim = dim - x.shape[-1]
-        x_padded = pad(x, (0, pad_dim))
-        mask = torch.zeros_like(x[0]).bool()
-        mask = pad(mask, (0, pad_dim), value=True)
-        return x_padded, mask
-
-    @staticmethod
-    def _crop(x: torch.Tensor, meta: int):
-        assert x.ndim == 3
-        dim = sum([m["shape"] for m in meta])
-        x = x[:, :, :dim]
-        return x
-    
-    @staticmethod
-    def _concat(x: Dict[str, torch.Tensor], meta: Dict[str, Dict]):
-        x = torch.cat([x[m["key"]] for m in meta], dim=-1)
-        assert x.ndim == 2
-        return x
-
-    @staticmethod
-    def _split(x: torch.Tensor, meta: Dict[str, Dict]):
-        assert x.ndim == 3
-        y = {}
-        idx = 0
-        for m in meta:
-            key, dim = m["key"], m["shape"]
-            y[key] = x[:, :, idx: idx + dim]
-            idx += dim
-
-        return y