# Procesadores

Los procesadores son la capa de transformación de datos entre un robot, un conjunto de datos y una política. Un pipeline es una cadena de `ProcessorStep`s; cada paso declara cómo transforma tanto los datos como el contrato de características.

Consulte [Introducción a los procesadores de robots](../introduction_processors) para los conceptos, [Implemente su propio procesador](../implement_your_own_processor) para escribir un paso y [Depure su pipeline de procesadores](../debug_processor_pipeline) cuando un pipeline se comporte de manera inesperada.

## ProcessorStep[[lerobot.processor.ProcessorStep]]

#### lerobot.processor.ProcessorStep[[lerobot.processor.ProcessorStep]]

```python
lerobot.processor.ProcessorStep()
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L150)

Clase base abstracta para un paso individual en un pipeline de procesamiento de datos.

Cada paso debe implementar el método `__call__` para realizar su transformación en una transición de datos y el método `transform_features` para describir cómo modifica la forma o el tipo de las características de los datos.

Las subclases pueden ser opcionalmente con estado implementando `state_dict` y `load_state_dict`.

#### get_config[[lerobot.processor.ProcessorStep.get_config]]

```python
get_config()
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L193)

**Devuelve:**

Un diccionario serializable en JSON de parámetros de configuración.

Devuelve la configuración del paso para la serialización.

#### load_state_dict[[lerobot.processor.ProcessorStep.load_state_dict]]

```python
load_state_dict(state: dict[str, torch.Tensor])
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L209)

**Parámetros:**

state : Un diccionario de tensores de estado.

Carga el estado del paso desde un diccionario de estado.

#### reset[[lerobot.processor.ProcessorStep.reset]]

```python
reset()
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L221)

Restablece el estado interno del paso del procesador, si lo hay.

#### save_artifacts[[lerobot.processor.ProcessorStep.save_artifacts]]

```python
save_artifacts(save_directory: Path)
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L217)

Guarde los activos no tensoriales y mapee los argumentos del constructor a rutas relativas.

#### state_dict[[lerobot.processor.ProcessorStep.state_dict]]

```python
state_dict()
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L201)

**Devuelve:**

Un diccionario que mapea nombres de estado a tensores.

Devuelve el estado del paso (p. ej., parámetros aprendidos, medias en ejecución).

#### transform_features[[lerobot.processor.ProcessorStep.transform_features]]

```python
transform_features(features: dict[PipelineFeatureType, dict[str, PolicyFeature]])
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L225)

**Parámetros:**

features : Un diccionario que describe las características de entrada para observaciones, acciones, etc.

**Devuelve:**

Un diccionario que describe las características de salida después de la transformación de esta etapa.

Define cómo este paso modifica la descripción de las características del pipeline.

Este método se utiliza para rastrear los cambios en las formas de los datos, los dtypes o las modalidades a medida que los datos fluyen a través de la pipeline, sin necesidad de procesar datos reales.

## DataProcessorPipeline[[lerobot.processor.DataProcessorPipeline]]

#### lerobot.processor.DataProcessorPipeline[[lerobot.processor.DataProcessorPipeline]]

```python
lerobot.processor.DataProcessorPipeline(steps: Sequence[ProcessorStep] = <factory>, name: str = 'DataProcessorPipeline', to_transition: Callable[[TInput], EnvTransition] = <factory>, to_output: Callable[[EnvTransition], TOutput] = <factory>, before_step_hooks: list[Callable[[int, EnvTransition], None]] = <factory>, after_step_hooks: list[Callable[[int, EnvTransition], None]] = <factory>)
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L273)

**Parámetros:**

steps : Una secuencia de objetos `ProcessorStep` que componen la tubería.

name : Un nombre descriptivo para el pipeline.

to_transition : Una función para convertir los datos de entrada crudos al formato estandarizado `EnvTransition`.

to_output : Una función para convertir el `EnvTransition` final al formato de salida deseado.

before_step_hooks : Una lista de funciones que se llamarán antes de que se ejecute cada paso.

after_step_hooks : Una lista de funciones que se llamarán después de que se ejecute cada paso.

Un pipeline secuencial para el procesamiento de datos, integrado con el Hugging Face Hub.

Esta clase encadena múltiples instancias de `ProcessorStep` para formar un flujo de trabajo completo de procesamiento de datos. Es genérica, lo que permite tipos de entrada y salida personalizados, que son manejados por los convertidores `to_transition` y `to_output`.

#### from_config[[lerobot.processor.DataProcessorPipeline.from_config]]

