Update README.md

README.md

@@ -17,83 +17,38 @@ size_categories:
 
 **Grounded Action Trajectory Embeddings with Vision-Language Action Planning**
 
-This repository contains preprocessed datasets from the LIBERO benchmark suite, specifically designed for training vision-language-action models with semantic action segmentation.
+This repository contains preprocessed datasets from the LIBERO benchmark suite in WebDataset TAR format, specifically designed for training vision-language-action models with semantic action segmentation.
 
-## Why Raw Format?
+## Data Format: WebDataset TAR
 
-We provide datasets in **raw PNG + JSON format** rather than pre-packaged TAR/WebDataset files for several important reasons:
+We provide datasets in **WebDataset TAR format** for optimal performance:
 
-### Advantages of Raw Format
+✅ **Fast loading** - Efficient streaming during training  
+✅ **Easy downloading** - Single file per subtask  
+✅ **HuggingFace optimized** - Quick browsing and file listing  
+✅ **Inspectable** - Extract locally to view individual frames
 
-1. **Easy Inspection**: Browse and visualize individual demonstrations directly on HuggingFace
-2. **Maximum Flexibility**: 
-   - Load with any framework (PyTorch, TensorFlow, JAX)
-   - Convert to your preferred format (TAR, RLDS, LeRobot, custom)
-   - Cherry-pick specific demos or subtasks
-3. **Better Debugging**: 
-   - Inspect problematic frames without extracting archives
-   - Verify data quality visually
-   - Check action sequences frame-by-frame
-4. **Transparent**: See exact file structure and metadata organization
-5. **Version Control**: Git LFS handles individual files better than large archives
+### Extracting TAR Files
 
-### Converting to TAR/WebDataset
+```bash
+# Download a subtask
+wget https://huggingface.co/datasets/gate-institute/GATE-VLAP-datasets/resolve/main/libero_10/pick_up_the_black_bowl.tar
 
-If you need TAR format for efficient streaming during training, you can easily convert:
+# Extract all files
+tar -xf pick_up_the_black_bowl.tar
 
-```python
-import webdataset as wds
-from pathlib import Path
-import json
-from PIL import Image
+# View structure
+ls
+# Output: demo_0/  demo_1/  demo_2/  ...
 
-def convert_to_tar(input_dir, output_pattern, maxcount=1000):
-    """
-    Convert raw PNG+JSON format to WebDataset TAR shards.
-    
-    Args:
-        input_dir: Path to subtask directory (e.g., "libero_10/pick_up_the_black_bowl")
-        output_pattern: Output pattern (e.g., "output/shard-%06d.tar")
-        maxcount: Max samples per shard (default: 1000 frames per TAR)
-    """
-    with wds.ShardWriter(output_pattern, maxcount=maxcount) as sink:
-        subtask_path = Path(input_dir)
-        
-        # Iterate through demos
-        for demo_dir in sorted(subtask_path.iterdir()):
-            if not demo_dir.is_dir():
-                continue
-                
-            # Iterate through timesteps
-            for json_file in sorted(demo_dir.glob("*.json")):
-                png_file = json_file.with_suffix(".png")
-                
-                if not png_file.exists():
-                    continue
-                
-                # Load data
-                with open(json_file) as f:
-                    data = json.load(f)
-                
-                # Create WebDataset sample
-                sample = {
-                    "__key__": f"{demo_dir.name}/{json_file.stem}",
-                    "png": Image.open(png_file),
-                    "json": data,
-                    "action.pyd": data["action"],  # NumPy-compatible format
-                    "robot_state.pyd": data["robot_state"],
-                }
-                
-                sink.write(sample)
-
-# Example: Convert a subtask to TAR
-convert_to_tar(
-    "libero_10/pick_up_the_black_bowl",
-    "tar_output/pick_up_the_black_bowl-%06d.tar"
-)
+# View demo contents
+ls demo_0/
+# Output: demo_0_timestep_0000.png  demo_0_timestep_0000.json
+#         demo_0_timestep_0001.png  demo_0_timestep_0001.json
+#         ...
 ```
 
-### Loading Raw Data
+### Loading Raw Data (After Extraction)
 
 ```python
 from pathlib import Path
@@ -102,7 +57,7 @@ from PIL import Image
 import numpy as np
 
 def load_demo(demo_dir):
