EVO1

EVO1 es una política de Visión-Lenguaje-Acción para el control de robots, construida en torno a un backbone de InternVL3 y una cabeza de acción de flow-matching continuo. Esta integración de LeRobot expone EVO1 como un tipo de política estándar, de modo que puede entrenarse y evaluarse con las APIs habituales de conjuntos de datos, puntos de control y procesadores de LeRobot.

Resumen del modelo

La política incrusta una o más imágenes de cámara y el prompt de la tarea de lenguaje con InternVL3, rellena los vectores de estado/acción del robot hasta dimensiones máximas fijas y predice fragmentos de acciones futuras con una cabeza de acción de flow-matching. Durante la inferencia, la política muestrea un fragmento de acciones y devuelve n_action_steps acciones de ese fragmento antes de volver a muestrear.

Lo que abarca la integración de LeRobot

• Configuración estándar policy.type=evo1 a través de LeRobot
• Embedding de imagen/texto de InternVL3 con respaldo opcional de FlashAttention
• Controles de ajuste fino por etapas para ejecuciones de ajuste fino solo de la cabeza de acción y de VLM
• Predicción de acciones mediante flujo continuo
• Guardado y carga de puntos de control a través de las APIs de políticas de LeRobot
• Entrenamiento con lerobot-train y evaluación con las APIs estándar de inferencia de políticas

El proyecto EVO1 más amplio puede incluir scripts de entrenamiento adicionales y herramientas de conjuntos de datos. Esta página se centra en la ruta de la política de control de robots de LeRobot.

Requisitos de instalación

1. Instala LeRobot siguiendo la Guía de instalación.

2. Instale las dependencias de EVO1:

   Copiado

   pip install -e ".[training,evo1]"

   Para el entrenamiento y la evaluación de LIBERO, instale también el extra de LIBERO:

   Copiado

   pip install -e ".[training,evo1,libero]"

3. Instale una rueda de flash-attn solo si es compatible con su pila de Python, PyTorch, CUDA y GPU. EVO1 recurre a la atención estándar cuando flash_attn no está disponible.

EVO1 utiliza la implementación nativa de InternVL de transformers de Hugging Face, por lo que policy.vlm_model_name debe apuntar a un checkpoint convertido de forma nativa, como OpenGVLab/InternVL3-1B-hf (fíjese en el sufijo -hf). La primera ejecución descarga el checkpoint del VLM configurado y las ejecuciones posteriores lo reutilizan desde la caché de Hugging Face.

Requisitos de datos

EVO1 espera un conjunto de datos de LeRobot con:

• De uno a policy.max_views observaciones visuales, por ejemplo observation.images.image
• observation.state
• action
• Una instrucción de tarea de lenguaje en el campo task del conjunto de datos, o en otro campo configurado con policy.task_field

Los vectores de estado y acción se rellenan hasta policy.max_state_dim y policy.max_action_dim. Las predicciones se recortan de nuevo a la dimensión de acción del conjunto de datos antes de ser devueltas.

Uso

Para usar EVO1 en una configuración de LeRobot, especifique:

policy.type=evo1

Por defecto, una nueva política de EVO1 inicializa su VLM desde:

policy.vlm_model_name=OpenGVLab/InternVL3-1B-hf

Una vez que esté disponible un punto de control EVO1 en formato LeRobot, cárguelo con:

policy.path=your-org/your-evo1-checkpoint

Entrenamiento

Etapa 1

La etapa 1 congela el VLM y entrena la cabeza de acción:

lerobot-train \
  --dataset.repo_id=your_org/your_dataset \
  --policy.type=evo1 \
  --policy.training_stage=stage1 \
  --policy.vlm_model_name=OpenGVLab/InternVL3-1B-hf \
  --policy.device=cuda \
  --policy.chunk_size=50 \
  --policy.n_action_steps=50 \
  --policy.max_state_dim=24 \
  --policy.max_action_dim=24 \
  --policy.optimizer_lr=1e-5 \
  --batch_size=4 \
  --steps=5000 \
  --output_dir=./outputs/evo1_stage1

