Update README.md

README.md

@@ -1,77 +1,145 @@
 ---
-datasets: HuggingFaceVLA/libero
+language:
+- en
 library_name: lerobot
-license: apache-2.0
-model_name: pi0
 pipeline_tag: robotics
 tags:
-- pi0
-- robotics
+- vision-language-action
+- imitation-learning
 - lerobot
+inference: false
+license: gemma
+datasets:
+- HuggingFaceVLA/libero
+base_model:
+- lerobot/pi0_libero_base
 ---
 
-# Model Card for pi0
+# π₀ (Pi0) (LeRobot)
 
-<!-- Provide a quick summary of what the model is/does. -->
+π₀ is a Vision-Language-Action (VLA) foundation model from Physical Intelligence that jointly reasons over vision, language, and actions to control robots, serving as the base architecture that later enabled π₀.₅’s open-world generalization.
 
+Checkpoint trained and evaluated on LIBERO tasks.
 
-# π₀ (Pi0) Libero Finetuned
+**Original paper:** π0: A Vision-Language-Action Flow Model for General Robot Controlion  
+**Reference implementation:** https://github.com/Physical-Intelligence/openpi  
+**LeRobot implementation:** Follows the original reference code for compatibility.
 
-This model which come from the Pytorch conversion script of openpi and their `pi0_libero` model, has been finetuned on libero dataset.
 
-π₀ is a **Vision-Language-Action model for general robot control**, from Physical Intelligence. The LeRobot implementation is adapted from their open source [OpenPI](https://github.com/Physical-Intelligence/openpi) repository.
+## Model description
 
-## Model Overview
+- **Inputs:** images (multi-view), proprio/state, optional language instruction
+- **Outputs:** continuous actions
+- **Training objective:** flow matching
+- **Action representation:** continuous
+- **Intended use:** Base model to fine tune on your specific use case
 
-π₀ represents a breakthrough in robotics as the first general-purpose robot foundation model developed by [Physical Intelligence](https://www.physicalintelligence.company/blog/pi0). Unlike traditional robots that are narrow specialists programmed for repetitive motions, π₀ is designed to be a generalist policy that can understand visual inputs, interpret natural language instructions, and control a variety of different robots across diverse tasks.
 
-### Architecture and Approach
+## Quick start (inference on a real batch)
 
-π₀ combines several key innovations:
+### Installation
 
-- **Flow Matching**: Uses a novel method to augment pre-trained VLMs with continuous action outputs via flow matching (a variant of diffusion models)
-- **Cross-Embodiment Training**: Trained on data from 8 distinct robot platforms including UR5e, Bimanual UR5e, Franka, Bimanual Trossen, Bimanual ARX, Mobile Trossen, and Mobile Fibocom
-- **Internet-Scale Pre-training**: Inherits semantic knowledge from a pre-trained 3B parameter Vision-Language Model
-- **High-Frequency Control**: Outputs motor commands at up to 50 Hz for real-time dexterous manipulation
+```bash
+pip install "lerobot[pi]@git+https://github.com/huggingface/lerobot.git"
+```
+For full installation details (including optional video dependencies such as ffmpeg for torchcodec), see the official documentation: https://huggingface.co/docs/lerobot/installation
 
-## Training
+### Load model + dataset, run `select_action`
 
-For training π₀, you can use the standard LeRobot training script with the appropriate configuration:
+```python
+import torch
+from lerobot.datasets.lerobot_dataset import LeRobotDataset
+from lerobot.policies.factory import make_pre_post_processors
+
+# Swap this import per-policy
+from lerobot.policies.pi0 import PI0Policy
+
+# load a policy
+model_id = "lerobot/pi0_libero_finetuned"  # <- swap checkpoint
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+policy = PI0Policy.from_pretrained(model_id).to(device).eval()
+
+preprocess, postprocess = make_pre_post_processors(
+    policy.config,
+    model_id,
+    preprocessor_overrides={"device_processor": {"device": str(device)}},
+)
+# load a lerobotdataset
+dataset = LeRobotDataset("lerobot/libero")
+
+# pick an episode
+episode_index = 0
+
+# each episode corresponds to a contiguous range of frame indices
+from_idx = dataset.meta.episodes["dataset_from_index"][episode_index]
+to_idx   = dataset.meta.episodes["dataset_to_index"][episode_index]
+
+# get a single frame from that episode (e.g. the first frame)
+frame_index = from_idx
+frame = dict(dataset[frame_index])
+
+batch = preprocess(frame)
+with torch.inference_mode():
+    pred_action = policy.select_action(frame)
+    # use your policy postprocess, this post process the action
+    # for instance unnormalize the actions, detokenize it etc..
+    pred_action = postprocess(pred_action)
+```
+
+
+## Training step (loss + backward)
+
+If you’re training / fine-tuning, you typically call `forward(...)` to get a loss and then:
+
+```python
+policy.train()
+batch = dict(dataset[0])
+batch = preprocess(batch)
+
+loss, outputs = policy.forward(batch)
+loss.backward()
 
-```bash
-python src/lerobot/scripts/train.py \
-    --dataset.repo_id=your_dataset \
-    --policy.type=pi0 \
-    --output_dir=./outputs/pi0_training \
-    --job_name=pi0_training \
-    --policy.pretrained_path=lerobot/pi0_libero_finetuned \
-    --policy.repo_id=your_repo_id \
-    --policy.compile_model=true \
-    --policy.gradient_checkpointing=true \
-    --policy.dtype=bfloat16 \
-    --steps=3000 \
-    --policy.scheduler_decay_steps=3000 \
-    --policy.device=cuda \
-    --batch_size=32
 ```
 
-## Citation
+> Notes:
+> 
+> - Some policies expose `policy(**batch)` or return a dict; keep this snippet aligned with the policy API.
+> - Use your trainer script (`lerobot-train`) for full training loops.
 
-If you use this model, please cite the original OpenPI work:
 
-```bibtex
-@article{openpi2024,
-    title={Open-World Robotic Manipulation with Vision-Language-Action Models},
-    author={Physical Intelligence},
-    year={2024},
-    url={https://github.com/Physical-Intelligence/openpi}
-}
+## How to train / fine-tune
+
+```bash
+lerobot-train \
+  --dataset.repo_id=${HF_USER}/<dataset> \
+  --output_dir=./outputs/[RUN_NAME] \
+  --job_name=[RUN_NAME] \
+  --policy.repo_id=${HF_USER}/<desired_policy_repo_id> \
+  --policy.path=lerobot/[BASE_CHECKPOINT] \
+  --policy.dtype=bfloat16 \
+  --policy.device=cuda \
+  --steps=100000 \
+  --batch_size=4
 ```
 
-## Original Repository
+Add policy-specific flags below:
+
+- `-policy.chunk_size=...`
+- `-policy.n_action_steps=...`
+- `-policy.max_action_tokens=...`
+- `-policy.gradient_checkpointing=true`
 
-[OpenPI GitHub Repository](https://github.com/Physical-Intelligence/openpi)
 
-## License
+## Evaluate in Simulation (LIBERO)
 
-This model follows the same license as the original OpenPI repository.
+You can evaluate the model in Libero environment.
+
+```bash
+lerobot-eval \
+  --policy.path=lerobot/pi0_libero_finetuned \
+  --env.type=libero \
+  --env.task=libero_object \
+  --eval.batch_size=1 \
+  --eval.n_episodes=20
+```