LeRobot documentation
Políticas
Políticas
Cada política hereda de PreTrainedPolicy, que combina un torch.nn.Module con el mixin de Hub, por lo que cualquier política puede subirse y cargarse desde el Hugging Face Hub con las mismas dos llamadas.
Cada política tiene su propia guía con recetas de entrenamiento y resultados: ACT, SmolVLA, π₀, π₀.₅ y el resto se enumeran en Políticas. Para añadir una, consulta Adding a Policy.
PreTrainedPolicy
Clase base para modelos de política.
Declara el contrato de autor de servicio de fragmentos de observación actual por defecto.
Heredar esta implementación declara que predict_action_chunk realiza toda la preparación necesaria para los llamadores directos, acepta la observación completa actual y devuelve [B, chunk_size, A] en coordenadas del modelo. Su par de procesadores canónicos debe admitir chunks completos. n_action_steps es la porción de reproducción ordinaria; RTC conserva el horizonte de predicción completo.
Una política que requiera preparación solo de select_action, otros diseños de acciones o muestreo temporal debe sobrescribir este método y rechazar las configuraciones no admitidas o proporcionar un ejecutor personalizado. La presencia del método o un warmup exitoso no son evidencia de este contrato. El estado de la política/procesador solo está permitido dentro de una sesión exclusiva y reset() debe limpiarlo para una nueva ejecución.
Número de acciones ya calculadas y a la espera de ser servidas.
0 para una política que no mantiene ninguna cola de acciones (nunca fragmenta) o cuya cola está actualmente vacía (a punto de calcular un fragmento nuevo). Lee las mismas colas que drop_queued_actions limpia, denominadas en :attr:_action_queue_attrs.
Descarta las acciones precalculadas por llamadas anteriores a select_action.
Fuerza una nueva pasada hacia adelante en la siguiente select_action para que un cambio de condicionamiento a mitad de episodio (p. ej., una nueva instrucción) surta efecto de inmediato en lugar de después de que se vacíe la cola. A diferencia de reset, se conserva el resto del estado del episodio. Llámalo desde el hilo que invoca select_action. Limpia las colas especificadas en :attr:_action_queue_attrs; una política que no conserve ninguna cola de acciones hereda una operación sin efecto.
forward
< source >( batch: dict[str, Tensor] ) → tuple[Tensor, dict | None]
resumen
from_pretrained
< source >( pretrained_name_or_path: str | Pathconfig: PreTrainedConfig | None = Noneforce_download: bool = Falseresume_download: bool | None = Noneproxies: dict | None = Nonetoken: str | bool | None = Nonecache_dir: str | Path | None = Nonelocal_files_only: bool = Falserevision: str | None = Nonestrict: bool = False**kwargs )
La política se establece en modo de evaluación de forma predeterminada mediante policy.eval() (los módulos de dropout se desactivan). Para entrenarla, primero debe volver a establecerla en modo de entrenamiento con policy.train().
Ejecuta la cabeza de texto de la política en un lote de observaciones preprocesadas.
La solicitud viaja en batch como datos complementarios (:data:~lerobot.utils.constants.QUERY_KIND / QUERY_TEXT); una respuesta de next_subtask se introduce directamente en set_task, por lo que debe ser
exactamente un subtask, no un plan ni una lista numerada. Devuelve el texto generado y no debe
mutar el estado que produce acciones (colas, historial de observaciones).
Devuelve los parámetros específicos de la política (parámetros o grupos de parámetros) que se deben pasar al optimizador.
Devuelve el trozo de acciones (para políticas de troceado de acciones) para una observación dada, posiblemente en modo por lotes.
Las clases hijas que utilizan la segmentación de acciones deben usar este método dentro de select_action para formar el trozo de acciones que se almacena en caché para la selección.
Una política que admite la palabra clave noise inicia su muestreo desde ese tensor, con la forma que la política le asignaría. Cuando noise es None, la política lo genera de la forma habitual.
Puede devolver un PolicyOutput que contenga el fragmento y su predicción, como en select_action.
push_model_to_hub
< source >( cfg: TrainPipelineConfigpeft_model = Nonestate_dict: dict[str, Tensor] | None = Nonedataset_meta: LeRobotDatasetMetadata | None = None )
Parámetros
- cfg (TrainPipelineConfig) — La configuración de entrenamiento; se guarda como train_config.json y se utiliza para generar la tarjeta del modelo.
- peft_model — El envoltorio de PEFT al entrenar adaptadores, cuyos pesos reemplazan los pesos del modelo completo en el repositorio publicado. El valor predeterminado es None.
- state_dict (dict[str, Tensor] | None) — Se ignora; los pesos ahora se recogen internamente cuando la política está fragmentada. El valor predeterminado es None.
- dataset_meta (LeRobotDatasetMetadata | None) — Metadatos del conjunto de datos para la tarjeta del modelo, si están disponibles. El valor predeterminado es None.
Publica esta política en el Hub.
Obsoleto: use lerobot.common.train_utils.publish_trained_model() en su lugar, que también publica los pre/post-procesadores junto con el modelo.
Se llamará cada vez que el entorno se reinicie.
Realiza tareas como la limpieza de cachés.
Devuelve una acción para ejecutar en el entorno (posiblemente en modo por lotes).
Cuando el modelo utiliza un historial de observaciones o genera una secuencia de acciones, este método se encarga del almacenamiento en caché.
Devuelve un tensor de acción simple o un PolicyOutput: un lote, con claves como el lote de entrada, que contiene la acción bajo "action" y lo que la política espera o cree además de ella bajo "prediction" (un PolicyPrediction). La predicción se lotea como la acción, con un valor por entorno, y cada entrada se clavea según a lo que se refiere: los fotogramas predichos por la clave de observación que predicen, el lenguaje por estilo de anotación (“subtask”, “plan”, “memory”), y las cajas (esquema VQA de anotación) por la cámara en la que se dibujan. Los llamadores normalizan los dos tipos de retorno con lerobot.processor.policy_output_to_transition; —display_data muestra la predicción del primer entorno.
Una predicción contiene valores para este paso: uno que abarca un fragmento (p. ej., un clip imaginado) se devuelve por partes, junto con la acción a la que pertenece cada parte. Cada entrada permanece visible hasta que se devuelve de nuevo. La predicción es opcional a través de un campo de configuración a elección de la política, y no debe modificar las acciones; el texto que debe guiar la política se pasa a través de generate_text.
Si esta política implementa la semántica de inferencia de Real-Time Chunking.
Si esta política implementa generate_text (sobrescribir ambos juntos).
Validar las entradas canónicas antes de servir, con formas exactas de forma predeterminada.
Las políticas que redimensionan o enmascaran explícitamente las entradas faltantes pueden invalidar este contrato. Dichas excepciones deben pertenecer a la política, nunca al transporte. El esquema de cable negociado sigue fijando la forma de cada característica proporcionada.
wrap_with_peft
< source >( peft_config = Nonepeft_cli_overrides: dict | None = None )
Parámetros
- peft_config — Configuración opcional del adaptador PEFT (p. ej., LoraConfig). Si se proporciona, se usa directamente (con las superposiciones de la CLI aplicadas).
- peft_cli_overrides — Diccionario opcional de reemplazos de CLI (method_type, target_modules, r, etc.) Estos se combinan con los valores predeterminados de la política para construir la configuración final.
Envuelva esta política con adaptadores PEFT para el ajuste fino eficiente de parámetros.
Este método es el único punto de entrada para la integración de PEFT. Las subclases deben sobrescribir _get_default_peft_targets() para proporcionar los módulos objetivo predeterminados, y _validate_peft_config() para la validación específica de la política.
PreTrainedConfig
clase lerobot.configs.PreTrainedConfig
< source >( n_obs_steps: int = 1input_features: dict[str, lerobot.configs.types.PolicyFeature] | None = <factory>output_features: dict[str, lerobot.configs.types.PolicyFeature] | None = <factory>device: str | None = Nonedtype: torch.dtype | None = Noneuse_amp: bool = Falseuse_peft: bool = Falsepush_to_hub: bool = Truerepo_id: str | None = Noneprivate: bool | None = Nonetags: list[str] | None = Nonelicense: str | None = Nonepretrained_path: pathlib.Path | None = Nonepretrained_revision: str | None = None )
Parámetros
- n_obs_steps — Número de pasos del entorno de observaciones que se pasan a la política (toma el paso actual y pasos adicionales hacia atrás).
- input_features — Un diccionario que define la PolicyFeature de los datos de entrada para la política. La clave representa el nombre de los datos de entrada y el valor es PolicyFeature, que consiste en los atributos FeatureType y shape.
- output_features — Un diccionario que define la PolicyFeature de los datos de salida para la política. La clave representa el nombre de los datos de salida y el valor es PolicyFeature, que consiste en los atributos FeatureType y shape.
- normalization_mapping — Un diccionario que mapea desde un valor str de FeatureType (p. ej., “STATE”, “VISUAL”) a un NormalizationMode correspondiente (p. ej., NormalizationMode.MIN_MAX)
Clase de configuración base para modelos de política.
make_policy
lerobot.policies.make_policy
< source >( cfg: PreTrainedConfigds_meta: LeRobotDatasetMetadata | None = Noneenv_cfg: EnvConfig | None = Nonerename_map: dict[str, str] | None = Nonedefer_weight_load: bool = Falsepretrained_path: str | Path | None = None ) → PreTrainedPolicy
Parámetros
- cfg (PreTrainedConfig) — La configuración de la política que se va a crear. Si
cfg.pretrained_pathestá definido, la política se cargará con los pesos de esa ruta. - ds_meta (LeRobotDatasetMetadata | None) — Metadatos del conjunto de datos utilizados para inferir las formas y tipos de las características. También proporciona estadísticas para las capas de normalización.
- env_cfg (EnvConfig | None) — Configuración del entorno utilizada para inferir las formas y
tipos de las características. Debe proporcionarse uno de
ds_metaoenv_cfg. - rename_map (dict[str, str] | None) — Mapeo opcional de claves de características del conjunto de datos o del entorno para que coincidan con los nombres de características esperados de la política (p. ej.,
"left"→"camera1"). - defer_weight_load (bool) — Construye la política exacta que construiría
from_pretrained: misma resolución de configuración, mismos búferes derivados de estadísticas, mismo dispositivo y modo de evaluación, pero omite la carga de pesos de safetensors. Se utiliza al reanudar desde un punto de control de DCP, cuyos pesos fragmentados se cargan después deaccelerator.prepare()(el motor de puntos de control distribuidos sobrescribe la inicialización aleatoria). Para una política PEFT, solo se omiten los pesos del adaptador; los pesos base se cargan como de costumbre. - pretrained_path (str | Path | None) — Carga los pesos (o el adaptador PEFT) desde aquí en lugar de
cfg.pretrained_path, que mantiene el nombre del modelo del que se afinó la política una vez que esta se ha construido. Se utiliza al reanudar desde un punto de control.
Devuelve
PreTrainedPolicy
Un modelo de política instanciado y colocado en el dispositivo.
Lanza
ValueError o NotImplementedError
ValueError— Si se proporcionan ambos o ninguno deds_metayenv_cfg.NotImplementedError— Si se intenta usar una combinación de política y backend no compatible (p. ej., VQBeT con ‘mps’).
Instanciar un modelo de política.
Esta función de fábrica gestiona la lógica para crear una política, lo que requiere determinar las formas de las características de entrada y salida. Estas formas pueden derivarse de un objeto LeRobotDatasetMetadata o de un objeto EnvConfig. La función puede inicializar una nueva política desde cero o cargar una preentrenada.