-    """Load a single demonstration."""
+    """Load a single demonstration from extracted TAR."""
     frames = []
     demo_path = Path(demo_dir)
     
@@ -119,10 +74,59 @@ def load_demo(demo_dir):
     
     return frames
 
-# Load a specific demo
-demo = load_demo("libero_10/pick_up_the_black_bowl/demo_0")
+# After extracting pick_up_the_black_bowl.tar
+demo = load_demo("demo_0")
 print(f"Demo length: {len(demo)} frames")
-print(f"Action shape: {demo[0]['action'].shape}")
+print(f"Action shape: {demo[0]['action']}")
+```
+
+### Loading with WebDataset (Direct Streaming)
+
+```python
+import webdataset as wds
+from PIL import Image
+import json
+
+# Stream data directly from HuggingFace (no download needed!)
+url = "https://huggingface.co/datasets/gate-institute/GATE-VLAP-datasets/resolve/main/libero_10/pick_up_the_black_bowl.tar"
+
+dataset = wds.WebDataset(url).decode("rgb")
+
+for sample in dataset:
+    # sample["png"] = PIL Image (128x128 RGB)
+    # sample["json"] = bytes (JSON metadata)
+    metadata = json.loads(sample["json"])
+    image = sample["png"]
+    
+    print(f"Action: {metadata['action']}")
+    print(f"Image shape: {np.array(image).shape}")
+    break
+```
+
+### Training with Multiple Subtasks
+
+```python
+import webdataset as wds
+import torch
+from torch.utils.data import DataLoader
+
+# Load multiple subtasks at once
+base_url = "https://huggingface.co/datasets/gate-institute/GATE-VLAP-datasets/resolve/main/libero_10/"
+subtasks = ["pick_up_the_black_bowl", "close_the_drawer", "open_the_top_drawer"]
+urls = [f"{base_url}{task}.tar" for task in subtasks]
+
+dataset = (
+    wds.WebDataset(urls)
+    .decode("rgb")
+    .to_tuple("png", "json")
+    .map(preprocess_fn)  # Your preprocessing function
+)
+
+dataloader = DataLoader(dataset, batch_size=32, num_workers=4)
+
+for images, actions in dataloader:
+    # Train your model
+    pass
 ```
 
 ## Datasets Included
@@ -133,12 +137,12 @@ print(f"Action shape: {demo[0]['action'].shape}")
 - **Segmentation Method**: Semantic Action Chunking using Gemini Vision API
 - **Demos**: 1,354 demonstrations across 29 subtasks
 - **Frames**: 103,650 total frames
-- **Subtasks**: Tasks are automatically segmented into atomic subtasks
+- **TAR Files**: 29 files (one per subtask)
 
 **Example Tasks**:
-- `pick_up_the_black_bowl` → Segmented into pick and place subtasks
-- `close_the_drawer` → Segmented into approach, grasp, close subtasks
-- `put_the_bowl_in_the_drawer` → Multi-step pick, open, place, close sequence
+- `pick_up_the_black_bowl.tar` → Pick and place subtasks
+- `close_the_drawer.tar` → Approach, grasp, close subtasks
+- `put_the_bowl_in_the_drawer.tar` → Multi-step pick, open, place, close sequence
 
 ### LIBERO-Object (Object Manipulation)
 
@@ -146,37 +150,26 @@ print(f"Action shape: {demo[0]['action'].shape}")
 - **Segmentation Method**: Semantic Action Chunking using Gemini Vision API
 - **Demos**: 875 demonstrations across 20 subtasks
 - **Frames**: 66,334 total frames
-- **Subtasks**: Pick and place variations for 10 different objects
+- **TAR Files**: 20 files (one per subtask)
 
 **Example Tasks**:
-- `pick_up_the_alphabet_soup` → Approach, grasp, lift
-- `place_the_alphabet_soup_on_the_basket` → Move, position, place, release
+- `pick_up_the_alphabet_soup.tar` → Approach, grasp, lift
+- `place_the_alphabet_soup_on_the_basket.tar` → Move, position, place, release
 
 ## 📁 Dataset Structure
 
 ```
 gate-institute/GATE-VLAP-datasets/