```python
from_config(config: dict[str, Any], state_dict: dict[str, dict[str, torch.Tensor]] | None = None, overrides: dict[str, Any] | None = None, to_transition: Callable[[TInput], EnvTransition] | None = None, to_output: Callable[[EnvTransition], TOutput] | None = None)
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L792)

**Parámetros:**

config : Un diccionario de configuración con la misma estructura que el JSON del procesador guardado.

state_dict : Estado de pipeline en memoria opcional, agrupado por clave de estado sin sufijo.

overrides : Sobrescrituras opcionales del constructor indexadas por nombre de registro o nombre de clase.

to_transition : Convertidor opcional de los datos de entrada a `EnvTransition`.

to_output : Convertidor opcional de `EnvTransition` a datos de salida.

**Devuelve:**

Un pipeline de procesador construido a partir de la configuración y el estado opcional.

Construir un pipeline a partir de una configuración en memoria y tensores de estado opcionales.

#### from_pretrained[[lerobot.processor.DataProcessorPipeline.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | Path, config_filename: str, force_download: bool = False, resume_download: bool | None = None, proxies: dict[str, str] | None = None, token: str | bool | None = None, cache_dir: str | Path | None = None, local_files_only: bool = False, revision: str | None = None, overrides: dict[str, Any] | None = None, to_transition: Callable[[TInput], EnvTransition] | None = None, to_output: Callable[[EnvTransition], TOutput] | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L647)

**Parámetros:**

pretrained_model_name_or_path : El identificador del repositorio en el Hugging Face Hub, una ruta a un directorio local o una ruta a un archivo de configuración individual.

config_filename : El nombre del archivo de configuración JSON del pipeline. Siempre es obligatorio para evitar ambigüedad cuando existen varias configuraciones (p. ej., preprocesador vs. posprocesador).

force_download : Si se debe forzar la (re)descarga de los archivos.

resume_download : Se mantiene por compatibilidad con versiones anteriores y se ignora. Las descargas se reanudan automáticamente.

proxies : Se mantiene por compatibilidad con versiones anteriores y se ignora. Use HTTP_PROXY y HTTPS_PROXY en su lugar.

token : El token que se usará como autorización HTTP bearer para los repositorios privados de Hub.

cache_dir : La ruta a una carpeta de caché específica para almacenar los archivos descargados.

local_files_only : Si es True, evita la descarga de archivos desde el Hub.

revision : La versión específica del modelo que se va a usar (p. ej., un nombre de rama, un nombre de etiqueta o un id de commit).

overrides : Un diccionario para sobrescribir la configuración de pasos específicos. Las claves deben coincidir con el nombre de la clase o el nombre del registro del paso.

to_transition : Una función personalizada para convertir los datos de entrada en `EnvTransition`.

to_output : Una función personalizada para convertir el `EnvTransition` final al formato de salida.

- ****kwargs** : Argumentos adicionales (no se usan).

**Devuelve:**

Una instancia de `DataProcessorPipeline` cargada con la configuración y el estado especificados.

**Excepciones:** ``FileNotFoundError`` o ``ValueError`` o ``ImportError`` o ``KeyError`` o ``ProcessorMigrationError``

- ``FileNotFoundError`` -- Si no se puede encontrar el archivo de configuración.
- ``ValueError`` -- Si la configuración es ambigua o la instanciación falla.
- ``ImportError`` -- Si la clase de un paso no se puede importar.
- ``KeyError`` -- Si una clave de reemplazo no coincide con ningún paso del pipeline.
- ``ProcessorMigrationError`` -- Si el modelo requiere migración al formato de procesador.

Carga un pipeline desde un directorio local, un archivo individual o un repositorio de Hugging Face Hub.

Este método implementa un pipeline de carga simplificado con detección inteligente de migración:

**Estrategia de carga simplificada**:
1. **Carga de configuración** (_load_config):
   - **Directorio**: Carga el config_filename especificado desde el directorio
   - **Archivo único**: Carga el archivo directamente (config_filename se ignora)
   - **Repositorio de Hub**: Descarga el config_filename especificado desde Hub

2. **Validación de la configuración** (_validate_loaded_config):
   - Validación del formato: Asegúrese de que la configuración sea un formato de procesador válido
   - Detección de migración: Guía a los usuarios para migrar modelos antiguos de LeRobot
   - Errores claros: Proporciona mensajes de error accionables

3. **Construcción de pasos** (_build_steps_with_overrides):
   - Resolución de clases: búsqueda en el registro o importaciones dinámicas
   - Fusión de sobrescritura: los parámetros del usuario sobrescriben la configuración guardada
   - Carga de estado: Carga archivos .safetensors para pasos con estado

4. **Sobrescritura de validación** (_validate_overrides_used):
   - Asegúrese de que se aplicaron todas las anulaciones del usuario (detectar errores tipográficos)
   - Proporcionar mensajes de error útiles con las claves disponibles

**Detección de migración**:
- **Detección inteligente**: Analiza los archivos JSON para detectar modelos antiguos de LeRobot
- **Detección precisa**: Evita falsos positivos en otros modelos de HuggingFace
- **Guía clara**: Proporciona el comando exacto de migración para ejecutar
- **Modo de error**: Siempre lanza ProcessorMigrationError para una acción clara del usuario

**Cargar ejemplos**:
```python
# Directory loading
pipeline = DataProcessorPipeline.from_pretrained("/models/my_model", config_filename="processor.json")