Etapa 2

La etapa 2 carga la política de la etapa 1, pero inicia un optimizador y un programador nuevos:

lerobot-train \
  --dataset.repo_id=your_org/your_dataset \
  --policy.path=./outputs/evo1_stage1/checkpoints/005000/pretrained_model \
  --policy.training_stage=stage2 \
  --policy.vlm_model_name=OpenGVLab/InternVL3-1B-hf \
  --policy.device=cuda \
  --policy.chunk_size=50 \
  --policy.n_action_steps=50 \
  --policy.max_state_dim=24 \
  --policy.max_action_dim=24 \
  --policy.optimizer_lr=1e-5 \
  --batch_size=4 \
  --steps=80000 \
  --output_dir=./outputs/evo1_stage2

Por defecto, policy.training_stage reaplica los valores predeterminados de ajuste fino para esa etapa. Esto es importante al iniciar la Etapa 2 desde un punto de control de la Etapa 1, porque la configuración del punto de control de la Etapa 1 almacena las banderas de ajuste fino del VLM como deshabilitadas. Estos valores predeterminados de etapa tienen prioridad sobre las banderas policy.finetune_* guardadas o proporcionadas manualmente, a menos que policy.apply_training_stage_defaults=false, por lo que establezca esa bandera solo cuando controle manualmente cada bandera de ajuste fino.

Parámetros clave de entrenamiento

Inferencia

Pruébalo con un punto de control de EVO1 entrenado:

# --inference.type=rtc is optional
lerobot-rollout \
  --policy.path=your-org/your-evo1-checkpoint \
  --inference.type=rtc \
  ...

Resultados

Evaluación de LIBERO

Resultado de referencia

El checkpoint de Stage-2 publicado pasó la verificación de descarga limpia y de rollout: zuoxingdong/evo1_libero, revisión 515921f4a2c1d3f3ad523721eafa26fdf2af315b. La evaluación de descarga limpia utilizó la revisión de LeRobot e40b58a8dfa9e7b86918c374791599d070518d11.

El punto de control de la etapa 2 de una sola ejecución en el paso 70.000 produjo:

Estos resultados utilizan un único punto de control entrenado y una semilla de evaluación 1000; no son una media de varias semillas ni una estimación de confianza.

Receta de entrenamiento de referencia

El checkpoint publicado registra la configuración completa y resuelta de la Etapa 2 en train_config.json. La ejecución medida utilizó dos GPU H100 con dos procesos DDP y un batch de 64 por proceso, lo que da un batch global de 128. Ambas etapas utilizaron la misma topología. El VLM base provenía de la revisión 014c0583a0d4bedf29fbe2dbff4f865eb998e171 de OpenGVLab/InternVL3-1B-hf. El artefacto publicado no registra el commit exacto de entrenamiento de LeRobot ni su bloqueo de dependencias original, por lo que los comandos siguientes reproducen la configuración y la topología registradas desde un checkout actual, en lugar de reconstruir el entorno de software bit a bit.

Desde un checkout de la fuente de LeRobot, instale las dependencias bloqueadas y descargue esa revisión exacta del VLM:

uv sync --locked --extra training --extra evo1 --extra libero
VLM_DIR=$(uv run hf download OpenGVLab/InternVL3-1B-hf \
  --revision=014c0583a0d4bedf29fbe2dbff4f865eb998e171)

La etapa 1 congela el VLM y entrena la cabeza de acciones durante 5.000 pasos:

uv run accelerate launch --num_processes=2 -m lerobot.scripts.lerobot_train \
  --dataset.repo_id=lerobot/libero \
  --dataset.revision=a1aaacb7f6cd6ee5fb43120f673cebb0cfea7dd4 \
  --dataset.video_backend=torchcodec \
  --dataset.return_uint8=true \
  --dataset.image_transforms.enable=true \
  --dataset.use_imagenet_stats=true \
  --dataset.eval_split=0.0 \
  --policy.type=evo1 \
  --policy.training_stage=stage1 \
  --policy.apply_training_stage_defaults=true \
  --policy.vlm_model_name="${VLM_DIR}" \
  --policy.vlm_num_layers=14 \
  --policy.dtype=bfloat16 \
  --policy.device=cuda \
  --policy.use_amp=true \
  --policy.use_flash_attn=true \
  --policy.enable_gradient_checkpointing=true \
  --policy.gradient_checkpointing_use_reentrant=false \
  --policy.image_resolution='[448,448]' \
  --policy.chunk_size=50 \
  --policy.n_action_steps=50 \
  --policy.max_state_dim=24 \
  --policy.max_action_dim=24 \
  --policy.dropout=0.2 \
  --policy.optimizer_lr=1e-5 \
  --policy.optimizer_weight_decay=1e-3 \
  --policy.optimizer_grad_clip_norm=1.0 \
  --policy.scheduler_warmup_steps=1000 \
  --policy.push_to_hub=false \
  --use_policy_training_preset=true \
  --batch_size=64 \
  --steps=5000 \
  --save_checkpoint=true \
  --save_checkpoint_to_hub=false \
  --save_freq=2500 \
  --log_freq=10 \
  --env_eval_freq=0 \
  --num_workers=4 \
  --prefetch_factor=2 \
  --persistent_workers=true \
  --seed=1000 \
  --trackio.enable=false \
  --output_dir=./outputs/evo1-libero-stage1-g128-5k

La etapa 2 carga la política de la etapa 1, pero inicia un optimizador y un programador nuevos. Se entrena durante 80.000 pasos; el punto de control reportado es el guardado en el paso 70.000:

uv run accelerate launch --num_processes=2 -m lerobot.scripts.lerobot_train \
  --dataset.repo_id=lerobot/libero \
  --dataset.revision=a1aaacb7f6cd6ee5fb43120f673cebb0cfea7dd4 \
  --dataset.video_backend=torchcodec \
  --dataset.return_uint8=true \
  --dataset.image_transforms.enable=true \
  --dataset.use_imagenet_stats=true \
  --dataset.eval_split=0.0 \
  --policy.path=./outputs/evo1-libero-stage1-g128-5k/checkpoints/005000/pretrained_model \
  --policy.training_stage=stage2 \
  --policy.apply_training_stage_defaults=true \
  --policy.vlm_model_name="${VLM_DIR}" \
  --policy.vlm_num_layers=14 \
  --policy.dtype=float32 \
  --policy.device=cuda \
  --policy.use_amp=true \
  --policy.use_flash_attn=true \
  --policy.enable_gradient_checkpointing=true \
  --policy.gradient_checkpointing_use_reentrant=false \
  --policy.image_resolution='[448,448]' \
  --policy.chunk_size=50 \
  --policy.n_action_steps=50 \
  --policy.max_state_dim=24 \
  --policy.max_action_dim=24 \
  --policy.dropout=0.2 \
  --policy.optimizer_lr=1e-5 \
  --policy.optimizer_weight_decay=1e-3 \
  --policy.optimizer_grad_clip_norm=1.0 \
  --policy.scheduler_warmup_steps=1000 \
  --policy.push_to_hub=false \
  --use_policy_training_preset=true \
  --batch_size=64 \
  --steps=80000 \
  --resume=false \
  --save_checkpoint=true \
  --save_checkpoint_to_hub=false \
  --save_freq=10000 \
  --log_freq=10 \
  --env_eval_freq=0 \
  --num_workers=4 \
  --prefetch_factor=2 \
  --persistent_workers=true \
  --seed=1000 \
  --trackio.enable=false \
  --output_dir=./outputs/evo1-libero-stage2-g128-80k

Perfil de evaluación de formato de autor

El perfil EVO1 LIBERO en formato de autor utiliza los nombres de características de cámara crudos de LIBERO (observation.images.agentview_image y observation.images.robot0_eye_in_hand_image), replanifica cada 14 acciones y binariza el comando del agarre antes de avanzar el simulador. El postprocesador de la política EVO1 puede recortar la acción rellena de 24D al espacio de acciones de 7D de LIBERO y aplicar esa binarización del agarre. Para evaluar un punto de control en formato de autor bajo la misma configuración de un episodio por tarea, mantenga los nombres de cámara crudos en lugar del mapeo predeterminado image/image2 y establezca las banderas de postprocesamiento de acciones de LIBERO:

