Cómo ajustar la OpenVLA en su propio conjunto de datos de robots
LoRA afinado de OpenVLA-7B en su propio conjunto de datos de robot RLDS. tamaño de GPU, configuración PEFT, cargador de datos, bucle de entrenamiento y evaluación en menos de 3 horas.
OpenVLA-7B es el modelo de acción de lenguaje de visión abierto más popular. Este tutorial recorre la configuración de datos de RLDS basado en LoRA: tamaño de hardware, configuración de PEFT, configuración de cargador de datos, entrenamiento y evaluación en un episodio prolongado o en el robot real.
VLA / ajuste fino Tiempo total: aproximadamente 3 horas (más tiempo de entrenamiento) Dificultad: Avanzado Actualizado abril 2026
Lo que lograrás
Al final de este tutorial tendrás un punto de control OpenVLA-7B afinado con LoRA que se especialice en tu tarea y tu realización. LoRA (Low-Rank Adaptation) es la opción correcta para la mayoría de los equipos: reduce los requisitos de VRAM de ~ 100 GB para el ajuste fino completo a aproximadamente 24 GB, converge rápidamente en conjuntos de datos modestos (pocas cientos de episodios) y produce un pequeño adaptador que es fácil de distribuir.
OpenVLA es mantenido por el Stanford IRIS Lab y sus colaboradores. El modelo base 7B fue preentrenado en Open X-Embodiment, un conjunto de datos de casi un millón de trayectorias en 22 realizaciones.
Pre-requisitos
- Una GPU VRAM de 24 GB +. A100 40/80 GB, H100, RTX 4090, o L40S funcionan todos. RTX 3090 con 24 GB funciona pero es apretado.
- Un conjunto de datos RLDS de al menos 50 episodios (200+ recomendados) con observaciones de imágenes, propriocepción e instrucciones de tareas en lenguaje natural.
- Conocimiento con PyTorch, transformadores HuggingFace y aprendizaje de imitación.
- Ubuntu 22.04 o 20.04 con controladores CUDA 12.1+.
- 200 GB de disco libre para los pesos del modelo, los puntos de control y su conjunto de datos.
Si aún no tiene un conjunto de datos, vaya a recoger uno primero
Los pasos
Compruebe el hardware y el entorno
Verifique su GPU y CUDA:
```
nvidia-smi
python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0), torch.version.cuda)"
```
Si quieres
```
conda create -n openvla python=3.10 -y
conda activate openvla
```
Instalar OpenVLA y dependencias
Instalar la base de código OpenVLA y la pila PEFT. Consulte el repo en aguas arriba en github.com/openvla/openvla para el objetivo de instalación más actual
```
git clone https://github.com/openvla/openvla.git
cd openvla
pip install -e .
pip install peft bitsandbytes accelerate wandb
```
PEFT proporciona la implementación de LoRA. bitsandbytes le da una cuantización de 8 bits para el modelo base para que encaje en 24 GB.
Prepara tu conjunto de datos en formato RLDS
OpenVLA consume RLDS (Reinforcement Learning Datasets)
Si sus datos ya están en LeRobot o HDF5, debe convertirlos. El repositorio Open X-Embodiment incluye convertidores de referencia que puede adaptar. Un constructor RLDS mínimo se parece a:
```
import tensorflow_datasets as tfds
class MyRobotDataset(tfds.core.GeneratorBasedBuilder):
VERSION = tfds.core.Version('1.0.0')
def _info(self):
return tfds.core.DatasetInfo(
builder=self,
features=tfds.features.FeaturesDict({
'steps': tfds.features.Dataset({
'observation': tfds.features.FeaturesDict({
'image': tfds.features.Image(shape=(224, 224, 3)),
'state': tfds.features.Tensor(shape=(7,), dtype=tf.float32),
}),
'action': tfds.features.Tensor(shape=(7,), dtype=tf.float32),
'language_instruction': tfds.features.Text(),
'is_terminal': tfds.features.Scalar(dtype=tf.bool),
}),
})
)
```
Indique este constructor a sus archivos de episodios y registre el nombre del conjunto de datos en la configuración del conjunto de datos OpenVLA. Las estadísticas de normalización de acción (media / std por dimensión) deben ser calculadas y almacenadas
- Descarga los pesos de base de OpenVLA-7B
Retira el modelo base de HuggingFace Hub:
```
huggingface-cli download openvla/openvla-7b --local-dir ./openvla-7b
```
Esto es de aproximadamente 15 GB. Opcionalmente, guardarlo en caché bajo
- Configurar LoRA
El punto de partida predeterminado para OpenVLA es el rango LoRA 32 dirigido a los módulos de atención.
```
from peft import LoraConfig, get_peft_model
lora_config = LoraConfig(
r=32,
lora_alpha=16,
target_modules="all-linear",
lora_dropout=0.0,
bias="none",
task_type="CAUSAL_LM",
)
```
El rango 32 es un estándar razonable para 50 a 500 episodios. Baja a 16 si VRAM es apretado; aumento a 64 para conjuntos de datos más grandes.
Lanza el ajuste fino
Utilice el guión de referencia finetune del repo OpenVLA. El punto de entrada exacto se mueve a través de las versiones
```
torchrun --standalone --nnodes 1 --nproc-per-node 1 \
vla-scripts/finetune.py \
--vla_path ./openvla-7b \
--data_root_dir /path/to/rlds \
--dataset_name my_robot_dataset \
--run_root_dir ./runs \
--adapter_tmp_dir ./adapter-tmp \
--lora_rank 32 \
--batch_size 16 \
--grad_accumulation_steps 1 \
--learning_rate 5e-4 \
--image_aug True \
--wandb_project openvla-finetune
```
En un solo A100 de 80 GB, espera aproximadamente 1 hora por 10k pasos. Un conjunto de datos típico de 200 episodios converge en 20 a 40k pasos.
Punta: habilitar
Monitorear el entrenamiento
Observe tres señales en WandB o tensorboard: action MSE (su pérdida primaria), gradiente norma (debe ser estable, no picando), y acurateza de acción por dimensión (acurateza de token para la cabeza de acción tokenizada). Si la acción MSE es superior a 0,1 después de 5k pasos, su conjunto de datos es demasiado pequeño o sus instrucciones de lenguaje no coinciden con la distribución de formación de la cabeza de política.
Fusión de LoRA y evaluar
Al final de la formación, fusionar el adaptador LoRA en el modelo base para una inferencia más rápida:
```
from peft import PeftModel
from transformers import AutoModelForVision2Seq
base = AutoModelForVision2Seq.from_pretrained('./openvla-7b', torch_dtype=torch.bfloat16)
model = PeftModel.from_pretrained(base, './runs/my_robot_dataset/adapter')
merged = model.merge_and_unload()
merged.save_pretrained('./openvla-7b-my-robot')
```
Ahora evalúa: ejecuta el modelo fusionado en un episodio prolongado y compara las acciones predichas con la verdad de la tierra, o despliega al robot real y mide la tasa de éxito de tareas en 20 ensayos. Para los despliegues de robots reales, utiliza el envoltorio de inferencia OpenVLA que maneja el preprocesamiento de imágenes y la desnormalización de acciones para ti.
¿Qué hacer ahora?
Una vez que un adaptador LoRA funcione, tres seguimientos naturales: (1) escalar a más datos
Si su conjunto de datos fue recogido con LeRobot, nuestro tutorial de grabación de LeRobot cubre el lado de captura. Para las tareas bimanual, vea el tutorial de equipo de teleop de ALOHA.
Modo de falla común
OOM en arranque: habilitar la cuantificación de 8 bits con
** MSE de acción no disminuye:** comprobar que sus estadísticas de normalización de acción son correctas.
La política lleva al robot a límites conjuntos: La distribución de instrucciones de idiomas en su conjunto de datos es demasiado estrecha; el modelo memorizado en lugar de aprendido.
La inferencia es lenta: siempre se ejecuta con
Mergullo profundo: LoRA vs. tono fino completo vs. desde cero
Tres opciones se sitúan en el espectro. ** Full fine-tune** actualiza todos los parámetros del modelo 7B. Normalmente produce la mejor tasa de éxito de tarea cuando tienes suficientes datos (500+ episodios) y una GPU de 80 GB, porque el modelo puede adaptar cada representación a tu realización. ** LoRA** agrega adaptadores de bajo rango a un subconjunto de capas, congela la base y converge rápidamente en conjuntos de datos más pequeños. En nuestros experimentos con conjuntos de datos de manipulación de tamaño medio, LoRA alcanza el 90 al 95 por ciento del rendimiento de ajuste fino completo en una cuarta parte del cálculo. ** Desde cero** casi nunca tiene sentido para los modelos a escala VLA
Un cuarto camino que ha estado ganando tracción es ** DoRA** (Adaptación de bajo rango descompuesto por peso), que descomponen los pesos en componentes de magnitud y dirección. DoRA agrega una pequeña cantidad de parámetro sobre el LoRA y a menudo cierra la brecha para ajustar aún más. PEFT admite DoRA fuera de la caja
Inmersión profunda: la calidad del conjunto de datos supera el tamaño del conjunto de datos
Los equipos invierten constantemente en exceso en el conteo de episodios y sub-invierten en la diversidad de episodios. 200 episodios en 20 variaciones de iluminación y posición de objetos superan a 1000 episodios de la misma escena. La razón es modelo-teórica: el ajuste fino de VLA no es principalmente aprender qué hacer
Una receta concreta que funciona: dentro de sus 200 episodios, varía la posición inicial del objeto en una cuadrícula de 20 cm x 20 cm (10 posiciones mínimas), registra bajo 3 condiciones de iluminación y gira a través de 5 frases en lenguaje natural de la misma instrucción. Esto es aproximadamente un 50% más de trabajo durante la recopilación, pero mejora dramáticamente la afinidad.
Mergullo profundo: la evaluación es donde los equipos se equivocan
El error más común es evaluar sólo los episodios prolongados de la misma sesión de grabación. La evaluación real tiene tres niveles: (1) ** retrasado de la misma sesión**
Preguntas frecuentes
Cuántos episodios necesito? 50 es un mínimo para resultados no triviales. 200 es un buen objetivo. 500+ satura la capacidad de LoRA para la mayoría de las tareas individuales.
** ¿Puedo ajustar los datos de múltiples tareas? ** Sí, y por lo general ayuda. La columna vertebral 7B OpenVLA tiene espacio para absorber múltiples tareas por adaptador.
Pi-Zero es la VLA de la inteligencia física que coincide con el flujo de la receta de entrenamiento diferente, a menudo con una tasa de éxito más alta por episodio, pero requiere pesos patentados. Octo es un modelo abierto más pequeño útil para la investigación. Ver nuestra comparación de modelos VLA.
La latencia de la inferencia es importante para mi aplicación. La inferencia de OpenVLA-7B es de aproximadamente 200 ms en un solo A100. Si eso es demasiado lento, mire las estrategias de VLA, cuantización o acción.