# Política de GR00T

GR00T es una familia de modelos base de NVIDIA para el razonamiento y las habilidades de robots humanoides generalizados. Es una política de cruce de encarnaciones que acepta entrada multimodal, incluido el lenguaje, las imágenes y la propiocepción, para realizar tareas de manipulación en diversos entornos.

LeRobot integra GR00T N1.7 a través del tipo de política `groot`.

> [!WARNING]
> **Cambio importante:** se eliminó la compatibilidad con GR00T N1.5 de LeRobot, y las versiones actuales solo admiten GR00T N1.7. Los puntos de control y configuraciones de N1.5 se rechazan con una nota de migración. Para seguir usando un punto de control de N1.5, fije la última versión que lo admite: `pip install 'lerobot==0.5.1'`. Para usar la versión actual, migre a GR00T N1.7 (modelo base [`nvidia/GR00T-N1.7-3B`](https://huggingface.co/nvidia/GR00T-N1.7-3B)).

## Resumen del modelo

GR00T N1.7 utiliza un backbone de Cosmos-Reason2/Qwen3-VL y proporciona checkpoints para SimplerEnv, DROID y LIBERO.

Los desarrolladores e investigadores pueden realizar el entrenamiento posterior de GR00T con sus propios datos reales o sintéticos para adaptarlo a robots humanoides o tareas específicas.

GR00T utiliza codificadores de visión y lenguaje preentrenados junto con un transformador de acciones de coincidencia de flujos para modelar un bloque de acciones condicionado en la visión, el lenguaje y la propiocepción.

<img
  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/lerobot-groot-paper1%20(1).png"
  alt="An overview of GR00T"
  width="80%"
/>

Su alto rendimiento se debe a que fue entrenado con un conjunto de datos humanoide amplio y diverso, que incluye:

- Datos reales capturados por robots.
- Datos sintéticos generados usando NVIDIA Isaac GR00T Blueprint.
- Datos de video a escala de Internet.

Este enfoque permite que el modelo sea altamente adaptable mediante el entrenamiento posterior para encarnaciones, tareas y entornos específicos.

## Requisitos de instalación

GR00T está diseñado para sistemas con aceleración por GPU de NVIDIA. Instale LeRobot con el extra de GR00T:

```bash
pip install "lerobot[groot]"
```

Para una compilación desde el código fuente:

```bash
pip install -e ".[groot]"
```

## Uso

Para usar GR00T N1.7:

```bash
--policy.type=groot
```

## Entrenamiento

### Ejemplo de comando de entrenamiento

Aquí hay un comando de entrenamiento completo para ajustar el modelo base GR00T en su propio conjunto de datos:

Este comando utiliza la bandera `new_embodiment`, que se usa para el robot SO-101, [lea más sobre cómo GR00T maneja diferentes embodiments](https://github.com/NVIDIA/Isaac-GR00T/blob/main/getting_started/policy.md#--embodiment-tag).

```bash
# install extra deps for training
pip install "lerobot[training]"

hf auth login
# Trackio needs no login for local runs; pass --trackio.space_id=<user>/<space> to sync runs to a Hugging Face Space.

export DATASET_NAME=your_data_set
export HF_USER=your_hf_username
export DATASET=$HF_USER/$DATASET_NAME
export REPO_ID="${DATASET}_GR00T17" #this is the model that will be uploaded to huggingface
export OUTPUT_DIR=outputs/train/$REPO_ID

lerobot-train \
  --dataset.repo_id=$DATASET \
  --dataset.image_transforms.enable=true \
  --policy.type=groot \
  --policy.device=cuda \
  --policy.base_model_path=nvidia/GR00T-N1.7-3B \
  --policy.embodiment_tag=new_embodiment \
  --policy.chunk_size=16 \
  --policy.n_action_steps=16 \
  --policy.use_relative_actions=true \
  --policy.relative_exclude_joints='["gripper"]' \
  --policy.use_bf16=true \
  --policy.push_to_hub=true \
  --policy.repo_id=$REPO_ID \
  --seed=42 \
  --batch_size=64 \
  --steps=20000 \
  --save_checkpoint=true \
  --save_freq=5000 \
  --use_policy_training_preset=true \
  --env_eval_freq=0 \
  --eval_steps=0 \
  --log_freq=10 \
  --output_dir=$OUTPUT_DIR \
  --job_name=$DATASET \
  --trackio.enable=true \
  --trackio.disable_artifact=true

```

## Resultados de rendimiento

### Resultados del benchmark LIBERO

> [!NOTE]
> Siga las instrucciones de configuración de [LIBERO](./libero) antes de ejecutar `lerobot-eval`.

GR00T N1.7 ha demostrado un rendimiento sólido en la suite de benchmarks LIBERO. Para reproducir los resultados de LeRobot, siga las instrucciones de la sección [LIBERO](./libero).

### Entrenar en LIBERO

Ejemplo de comando de entrenamiento para una suite de LIBERO (aquí `libero_spatial`):

```bash
IMAGE_TRANSFORMS='{
  "brightness": {"weight": 1.0, "type": "ColorJitter", "kwargs": {"brightness": [0.7, 1.3]}},
  "contrast":   {"weight": 1.0, "type": "ColorJitter", "kwargs": {"contrast":   [0.6, 1.4]}},
  "saturation": {"weight": 1.0, "type": "ColorJitter", "kwargs": {"saturation": [0.5, 1.5]}},
  "hue":        {"weight": 1.0, "type": "ColorJitter", "kwargs": {"hue":        [-0.08, 0.08]}}
}'

lerobot-train \
  --dataset.repo_id=IPEC-COMMUNITY/libero_spatial_no_noops_1.0.0_lerobot \
  --dataset.root=/datasets/libero_spatial \
  --dataset.revision=main \
  --dataset.video_backend=pyav \
  --dataset.image_transforms.enable=true \
  --dataset.image_transforms.max_num_transforms=4 \
  --dataset.image_transforms.tfs="$IMAGE_TRANSFORMS" \
  --policy.type=groot \
  --policy.base_model_path=nvidia/GR00T-N1.7-3B \
  --policy.embodiment_tag=libero_sim \
  --policy.push_to_hub=false \
  --policy.use_relative_actions=false \
  --policy.max_steps=20000 \
  --batch_size=320 \
  --steps=20000 \
  --save_freq=2000 \
  --env_eval_freq=0 \
  --eval_steps=0 \
  --log_freq=10 \
  --trackio.enable=true \
  --trackio.project=lerobot \
  --trackio.disable_artifact=true \
  --num_workers=4 \
  --prefetch_factor=2 \
  --persistent_workers=true \
  --output_dir=$OUTPUT_DIR \
  --job_name=$JOB_NAME
```

Esto seguirá la receta que se encuentra [aquí](https://github.com/NVIDIA/Isaac-GR00T/blob/main/examples/LIBERO/README.md).

### Resultados de LIBERO de GR00T N1.7

Resultados preliminares de la integración de LeRobot (GR00T-LeRobot, `eval.n_episodes >= 50` por suite):

| Suite            | Tasa de éxito | Checkpoint                                                                                                    |
| ---------------- | -----------: | ------------------------------------------------------------------------------------------------------------- |
| LIBERO Espacial   |          95% | [nvidia/gr00t17-lerobot-libero_spatial-640](https://huggingface.co/nvidia/gr00t17-lerobot-libero_spatial-640) |
| LIBERO Object    |         100% | [nvidia/gr00t17-lerobot-libero_object-640](https://huggingface.co/nvidia/gr00t17-lerobot-libero_object-640)   |
| Objetivo de LIBERO      |          98% | [nvidia/gr00t17-lerobot-libero_goal-640](https://huggingface.co/nvidia/gr00t17-lerobot-libero_goal-640)       |
| LIBERO 10 (Largo) |          93% | [nvidia/gr00t17-lerobot-libero_10-640](https://huggingface.co/nvidia/gr00t17-lerobot-libero_10-640)           |
| **Promedio**      |    **96.5%** |                                                                                                               |

```bash
export MODEL_ID=your_trained_model_on_huggingface

lerobot-eval \
  --policy.path=$MODEL_ID \
  --policy.embodiment_tag=libero_sim \
  --env.type=libero \
  --env.task=libero_spatial \
  --eval.n_episodes=50
```

Use `eval.n_episodes >= 50` por suite al informar las tasas de éxito.

### Evaluar en su configuración de hardware

Una vez que hayas entrenado tu modelo usando tus parámetros, puedes ejecutar inferencia en tu tarea de destino. Sigue las instrucciones en [Policy Deployment (lerobot-rollout)](./inference). Por ejemplo:

```bash
# install extra deps for roullout and real hardware
pip install "lerobot[feetech,viz]"

export MODEL_ID=your_trained_model_on_huggingface

# make sure that camera index matches your setup!
# find index using `uv run lerobot-find-cameras opencv`
WRIST_CAM='wrist: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30, fourcc: "MJPG"}'
FRONT_CAM='front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}'
export ROBOT_CAMERAS="{ $WRIST_CAM, $FRONT_CAM }"
export ROBOT_ID=follower_robot
export ROBOT_PORT=/dev/ttyACM0

# Set --inference.rtc.enabled=False if RTC causes inference instability
uv run lerobot-rollout \
  --strategy.type=base \
  --policy.path=$MODEL_ID \
  --policy.base_model_path=nvidia/GR00T-N1.7-3B \
  --policy.n_action_steps=8 \
  --robot.type=so101_follower \
  --robot.port=$ROBOT_PORT \
  --robot.id=$ROBOT_ID \
  --robot.cameras="$ROBOT_CAMERAS" \
  --task="place the vial in the rack" \
  --duration=60 \
  --device=cuda \
  --display_data=true \
  --inference.type=rtc \
  --inference.rtc.enabled=True \
  --inference.rtc.execution_horizon=8 \
  --inference.queue_threshold=0
```

> [!NOTE]
> El valor de `inference.queue_threshold` no debe superar 5 para garantizar una inferencia estable.

## Licencia

GR00T N1.7 se publica bajo el [NVIDIA Open Model License Agreement](https://www.nvidia.com/en-us/agreements/enterprise-software/nvidia-open-model-license/).