lerobot-eval \
  --policy.path=your-org/your-evo1-libero-checkpoint \
  --policy.vlm_model_name=OpenGVLab/InternVL3-1B-hf \
  --policy.device=cuda \
  --policy.use_flash_attn=true \
  --policy.n_action_steps=14 \
  --policy.postprocess_action_dim=7 \
  --policy.binarize_gripper=true \
  --env.type=libero \
  --env.task=libero_object \
  --env.camera_name_mapping="{agentview_image: agentview_image, robot0_eye_in_hand_image: robot0_eye_in_hand_image}" \
  --env.observation_height=448 \
  --env.observation_width=448 \
  --eval.batch_size=1 \
  --eval.n_episodes=1

Perfil nativo de lerobot/libero v3

La revisión a1aaacb7f6cd6ee5fb43120f673cebb0cfea7dd4 almacena las características de la cámara como image y image2. Este ejemplo evalúa las diez tareas de LIBERO Object, lanzando cada tarea en un proceso nuevo:

export MUJOCO_GL=egl
export PYOPENGL_PLATFORM=egl

suite=libero_object
horizon=280
for task_id in {0..9}; do
  lerobot-eval \
    --policy.path=zuoxingdong/evo1_libero \
    --policy.pretrained_revision=515921f4a2c1d3f3ad523721eafa26fdf2af315b \
    --policy.vlm_model_name=OpenGVLab/InternVL3-1B-hf \
    --policy.device=cuda \
    --policy.use_amp=true \
    --policy.dtype=bfloat16 \
    --policy.use_flash_attn=false \
    --policy.enable_gradient_checkpointing=false \
    --policy.vlm_num_layers=14 \
    --policy.image_resolution='[448,448]' \
    --policy.max_text_length=1024 \
    --policy.chunk_size=50 \
    --policy.n_action_steps=14 \
    --policy.max_state_dim=24 \
    --policy.max_action_dim=24 \
    --policy.num_inference_timesteps=32 \
    --policy.postprocess_action_dim=7 \
    --policy.binarize_gripper=true \
    --policy.gripper_threshold=0.0 \
    --policy.gripper_below_threshold_value=-1.0 \
    --policy.gripper_above_threshold_value=1.0 \
    --env.type=libero \
    --env.task="${suite}" \
    --env.task_ids="[${task_id}]" \
    --env.camera_name=agentview_image,robot0_eye_in_hand_image \
    --env.camera_name_mapping="{agentview_image: image, robot0_eye_in_hand_image: image2}" \
    --env.control_mode=relative \
    --env.obs_type=pixels_agent_pos \
    --env.observation_width=448 \
    --env.observation_height=448 \
    --env.init_states=true \
    --env.episode_length="${horizon}" \
    --env.render_mode=rgb_array \
    --env.max_parallel_tasks=1 \
    --eval.n_episodes=50 \
    --eval.batch_size=1 \
    --eval.use_async_envs=false \
    --eval.recording=false \
    --seed=1000 \
    --output_dir="./outputs/evo1-libero-stage2-70k-eval/${suite}/task-${task_id}" \
    --job_name="evo1-libero-stage2-70k-${suite}-task-${task_id}"
done

Ejecuta los diez identificadores de tareas de cada suite con estos horizontes:

Establezca suite y horizon para cada fila. Esto proporciona 500 episodios por suite y 2.000 episodios en total, mientras que el proceso nuevo por tarea del bucle coincide con la topología de reinicio de RNG medida.

Referencias

• repositorio EVO1
• InternVL3-1B-hf

Licencia

Esta integración de LeRobot sigue la licencia Apache 2.0 utilizada por LeRobot. Consulte las páginas de los modelos EVO1 e InternVL3 de origen para conocer las licencias de los puntos de control y los datos publicados.