# Single file loading
pipeline = DataProcessorPipeline.from_pretrained(
    "/models/my_model/processor.json", config_filename="processor.json"
)

# Hub loading
pipeline = DataProcessorPipeline.from_pretrained("user/repo", config_filename="processor.json")

# Multiple configs (preprocessor/postprocessor)
preprocessor = DataProcessorPipeline.from_pretrained(
    "model", config_filename="policy_preprocessor.json"
)
postprocessor = DataProcessorPipeline.from_pretrained(
    "model", config_filename="policy_postprocessor.json"
)
```

**Sistema de anulación**:
- **Correspondencia de claves**: Use nombres de registro o nombres de clase como claves de anulación
- **Fusión de configuraciones**: Las configuraciones del usuario tienen prioridad sobre la configuración guardada
- **Validación**: Asegúrate de que todas las claves de anulación coincidan con los pasos reales (detecta errores tipográficos)
- **Ejemplo**: overrides={"NormalizeStep": {"device": "cuda"}}

#### get_config[[lerobot.processor.DataProcessorPipeline.get_config]]

```python
get_config()
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L451)

**Devuelve:**

Un diccionario con el mismo contenido que `save_pretrained()` escribe como JSON.

Devuelve la configuración de la pipeline serializable en JSON.

#### load_state_dict[[lerobot.processor.DataProcessorPipeline.load_state_dict]]

```python
load_state_dict(state_dict: dict[str, dict[str, torch.Tensor]])
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L515)

**Parámetros:**

state_dict : Un diccionario que mapea claves de estado sin sufijo a diccionarios de estado de paso.

**Excepciones:** ``KeyError``

- ``KeyError`` -- Si al cargar se encuentra un estado esperado ausente o un estado adicional inesperado.

Cargue los tensores del estado de la pipeline en los pasos existentes.

#### process_action[[lerobot.processor.DataProcessorPipeline.process_action]]

```python
process_action(action: PolicyAction | RobotAction | EnvAction)
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L1786)

**Parámetros:**

action : Los datos de la acción.

**Devuelve:**

La acción procesada.

Procesa solo la parte de la acción de una transición a través del pipeline.

#### process_complementary_data[[lerobot.processor.DataProcessorPipeline.process_complementary_data]]

```python
process_complementary_data(complementary_data: dict[str, Any])
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L1853)

**Parámetros:**

complementary_data : El diccionario de datos complementario.

**Devuelve:**

El diccionario de datos complementarios procesados.

Procesa solo la parte de datos complementarios de una transición a través del pipeline.

#### process_done[[lerobot.processor.DataProcessorPipeline.process_done]]

```python
process_done(done: bool | torch.Tensor)
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L1814)

**Parámetros:**

done : La bandera done.

**Devuelve:**

La bandera procesada.

Procesa únicamente la bandera done de una transición a través de la pipeline.

#### process_info[[lerobot.processor.DataProcessorPipeline.process_info]]

```python
process_info(info: dict[str, Any])
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L1840)

**Parámetros:**

info : El diccionario de información.

**Devuelve:**

El diccionario de información procesada.

Procesa solo el diccionario de información de una transición a través de la tubería.

#### process_observation[[lerobot.processor.DataProcessorPipeline.process_observation]]

```python
process_observation(observation: RobotObservation)
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L1773)

**Parámetros:**

observation : El diccionario de observación.

**Devuelve:**

El diccionario de observaciones procesado.

Procesa solo la parte de observación de una transición a través del pipeline.

#### process_reward[[lerobot.processor.DataProcessorPipeline.process_reward]]

```python
process_reward(reward: float | torch.Tensor)
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L1801)

**Parámetros:**

reward : El valor de la recompensa.

**Devuelve:**

La recompensa procesada.

Procesa solo la parte de recompensa de una transición a través del pipeline.

#### process_truncated[[lerobot.processor.DataProcessorPipeline.process_truncated]]

```python
process_truncated(truncated: bool | torch.Tensor)
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L1827)

**Parámetros:**

truncated : La bandera truncada.

**Devuelve:**

La bandera truncada procesada.

Procesa únicamente la bandera truncada de una transición a través de la tubería.

#### register_after_step_hook[[lerobot.processor.DataProcessorPipeline.register_after_step_hook]]