-├── libero_10/                          # Long-horizon tasks
-│   ├── close_the_drawer/
-│   │   ├── demo_0/
-│   │   │   ├── demo_0_timestep_0000.png  # RGB observation (128x128)
-│   │   │   ├── demo_0_timestep_0000.json # Action + metadata
-│   │   │   ├── demo_0_timestep_0001.png
-│   │   │   ├── demo_0_timestep_0001.json
-│   │   │   └── ...
-│   │   ├── demo_1/
-│   │   └── ...
-│   ├── pick_up_the_black_bowl/
-│   └── ... (29 subtasks total)
+├── libero_10/                          # Long-horizon tasks (29 TAR files)
+│   ├── close_the_drawer.tar
+│   ├── pick_up_the_black_bowl.tar
+│   ├── open_the_top_drawer.tar
+│   └── ... (26 more)
 │
-├── libero_object/                      # Object manipulation tasks
-│   ├── pick_up_the_alphabet_soup/
-│   │   ├── demo_0/
-│   │   │   ├── demo_0_timestep_0000.png
-│   │   │   ├── demo_0_timestep_0000.json
-│   │   │   └── ...
-│   │   └── ...
-│   └── ... (20 subtasks total)
+├── libero_object/                      # Object manipulation (20 TAR files)
+│   ├── pick_up_the_alphabet_soup.tar
+│   ├── place_the_alphabet_soup_on_the_basket.tar
+│   └── ... (18 more)
 │
 └── metadata/                           # Dataset statistics & segmentation
     ├── libero_10_complete_stats.json
