# Pipeline

## ModularPipeline[[diffusers.ModularPipeline]]

#### diffusers.ModularPipeline[[diffusers.ModularPipeline]]

```python
diffusers.ModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L1700)

**Parámetros:**

blocks : ModularPipelineBlocks, los bloques que se usarán en el pipeline

Clase base para todos los pipelines modulares.

#### from_pretrained[[diffusers.ModularPipeline.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike | None, trust_remote_code: bool | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L1925)

**Parámetros:**

pretrained_model_name_or_path (`str` o `os.PathLike`, opcional) : Ruta a una configuración de pipeline preentrenada. Primero intentará cargar la configuración desde `modular_model_index.json` y, si no es posible, usará `model_index.json` para mantener la compatibilidad con repositorios estándar no modulares. Si pretrained_model_name_or_path no contiene ninguna configuración de pipeline, se establecerá en None durante la inicialización.

trust_remote_code (`bool`, opcional) : Si se debe confiar en el código remoto al cargar el pipeline. Debe establecerse en True si se desea crear bloques de pipeline basados en el código personalizado de `pretrained_model_name_or_path`

components_manager (`ComponentsManager`, opcional) : Instancia de ComponentsManager para gestionar múltiples componentes en diferentes pipelines y aplicar estrategias de offloading.

collection (`str`, opcional) --` Nombre de la colección para organizar los componentes en el ComponentsManager.

workflow (`str`, opcional) : Nombre de un flujo de trabajo declarado por los bloques de la pipeline. Si se proporciona, los bloques se recortan a los bloques de ejecución de ese flujo de trabajo, de modo que la pipeline solo espera — y `load_components()` solo carga — los componentes que utiliza ese flujo de trabajo.

Carga un ModularPipeline desde un repositorio de Hugging Face Hub.

#### get_component_spec[[diffusers.ModularPipeline.get_component_spec]]

```python
get_component_spec(name: str)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L2401)

**Devuelve:**

- una copia del objeto ComponentSpec para el nombre de componente dado

#### load_components[[diffusers.ModularPipeline.load_components]]

```python
load_components(names: list[str] | str | None = None, workflow: str | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L2489)

**Parámetros:**

names : lista de nombres de componentes a cargar. Si es None, se cargarán todos los componentes con default_creation_method == "from_pretrained". Si se proporciona como una lista o una cadena, se cargarán solo los componentes especificados.

workflow : nombre de un flujo de trabajo declarado por los bloques de pipeline. Si se proporciona, solo se cargan los componentes que utilizan los bloques de ejecución de ese flujo de trabajo. No se puede combinar con `names`.

- ****kwargs** : kwargs adicionales que se pasarán a `from_pretrained()`. Puede ser: - un único valor que se aplicará a todos los componentes que se carguen, p. ej. dtype=torch.bfloat16 - un diccionario, p. ej. dtype={"unet": torch.bfloat16, "default": torch.float32} - si se pasa un campo de carga diferente en kwargs, puede sobrescribir potencialmente ComponentSpec, p. ej. `pretrained_model_name_or_path`, `variant`, `revision`, etc. - si se pasa un campo de carga diferente en kwargs, puede sobrescribir potencialmente ComponentSpec, p. ej. `pretrained_model_name_or_path`, `variant`, `revision`, etc.

Cargar los componentes seleccionados desde las especificaciones.

#### register_components[[diffusers.ModularPipeline.register_components]]

```python
register_components(**kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L2186)

**Parámetros:**

- ****kwargs** : Argumentos de palabra clave donde las claves son nombres de componentes y los valores son objetos de componentes. Por ejemplo, register_components(unet=unet_model, text_encoder=encoder_model)

Registre los componentes con sus especificaciones correspondientes.

Este método se encarga de:
1. Establece los objetos de los componentes como atributos del cargador (p. ej., self.unet = unet)
2. Actualiza el diccionario de configuración, que se guardará como `modular_model_index.json` durante `save_pretrained` (solo para componentes de from_pretrained)
3. Añade componentes al gestor de componentes si está adjunto (solo para componentes de from_pretrained)

Este método se llama cuando:
- Los componentes se inicializan primero en __init__:
  - los componentes de from_pretrained no se cargan durante __init__, por lo que se registran como None;
  - los componentes no from_pretrained se crean durante __init__ y se registran como el propio objeto
- Los componentes se actualizan con el método `update_components()`: por ejemplo, loader.update_components(unet=unet) o loader.update_components(guider=guider_spec)
- (from_pretrained) Los componentes se cargan con el método `load_components()`: por ejemplo, loader.load_components(names=["unet"]) o loader.load_components() para cargar todos los componentes predeterminados

Notas:
- Al registrar None para un componente, se establece el atributo en None, pero se siguen sincronizando las especificaciones con el diccionario de configuración, que se guardará como `modular_model_index.json` durante `save_pretrained`
- component_specs are updated to match the new component outside of this method, e.g. in `update_components()` method

#### save_pretrained[[diffusers.ModularPipeline.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, safe_serialization: bool = True, variant: str | None = None, max_shard_size: int | str | None = None, push_to_hub: bool = False, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L2026)

**Parámetros:**

save_directory (`str` o `os.PathLike`) : Directorio donde se guardará el pipeline. Se creará si no existe.

safe_serialization (`bool`, *opcional*, por defecto `True`) : Si se guarda el modelo usando `safetensors` o de la forma tradicional de PyTorch con `pickle`.

variant (`str`, *opcional*) : Si se especifica, los pesos se guardan en el formato `pytorch_model.<variant>.bin`.

max_shard_size (`int` o `str`, por defecto `None`) : El tamaño máximo de un checkpoint antes de ser fragmentado. Los fragmentos del checkpoint tendrán cada uno un tamaño inferior a este valor. Si se expresa como una cadena, debe consistir en dígitos seguidos de una unidad (como `"5GB"`). Si se expresa como un entero, la unidad es bytes.

push_to_hub (`bool`, *opcional*, por defecto `False`) : Si se debe subir el pipeline al Hugging Face model hub después de guardarlo.

- ****kwargs** : Argumentos de palabra clave adicionales: - `overwrite_modular_index` (`bool`, *opcional*, valor predeterminado `True`): Si se debe actualizar `modular_model_index.json` para que la especificación de carga de cada componente guardado apunte al destino: `repo_id` al publicar en el Hub, o de lo contrario `save_directory`. Los componentes que no se cargan no se guardan y siempre conservan sus especificaciones de carga registradas. Pasa `False` para conservar también las especificaciones registradas de los componentes que se están guardando (p. ej., para un índice que hace referencia deliberadamente a otros repositorios); los componentes sin un identificador de carga (como los modelos personalizados agregados con `update_components`) se reescriben de todos modos, ya que no tienen una fuente registrada. - `repo_id` (`str`, *opcional*): El identificador del repositorio al que se publicará el pipeline. El valor predeterminado es el último componente de `save_directory`. - `commit_message` (`str`, *opcional*): Mensaje de commit para la operación de publicación en el Hub. - `private` (`bool`, *opcional*): Si el repositorio debe ser privado. - `create_pr` (`bool`, *opcional*, valor predeterminado `False`): Si se debe crear una solicitud de extracción (pull request) en lugar de publicar directamente. - `token` (`str`, *opcional*): El token de Hugging Face que se usará para la autenticación.

Guarde el pipeline y todos sus componentes en un directorio para que pueda recargarse mediante el método de clase [from_pretrained()](/docs/diffusers/v0.43.0/es/api/modular_diffusers/pipeline#diffusers.ModularPipeline.from_pretrained).

#### a[[diffusers.ModularPipeline.to]]

```python
to(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L2651)

