Enhance ViPRA dataset card with links, abstract, usage, and task categories

This PR significantly improves the dataset card for ViPRA by:
- Adding `task_categories: ['robotics', 'video-text-to-text']` to the metadata for better discoverability.
- Including a visual teaser image.
- Providing direct links to the Hugging Face paper, the project page, and the GitHub repository.
- Incorporating the paper's full abstract and an overview of the ViPRA project.
- Detailing the contents and purpose of the `cotrain-dynamics14` and `cotrain-vqgan-vision-cache` datasets.
- Describing the required dataset structures for various data sources (SSv2, OpenX, LIBERO) with example configurations.
- Adding a "Sample JSONL Entry" to illustrate the dataset's data format.
- Including a "Sample Usage" section with `huggingface-cli` commands for downloading the datasets and a Python code snippet demonstrating the `ViPRAClient` for robot action inference, all sourced directly from the GitHub README.
- Adding the BibTeX citation for proper attribution.

These additions make the dataset card much more comprehensive, informative, and useful for researchers looking to understand and utilize the ViPRA datasets.

README.md

@@ -1,9 +1,223 @@
 ---
 license: apache-2.0
+size_categories:
+- 10M<n<100M
 tags:
 - robotics
 - latent-actions
 - vipra
-size_categories:
-- 10M<n<100M
----
+task_categories:
+- robotics
+- video-text-to-text
+---
+
+# ViPRA: Video Prediction for Robot Actions Datasets
+
+<div align="center">
+<picture>
+  <!-- Optional: light/dark variants -->
+  <img src="https://github.com/sroutray/vipra/assets/teaser_vipra.png" alt="ViPRA teaser" style="max-width: 100%; height: auto;">
+</picture>
+
+<p>
+    <a href="https://huggingface.co/papers/2511.07732">
+        <img src="https://img.shields.io/badge/Paper-2511.07732-b31b1b.svg" alt="Paper">
+    </a>
+    <a href="https://vipra-project.github.io">
+        <img src="https://img.shields.io/badge/Project-Page-green.svg" alt="Project Page">
+    </a>
+    <a href="https://github.com/sroutray/vipra">
+        <img src="https://img.shields.io/badge/Code-GitHub-blue.svg" alt="Code">
+    </a>
+</p>
+</div>
+
+ViPRA (Video Prediction for Robot Actions) is a framework that learns continuous robot control from actionless videos. It employs a video-language model to predict future visual observations and motion-centric latent actions, which are intermediate representations of scene dynamics. These latent actions are trained to reflect physically grounded behavior, and for downstream control, a chunked flow matching decoder maps them to robot-specific continuous action sequences.
+
+## Abstract
+
+Can we turn a video prediction model into a robot policy? Videos, including those of humans or teleoperated robots, capture rich physical interactions. However, most of them lack labeled actions, which limits their use in robot learning. We present Video Prediction for Robot Actions (ViPRA), a simple pretraining-finetuning framework that learns continuous robot control from these actionless videos. Instead of directly predicting actions, we train a video-language model to predict both future visual observations and motion-centric latent actions, which serve as intermediate representations of scene dynamics. We train these latent actions using perceptual losses and optical flow consistency to ensure they reflect physically grounded behavior. For downstream control, we introduce a chunked flow matching decoder that maps latent actions to robot-specific continuous action sequences, using only 100 to 200 teleoperated demonstrations. This approach avoids expensive action annotation, supports generalization across embodiments, and enables smooth, high-frequency continuous control upto 22 Hz via chunked action decoding. Unlike prior latent action works that treat pretraining as autoregressive policy learning, explicitly models both what changes and how. Our method outperforms strong baselines, with a 16% gain on the SIMPLER benchmark and a 13% improvement across real world manipulation tasks. We will release models and code at this https URL
+
+## Overview
+- A recipe to learn generalist robot policies from large-scale human and robot videos without action labels.
+- A novel approach to extract motion-centric latent actions that capture fine-grained physical dynamics.
+- A flow matching action decoder with action chunking for high-frequency continuous control.
+- Outperforms prior latent action methods and VLA baselines trained on ground-truth actions.
+
+---
+
+## Datasets
+
+This repository hosts two primary datasets for ViPRA: `cotrain-dynamics14` and `cotrain-vqgan-vision-cache`.
+
+### `cotrain-dynamics14` (ViPRA Policy Pretraining Data)
+
+This is a pre-tokenized, horizon-14 dynamics dataset used for ViPRA policy pretraining. It merges multiple robot datasets (LIBERO, BridgeData V2, Fractal, Kuka) with human video data from SSv2. Each training sample includes:
+
+*   history frames
+*   latent state target
+*   latent action tokens from LAQ
+*   natural language task text
+
+This dataset is already chunked into 14-step latent action sequences.
+
+### `cotrain-vqgan-vision-cache` (Optional, speeds up training)
+
+This optional dataset contains precomputed VQGAN token sequences for each frame. It can be used to speed up training by avoiding the need to repeatedly tokenize raw pixels during the training process. If you don't use the cache, ViPRA can tokenize frames on the fly by setting `vqgan_path` to the VQ-GAN weights from `LWM-Chat-1M-Jax`.
+
+## Dataset Structure Requirements
+
+You can match these layouts or extend `laq/model/data.py` (in the [code repository](https://github.com/sroutray/vipra)) to support your own.
+
+#### Something-Something-v2 (SSv2)
+
+```text
+ssv2/
+├── labels/
+│   ├── train.json
+│   ├── validation.json
+│   └── test.json
+├── 20bn-something-something-v2/
+│   ├── [video_id].webm
+│   └── ...
+```
+
+Example config:
+
+```python
+ssv2 = dict(
+    root_dir=Path("/path/to/ssv2"),
+    split="trainval",   # "train", "val", "trainval", "test", "all"
+    stepsize=2,         # frame sampling stride
+)
+```
+
+#### OpenX Datasets (Fractal, Bridge, Kuka)
+
+```text
+dataset_name/
+├── processed/
+│   ├── trajectory_001/
+│   │   └── images/
+│   │       ├── 000000.jpg
+│   │       ├── 000001.jpg
+│   │       └── ...
+│   ├── trajectory_002/
+│   └── ...
+```
+
+Example config:
+
+```python
+bridge = dict(
+    root_dir=Path("/path/to/bridge"),
+    split="trainval",
+    num_trajs=dict(trainval=25460, val=2546),
+    stepsize=1,
+)
+```
+
+#### LIBERO
+
+```text
+LIBERO/
+├── libero_10_modified/
+│   └── images/trajectory_001/000000.jpg
+├── libero_goal_modified/
+│   └── images/...
+├── libero_object_modified/
+│   └── images/...
+└── libero_spatial_modified/
+    └── images/...
+```
+
+Example config:
+
+```python
+libero = dict(
+    root_dir=Path("/path/to/LIBERO"),
+    split="trainval",
+    num_trajs=dict(trainval=1.0, val=0.1),  # float = percentage
+    stepsize=1,
+)
+```
+
+## Sample JSONL Entry
+
+Each line in the `cotrain-dynamics14` dataset is a JSONL entry representing a training sample with latent actions. Here's an example:
+
+```json
+{
+  "instruction": "pick up the red block and place it in the blue bowl",
+  "raw_action": [0.1, -0.2, 0.05, 0.0, 0.0, 0.0, 1.0],
+  "image": ["libero_10_modified/images/traj_001/step0000.jpg", "libero_10_modified/images/traj_001/step0001.jpg"],
+  "latent_state": ["libero_10_modified/images/traj_001/step0015.jpg"],
+  "latent_action_idxs": [3, 7, 1, 4, 2, 6, 0, 5, 1, 3, 7, 2, 4, 0, 6, 1],
+  "fields_la": "[instruction],[vision],latent_action",
+  "fields_ls": "[instruction],[vision],latent_state", 
+  "fields_ls_la": "[instruction],[vision],latent_state,latent_action"
+}
+```
+
+## Sample Usage
+
+### Downloading Pretraining Data
+
+You can download the `cotrain-dynamics14` dataset and the optional `cotrain-vqgan-vision-cache` using the Hugging Face CLI:
+
+```bash
+# Download the cotrain-dynamics14 dataset
+mkdir cotrain_data
+huggingface-cli download vipra-project/cotrain-dynamics14 --local-dir cotrain_data/
+
+# Download the cotrain-vqgan-vision-cache (optional, speeds up training)
+mkdir vision_cache
+huggingface-cli download vipra-project/cotrain-vqgan-vision-cache --local-dir vision_cache/
+```
+
+### Using the ViPRA Client for Action Inference
+
+The `ViPRAClient` class (available in the [code repository](https://github.com/sroutray/vipra) under `vipra/inference/dynamics_action_cont_client.py`) provides a simple interface to communicate with an inference server and obtain robot actions. This demonstrates how the dataset's visual inputs and task descriptions are used for inference.
+
+```python
+from inference.dynamics_action_cont_client import ViPRAClient
+import numpy as np
+
+client = ViPRAClient(
+    server_url="http://localhost:8005",
+    timeout=(1.0, 5.0),
+    image_size=256
+)
+
+task_description = "pick up the red block and place it in the blue bowl"
+client.reset_policy(task_description)
+
+image1 = np.random.randint(0, 255, (256, 256, 3), dtype=np.uint8)
+image2 = np.random.randint(0, 255, (256, 256, 3), dtype=np.uint8)
+
+# Two request modes available:
+actions = client.get_action([image1, image2], mode="json")   # JSON mode (baseline)
+actions = client.get_action([image1, image2], mode="bytes")  # JPEG mode (faster)
+```
+
+---
+
+## Citation
+
+If you find our code or models useful in your work, please cite:
+
+```bibtex
+@inproceedings{routray2025vipra,
+  title        = {ViPRA: Video Prediction for Robot Actions},
+  author       = {Routray, Sandeep and Pan, Hengkai and Jain, Unnat and Bahl, Shikhar and Pathak, Deepak},
+  booktitle    = {NeurIPS 2025 Workshop on Embodied World Models for Decision Making},
+  year         = {2025},
+  month        = dec
+}
+```
+
+---
+
+## License
+
+ViPRA’s code and model weights are released under the [Apache License 2.0](https://github.com/sroutray/vipra/blob/main/LICENSE).