```python
register_after_step_hook(fn: Callable[[int, EnvTransition], None])
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L1697)

**Parámetros:**

fn : Un objeto invocable que acepta el índice de paso y la transición actual.

Registra una función para ser llamada después de cada paso.

#### register_before_step_hook[[lerobot.processor.DataProcessorPipeline.register_before_step_hook]]

```python
register_before_step_hook(fn: Callable[[int, EnvTransition], None])
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L1673)

**Parámetros:**

fn : Un objeto invocable que acepta el índice de paso y la transición actual.

Registra una función para ser llamada antes de cada paso.

#### reset[[lerobot.processor.DataProcessorPipeline.reset]]

```python
reset()
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L1721)

Restablece el estado de todos los pasos con estado en la tubería.

#### save_pretrained[[lerobot.processor.DataProcessorPipeline.save_pretrained]]

```python
save_pretrained(save_directory: str | Path | None = None, repo_id: str | None = None, push_to_hub: bool = False, card_kwargs: dict[str, Any] | None = None, config_filename: str | None = None, **push_to_hub_kwargs)
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L595)

**Parámetros:**

save_directory : El directorio donde se guardará el pipeline. Si es None, se guarda en HF_LEROBOT_HOME/processors/{sanitized_pipeline_name}.

repo_id : ID de tu repositorio en el Hub. Se usa solo si `push_to_hub=true`.

push_to_hub : Si se sube o no el objeto al Hugging Face Hub después de guardarlo.

card_kwargs : Argumentos adicionales que se pasan a la plantilla de la tarjeta para personalizarla.

config_filename : El nombre del archivo de configuración JSON. Si es None, se genera un nombre a partir del atributo `name` del pipeline.

- ****push_to_hub_kwargs** : Argumentos de palabra clave adicionales que se pasan al método push_to_hub.

Guarda la configuración y el estado de la pipeline en un directorio.

Este método crea un archivo de configuración JSON que define la estructura del pipeline (nombre y pasos). Para cada paso con estado, también guarda un archivo `.safetensors` que contiene su diccionario de estado.

#### state_dict[[lerobot.processor.DataProcessorPipeline.state_dict]]

```python
state_dict()
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L488)

**Devuelve:**

Un diccionario que mapea claves de estado sin sufijo a diccionarios de estado de paso clonados.

Devuelve los tensores del estado de la pipeline agrupados por clave de estado.

#### step_through[[lerobot.processor.DataProcessorPipeline.step_through]]

```python
step_through(data: TInput)
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L343)

**Parámetros:**

data : Los datos de entrada.

**Devuelve:**

El objeto `EnvTransition`, comenzando con el estado inicial y luego después de cada paso de procesamiento.

Procesa los datos paso a paso, generando la transición en cada etapa.

Este es un método generador útil para depurar e inspeccionar el estado intermedio de los datos a medida que pasan por el pipeline.

#### transform_features[[lerobot.processor.DataProcessorPipeline.transform_features]]

```python
transform_features(initial_features: dict[PipelineFeatureType, dict[str, PolicyFeature]])
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L1750)

**Parámetros:**

initial_features : Un diccionario que describe las características iniciales.

**Devuelve:**

La descripción final de la característica después de todas las transformaciones.

Aplica las transformaciones de características de todos los pasos de forma secuencial.

Este método propaga un diccionario de descripción de características a través del método `transform_features` de cada paso, lo que permite a la pipeline determinar estáticamente la especificación de las características de salida sin procesar ningún dato real.

#### unregister_after_step_hook[[lerobot.processor.DataProcessorPipeline.unregister_after_step_hook]]

```python
unregister_after_step_hook(fn: Callable[[int, EnvTransition], None])
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L1705)

**Parámetros:**

fn : El objeto de función exacto que se registró previamente.

**Excepciones:** ``ValueError``

- ``ValueError`` -- Si el hook no se encuentra en la lista.

Deregistra un hook 'after_step'.

#### unregister_before_step_hook[[lerobot.processor.DataProcessorPipeline.unregister_before_step_hook]]

```python
unregister_before_step_hook(fn: Callable[[int, EnvTransition], None])
```

[Fuente](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/processor/pipeline.py#L1681)

**Parámetros:**

fn : El objeto de función exacto que se registró previamente.

**Excepciones:** ``ValueError``

- ``ValueError`` -- Si el hook no se encuentra en la lista.

Deregistra un hook 'before_step'.

## PolicyProcessorPipeline[[lerobot.processor.DataProcessorPipeline]]

#### lerobot.processor.DataProcessorPipeline[[lerobot.processor.DataProcessorPipeline]]

```python
lerobot.processor.DataProcessorPipeline(*args, **kwargs)
```