@@ -185,6 +178,23 @@ gate-institute/GATE-VLAP-datasets/
     └── libero_object_all_segments.json
 ```
 
+### Inside Each TAR File
+
+After extracting `pick_up_the_black_bowl.tar`:
+
+```
+pick_up_the_black_bowl/
+├── demo_0/
+│   ├── demo_0_timestep_0000.png        # RGB observation (128×128)
+│   ├── demo_0_timestep_0000.json       # Action + metadata
+│   ├── demo_0_timestep_0001.png
+│   ├── demo_0_timestep_0001.json
+│   └── ...
+├── demo_1/
+│   └── ...
+└── ... (all demos for this subtask)
+```
+
 ## Data Format
 
 ### JSON Metadata (per timestep)
@@ -193,13 +203,13 @@ Each `.json` file contains:
 
 ```json
 {
-  "action": [0.1, -0.2, 0.0, 0.0, 0.0, 0.0, 1.0],  // 7-DOF action (xyz, rpy, gripper)
-  "robot_state": [...],                             // Joint positions, velocities
+  "action": [0.1, -0.2, 0.0, 0.0, 0.0, 0.0, 1.0],  // 7-DOF action
+  "robot_state": [...],                             // Joint state
   "demo_id": "demo_0",
   "timestep": 42,
   "subtask": "pick_up_the_black_bowl",
   "parent_task": "LIBERO_10",
-  "is_stop_signal": false                           // Segment boundary marker
+  "is_stop_signal": false                           // Segment boundary
 }
 ```
 
@@ -225,33 +235,7 @@ Each `.json` file contains:
 
 **Purpose**: Overview statistics for the entire LIBERO-10 dataset
 
-```json
-{
-  "dataset": "LIBERO-10",
-  "total_parent_tasks": 10,
-  "total_subtasks": 29,
-  "total_demos": 1354,
-  "total_frames": 103650,
-  "parent_task_mapping": {
-    "LIBERO_10": {
-      "frames": 103650,
-      "demos": 1354,
-      "subtasks": ["pick_up_the_black_bowl", "close_the_drawer", ...]
-    }
-  },
-  "subtask_details": {
-    "pick_up_the_black_bowl": {
-      "demo_count": 48,
-      "frame_count": 3516,
-      "avg_frames_per_demo": 73.25,
-      "parent_task": "LIBERO_10"
-    },
-    ...
-  }
-}
-```
-
-**Use Case**: 
+**Use Cases**: 
 - Understand dataset composition
 - Plan training splits
 - Check demo/frame distribution across tasks
@@ -260,36 +244,13 @@ Each `.json` file contains:
 
 **Purpose**: Detailed segmentation metadata for each demonstration
 
-```json
-{
-  "demo_0": {
-    "subtask": "pick_up_the_black_bowl",
-    "parent_task": "LIBERO_10",
-    "segments": [
-      {
-        "segment_id": 0,
-        "start_frame": 0,
-        "end_frame": 35,
-        "description": "Approach the black bowl",
-        "action_type": "reach"
-      },
-      {
-        "segment_id": 1,
-        "start_frame": 36,
-        "end_frame": 45,
-        "description": "Grasp the black bowl",
-        "action_type": "grasp"
-      },
-      ...
-    ],
-    "segmentation_method": "gemini_vision_api",
-    "total_segments": 3
-  },
-  ...
-}
-```
+Contains semantic action chunks with:
+- Segment boundaries (start/end frames)
+- Action descriptions
+- Segment types (reach, grasp, move, place, etc.)
+- Gemini Vision API segmentation method
 
-**Use Case**:
+**Use Cases**:
 - Train with semantic action chunks
 - Implement hierarchical policies  
 - Analyze action primitives
@@ -297,21 +258,11 @@ Each `.json` file contains:
 
 ### 3. `libero_object_complete_stats.json`
 
-**Purpose**: Statistics for LIBERO-Object dataset (same structure as LIBERO-10)
-
-**Key Differences**:
-- Fewer, simpler subtasks (20 vs 29)
-- Object-centric task naming
-- Rule-based segmentation instead of vision-based
+**Purpose**: Statistics for LIBERO-Object dataset
 
 ### 4. `libero_object_all_segments.json`
 
-**Purpose**: Segmentation for LIBERO-Object demonstrations
-
-**Segmentation Method**: Rule-based gripper detection
-- Segments identified by gripper state changes
-- Stop signals mark task completion
-- More consistent segment boundaries than vision-based
+**Purpose**: Segmentation for LIBERO-Object demonstrations with semantic action chunking
 
 ## Citation
 
@@ -320,7 +271,7 @@ If you use this dataset, please cite:
 ```bibtex
 @article{gateVLAP@SAC2026,
   title={Atomic Action Slicing: Planner-Aligned Options for Generalist VLA Agents},
-  author={[Stefan Tabakov, Asen Popov, Dimitar Dimitrov, Ensiye Kiyamousavi and Boris Kraychev]},
+  author={Tabakov, Stefan and Popov, Asen and Dimitrov, Dimitar and Kiyamousavi, Ensiye and Kraychev, Boris},
   journal={arXiv preprint arXiv:XXXX.XXXXX},
   conference={The 41st ACM/SIGAPP Symposium On Applied Computing (SAC2026), track on Intelligent Robotics and Multi-Agent Systems (IRMAS)},
   year={2025}
@@ -329,7 +280,7 @@ If you use this dataset, please cite:
 @inproceedings{liu2023libero,
   title={LIBERO: Benchmarking Knowledge Transfer for Lifelong Robot Learning},
   author={Liu, Bo and Zhu, Yifeng and Gao, Chongkai and Feng, Yihao and Liu, Qiang and Zhu, Yuke and Stone, Peter},
-  booktitle={Thirty-seventh Conference on Neural Information Processing Systems Datasets and Benchmarks Track},
+  booktitle={NeurIPS Datasets and Benchmarks Track},
   year={2023}
 }
 ```
@@ -338,18 +289,17 @@ If you use this dataset, please cite:
 
 - **Model Checkpoints**: [gate-institute/GATE-VLAP](https://huggingface.co/gate-institute/GATE-VLAP)
 - **Original LIBERO**: [https://github.com/Lifelong-Robot-Learning/LIBERO](https://github.com/Lifelong-Robot-Learning/LIBERO)
-- **Paper**: [arXiv:XXXX.XXXXX](https://arxiv.org) *(coming soon)*
-
+- **Paper**: Coming soon
 
 ## Acknowledgments
 
 - **LIBERO Benchmark**: Original dataset by Liu et al. (2023)
-- **Segmentation**: Gemini Vision API for LIBERO semantic chunking
-- **Infrastructure**: Processed on GATE Institute infrastructure
+- **Segmentation**: Gemini Vision API for semantic action chunking
+- **Institution**: GATE Institute, Sofia, Bulgaria
 
 ## Contact
 
-For questions or issues, please open an issue on our [GitHub repository *(coming soon)*](https://github.com/your-repo).
+For questions or issues, please contact the GATE Institute.
 
 ---