**Parámetros:**

dtype (`torch.dtype`, *opcional*) : Devuelve un pipeline con el [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) especificado

device (`torch.Device`, *opcional*) : Devuelve un pipeline con el [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) especificado

silence_dtype_warnings (`str`, *opcional*, por defecto `False`) : Si se omiten las advertencias cuando el `dtype` objetivo no es compatible con el `device` objetivo.

**Devuelve:** [DiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline)

El pipeline se convirtió al `dtype` y/o `dtype` especificado.

Realiza la conversión de dtype y/o device de Pipeline. Se infieren un torch.dtype y un torch.device a partir de los argumentos de `self.to(*args, **kwargs).`

> [!TIP] > Si el pipeline ya tiene el torch.dtype y el torch.device correctos, se devuelve tal cual.
En caso contrario, > el pipeline devuelto es una copia de self con el torch.dtype y el torch.device deseados.

Estas son las formas de llamar a `to`:

- `to(dtype, silence_dtype_warnings=False) → DiffusionPipeline` para devolver un pipeline con el [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) especificado
- `to(device, silence_dtype_warnings=False) → DiffusionPipeline` para devolver un pipeline con el [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) especificado
- `to(device=None, dtype=None, silence_dtype_warnings=False) → DiffusionPipeline` para devolver un pipeline con el [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) y el [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) especificados

#### unload_components[[diffusers.ModularPipeline.unload_components]]

```python
unload_components(names: list[str] | str)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L2595)

**Parámetros:**

names : nombre del componente o lista de nombres de componentes para descargar.

Descargue los componentes seleccionados, liberando su memoria.

El atributo component se restablece a `None` y, si hay un ComponentsManager adjunto, el componente se elimina de él. La especificación del componente no se modifica, por lo que el componente puede volver a cargarse más adelante con `load_components()`.

#### update_components[[diffusers.ModularPipeline.update_components]]

```python
update_components(**kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L2408)

**Parámetros:**

- ****kwargs** : Objetos de componentes o valores de configuración para actualizar: - Objetos de componentes: Los modelos cargados con `AutoModel.from_pretrained()` o `ComponentSpec.load()` se etiquetan automáticamente con información de carga. Los objetos ConfigMixin sin pesos (p. ej., programadores, guías) se pueden pasar directamente. - Valores de configuración: Valores simples para actualizar la configuración (p. ej., `requires_safety_checker=False`)

Actualice los componentes y los valores y especificaciones de la configuración después de que se haya instanciado el pipeline.

Este método le permite:
1. Reemplace los componentes existentes por nuevos (por ejemplo, actualizando `self.unet` o `self.text_encoder`)
2. Actualizar los valores de configuración (p. ej., cambiar la bandera `self.requires_safety_checker`)

Además de actualizar los componentes y los valores de configuración como atributos de la pipeline, el método también actualiza:
- las especificaciones correspondientes en `_component_specs` y `_config_specs`
- el diccionario `config`, que se guardará como `modular_model_index.json` durante `save_pretrained`

Ejemplos:
```python
# Update pre-trained model
pipeline.update_components(unet=new_unet_model, text_encoder=new_text_encoder)

# Update configuration values
pipeline.update_components(requires_safety_checker=False)
```

Notas:
- Los componentes cargados con `AutoModel.from_pretrained()` o `ComponentSpec.load()` tendrán
loading specs conservados para la serialización. Los componentes personalizados o cargados localmente sin referencias al Hub tendrán sus entradas en `modular_model_index.json` actualizadas automáticamente durante `save_pretrained()`.
- Los objetos ConfigMixin sin pesos (p. ej., programadores, guías) se pueden pasar directamente.