# Pipelines

Los pipelines ofrecen una forma sencilla de ejecutar modelos de difusión de vanguardia en inferencia al agrupar todos los componentes necesarios (varios modelos entrenados de forma independiente, programadores y procesadores) en una única clase de extremo a extremo. Los pipelines son flexibles y se pueden adaptar para utilizar programadores o incluso componentes de modelo diferentes.

Todas las pipelines se construyen a partir de la clase base [DiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline), que proporciona la funcionalidad básica para cargar, descargar y guardar todos los componentes. Los tipos de pipeline específicos (por ejemplo, [StableDiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline)) cargados con [from_pretrained()](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained) se detectan automáticamente y los componentes del pipeline se cargan y se pasan a la función `__init__` del pipeline.

> [!WARNING]
> No debe usar la clase [DiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline) para el entrenamiento. Los componentes individuales (por ejemplo, [UNet2DModel](/docs/diffusers/v0.43.0/es/api/models/unet2d#diffusers.UNet2DModel) y [UNet2DConditionModel](/docs/diffusers/v0.43.0/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) de los pipelines de difusión suelen entrenarse de forma individual, por lo que sugerimos trabajar directamente con ellos.
>
> 
>
> Los pipelines no ofrecen ninguna funcionalidad de entrenamiento. Notará que el autograd de PyTorch está deshabilitado al decorar el método `__call__()` con el decorador [`torch.no_grad`](https://pytorch.org/docs/stable/generated/torch.no_grad.html), ya que los pipelines no deben usarse para entrenamiento. Si le interesa el entrenamiento, ¡consulte en su lugar las guías de [Training](../../training/overview)!

Use **API > Pipelines** en la barra lateral para consultar todas las referencias de pipelines por modalidad. Para flujos de trabajo orientados a tareas, comience con el [Quickstart](../../quicktour) o con una guía como [text-to-image](../../using-diffusers/conditional_image_generation), [image-to-image](../../using-diffusers/img2img), [inpainting](../../using-diffusers/inpaint) o [video generation](../../using-diffusers/text-img2vid).

## DiffusionPipeline[[diffusers.DiffusionPipeline]]

#### diffusers.DiffusionPipeline[[diffusers.DiffusionPipeline]]

```python
diffusers.DiffusionPipeline()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L198)

Clase base para todas las tuberías.

[DiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline) almacena todos los componentes (modelos, programadores y procesadores) de las tuberías de difusión y proporciona métodos para cargar, descargar y guardar modelos. También incluye métodos para:

- mover todos los módulos de PyTorch al dispositivo de su elección
- activar/desactivar la barra de progreso para la iteración de desruido

Atributos de clase:

- **config_name** (`str`) -- El nombre del archivo de configuración que almacena los nombres de las clases y los módulos de todos los componentes del pipeline de difusión.
- **_optional_components** (`List[str]`) -- Lista de todos los componentes opcionales que no es necesario pasar a la pipeline para que funcione (debe ser sobrescrito por las subclases).

#### __call__[[diffusers.DiffusionPipeline.__call__]]

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

Llamar a self como una función.

#### device[[diffusers.DiffusionPipeline.device]]

```python
device()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L600)

**Devuelve:** `torch.device`

El dispositivo torch en el que se encuentra el pipeline. Cuando los componentes se distribuyen entre dispositivos (por ejemplo, los codificadores de texto en la CPU mientras que el backbone de desruido se ejecuta en un acelerador), se devuelve el dispositivo del acelerador.

#### a[[diffusers.DiffusionPipeline.to]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L397)

**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

#### componentes[[diffusers.DiffusionPipeline.components]]

```python
components()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1907)

La propiedad `self.components` puede ser útil para ejecutar diferentes pipelines con los mismos pesos y configuraciones sin reasignar memoria adicional.

Returns (`dict`): Un diccionario que contiene todos los módulos necesarios para inicializar el pipeline.

Ejemplos:

```py
>>> from diffusers import (
...     StableDiffusionPipeline,
...     StableDiffusionImg2ImgPipeline,
...     StableDiffusionInpaintPipeline,
... )

>>> text2img = StableDiffusionPipeline.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5")
>>> img2img = StableDiffusionImg2ImgPipeline(**text2img.components)
>>> inpaint = StableDiffusionInpaintPipeline(**text2img.components)
```

#### disable_attention_slicing[[diffusers.DiffusionPipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2067)

Desactiva el cálculo de atención segmentada. Si `enable_attention_slicing` se llamó previamente, la atención se calcula en un solo paso.

#### disable_xformers_memory_efficient_attention[[diffusers.DiffusionPipeline.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2006)

Desactivar la atención eficiente en memoria de [xFormers](https://facebookresearch.github.io/xformers/).

#### descargar[[diffusers.DiffusionPipeline.download]]

```python
download(pretrained_model_name, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1483)

**Parámetros:**

pretrained_model_name (`str` o `os.PathLike`, *opcional*) : Una cadena de caracteres, el *repository id* (por ejemplo, `CompVis/ldm-text2im-large-256`) de un pipeline preentrenado alojado en el Hub.

custom_pipeline (`str`, *opcional*) : Puede ser:  - Una cadena de caracteres, el *repository id* (por ejemplo `CompVis/ldm-text2im-large-256`) de un pipeline preentrenado alojado en el Hub. El repositorio debe contener un archivo llamado `pipeline.py` que defina el pipeline personalizado.  - Una cadena de caracteres, el *nombre de archivo* de un pipeline de la comunidad alojado en GitHub bajo [Community](https://github.com/huggingface/diffusers/tree/main/examples/community). Los nombres de archivo válidos deben coincidir con el nombre del archivo y no con el script del pipeline (`clip_guided_stable_diffusion` en lugar de `clip_guided_stable_diffusion.py`). Los pipelines de la comunidad siempre se cargan desde la rama `main` actual de GitHub.  - Una ruta a un *directorio* (`./my_pipeline_directory/`) que contiene un pipeline personalizado. El directorio debe contener un archivo llamado `pipeline.py` que defina el pipeline personalizado.  > [!WARNING] > 🧪 Esta es una función experimental y puede cambiar en el futuro.  Para obtener más información sobre cómo cargar y crear pipelines personalizados, consulte [Cómo contribuir con un pipeline de la comunidad](https://huggingface.co/docs/diffusers/main/en/using-diffusers/contribute_pipeline).

force_download (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe forzar la (re)descarga de los pesos del modelo y los archivos de configuración, reemplazando las versiones en caché si existen.

proxies (`Dict[str, str]`, *opcional*) : Un diccionario de servidores proxy a utilizar por protocolo o punto de acceso, por ejemplo, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Los proxies se utilizan en cada solicitud.

output_loading_info(`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver también un diccionario que contenga las claves faltantes, las claves inesperadas y los mensajes de error.

local_files_only (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben cargar únicamente los pesos y archivos de configuración del modelo localmente. Si se establece en `True`, el modelo no se descargará desde el Hub.

token (`str` o *bool*, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. Si es `True`, se utiliza el token generado por `diffusers-cli login` (almacenado en `~/.huggingface`).

revision (`str`, *opcional*, valor predeterminado `"main"`) : La versión específica del modelo que se va a utilizar. Puede ser el nombre de una rama, el nombre de una etiqueta, un id de commit o cualquier identificador permitido por Git.

custom_revision (`str`, *opcional*, por defecto `"main"`) : La versión específica del modelo a utilizar. Puede ser un nombre de rama, un nombre de etiqueta o un id de commit similar a `revision` al cargar un pipeline personalizado desde el Hub. Puede ser una versión de 🤗 Diffusers al cargar un pipeline personalizado desde GitHub, de lo contrario, por defecto es `"main"` al cargar desde el Hub.

mirror (`str`, *opcional*) : Origen de espejo para resolver problemas de accesibilidad si estás descargando un modelo en China. No garantizamos la oportunidad ni la seguridad de la fuente, y debes consultar el sitio de espejo para obtener más información.

variant (`str`, *opcional*) : Carga los pesos desde un nombre de archivo de variante especificado, como `"fp16"` o `"ema"`.

use_safetensors (`bool`, *opcional*, valor predeterminado `None`) : Si se establece en `None`, se descargan los pesos de safetensors si están disponibles **y** si la biblioteca safetensors está instalada. Si se establece en `True`, el modelo se carga forzosamente desde los pesos de safetensors. Si se establece en `False`, no se cargan los pesos de safetensors.

use_onnx (`bool`, *opcional*, valor predeterminado `False`) : Si se establece en `True`, los pesos de ONNX siempre se descargarán si están presentes. Si se establece en `False`, los pesos de ONNX nunca se descargarán. De forma predeterminada, `use_onnx` toma el valor del atributo de clase `_is_onnx`, que es `False` para los pipelines no-ONNX y `True` para los pipelines ONNX. Los pesos de ONNX incluyen tanto los archivos que terminan en `.onnx` como en `.pb`.

trust_remote_code (`bool`, *opcional*, valor predeterminado `False`) : Si se permiten o no pipelines y componentes personalizados definidos en el Hub en sus propios archivos. Esta opción solo debe establecerse en `True` para repositorios de confianza y en los que hayas leído el código, ya que ejecutará el código presente en el Hub en tu máquina local.

use_flashpack (`bool`, *opcional*, valor predeterminado `False`) : Si se establece en `True`, los pesos de FlashPack siempre se descargarán si están presentes. Si se establece en `False`, los pesos de FlashPack nunca se descargarán.

**Devuelve:** `os.PathLike`

Una ruta al pipeline descargado.

Descarga y almacena en caché un pipeline de difusión de PyTorch a partir de pesos de pipeline preentrenados.

> [!TIP] > Para usar modelos privados o [con acceso restringido](https://huggingface.co/docs/hub/models-gated#gated-models), inicia sesión
con `hf > auth login

#### enable_attention_slicing[[diffusers.DiffusionPipeline.enable_attention_slicing]]

```python
enable_attention_slicing(slice_size: str | int = 'auto')
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2030)

**Parámetros:**

slice_size (`str` o `int`, *opcional*, valor predeterminado `"auto"`) : Cuando es `"auto"`, divide a la mitad la entrada de las cabezas de atención, de modo que la atención se calculará en dos pasos. Si es `"max"`, se ahorrará la máxima cantidad de memoria ejecutando solo una porción a la vez. Si se proporciona un número, se utilizan tantas porciones como `attention_head_dim // slice_size`. En este caso, `attention_head_dim` debe ser un múltiplo de `slice_size`.

Habilita el cálculo de atención segmentada. Cuando esta opción está habilitada, el módulo de atención divide el tensor de entrada en fragmentos para calcular la atención en varios pasos. Para más de una cabeza de atención, el cálculo se realiza de forma secuencial sobre cada cabeza. Esto es útil para ahorrar algo de memoria a cambio de una pequeña disminución en la velocidad.

> [!WARNING] > ⚠️ No actives el rebanado de atención si ya estás usando `scaled_dot_product_attention` (SDPA)
de PyTorch > 2.0 o xFormers. Estos cálculos de atención ya son muy eficientes en memoria, por lo que no necesitarás habilitar > esta función. Si habilitas el rebanado de atención con SDPA o xFormers, ¡puede provocar una ralentización grave!

Ejemplos:

```py
>>> import torch
>>> from diffusers import StableDiffusionPipeline

>>> pipe = StableDiffusionPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5",
...     dtype=torch.float16,
...     use_safetensors=True,
... )

>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> pipe.enable_attention_slicing()
>>> image = pipe(prompt).images[0]
```

#### enable_group_offload[[diffusers.DiffusionPipeline.enable_group_offload]]

```python
enable_group_offload(onload_device: device, offload_device: device = torch.device(), offload_type: str = 'block_level', num_blocks_per_group: int | None = None, non_blocking: bool = False, use_stream: bool = False, record_stream: bool = False, low_cpu_mem_usage = False, offload_to_disk_path: str | None = None, exclude_modules: str | list[str] | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1343)

**Parámetros:**

onload_device (`torch.device`) : El dispositivo en el que se cargan los módulos del grupo.

offload_device (`torch.device`, por defecto `torch.device("cpu")`) : El dispositivo al que se descargan los módulos del grupo. Normalmente, debe ser la CPU. El valor predeterminado es la CPU.

offload_type (`str` o `GroupOffloadingType`, por defecto "block_level") : El tipo de offloading que se aplicará. Puede ser "block_level" o "leaf_level". El valor por defecto es "block_level".

offload_to_disk_path (`str`, *opcional*, valor predeterminado `None`) : La ruta al directorio donde se descargará los parámetros. Establecer esta opción puede ser útil en entornos con RAM limitada donde se desea un equilibrio razonable entre velocidad y memoria.

num_blocks_per_group (`int`, *opcional*) : El número de bloques por grupo al usar offload_type="block_level". Es obligatorio al usar offload_type="block_level".

non_blocking (`bool`, por defecto `False`) : Si es True, el offloading y el onloading se realizan con transferencia de datos no bloqueante.

use_stream (`bool`, por defecto `False`) : Si es True, el offloading y el onloading se realizan de forma asíncrona utilizando un stream de CUDA. Esto puede ser útil para superponer el cálculo y la transferencia de datos.

record_stream (`bool`, por defecto `False`) : Cuando se habilita con `use_stream`, marca el tensor actual como utilizado por este stream. Es más rápido a costa de un uso ligeramente mayor de memoria. Consulte los [documentos oficiales de PyTorch](https://pytorch.org/docs/stable/generated/torch.Tensor.record_stream.html) para más detalles.

low_cpu_mem_usage (`bool`, por defecto `False`) : Si es True, el uso de memoria CPU se minimiza fijando los tensores sobre la marcha en lugar de fijarlos previamente. Esta opción solo es relevante al usar el descargado de CPU por streaming (es decir, `use_stream=True`). Puede ser útil cuando la memoria CPU es un cuello de botella, pero puede contrarrestar los beneficios de usar streams.

exclude_modules (`Union[str, List[str]]`, por defecto `None`) : Lista de módulos que se excluirán del offloading.

Aplica el descargado por grupos a las capas internas de un torch.nn.Module. Para comprender qué es el descargado por grupos y en qué casos resulta beneficioso, primero debemos proporcionar algo de contexto sobre cómo funcionan otros métodos de descargado admitidos.

Por lo general, el offloading se realiza en dos niveles:
- A nivel de módulo: en Diffusers, esto se puede habilitar usando el método `ModelMixin::enable_model_cpu_offload()`.
funciona descargando cada componente de un pipeline a la CPU para su almacenamiento y cargándolo en el dispositivo de acelerador cuando se necesita para el cálculo. Este método es más eficiente en memoria que mantener todos los componentes en el acelerador, pero los requisitos de memoria siguen siendo bastante altos. Para que este método funcione, se necesita una memoria equivalente al tamaño del modelo en el tipo de datos de tiempo de ejecución + el tamaño de los tensores de activación intermedia más grandes para poder completar la pasada hacia adelante.
- Nivel de hoja: En Diffusers, esto se puede habilitar usando el método `ModelMixin::enable_sequential_cpu_offload()`.
funciona descargando los parámetros de nivel de hoja más bajos del grafo de cómputo a la CPU para su almacenamiento, y cargando solo las hojas al dispositivo de aceleración para el cómputo. Esto utiliza la menor cantidad de memoria de acelerador, pero puede ser más lento debido al exceso de sincronizaciones de dispositivos.

El offloading por grupos es un punto intermedio entre los dos métodos. Funciona descargando grupos de capas internas (ya sea `torch.nn.ModuleList` o `torch.nn.Sequential`). Este método utiliza menos memoria que el offloading a nivel de módulo. También es más rápido que el offloading a nivel de hoja/secuencial, ya que se reduce el número de sincronizaciones de dispositivos.

Otra característica admitida (para dispositivos CUDA con soporte para flujos de transferencia de datos asíncronos) es la capacidad de superponer la transferencia de datos y el cálculo para reducir el tiempo de ejecución total en comparación con el offloading secuencial. Esto se habilita mediante la preobtención de capas con flujos, es decir, la capa que se ejecutará a continuación comienza a cargarse en el dispositivo de aceleración mientras se está ejecutando la capa actual; esto aumenta ligeramente los requisitos de memoria. Tenga en cuenta que esta implementación también admite el offloading a nivel de hoja, pero puede hacerse mucho más rápido al utilizar flujos.

Ejemplo:
```python
>>> from diffusers import DiffusionPipeline
>>> import torch

>>> pipe = DiffusionPipeline.from_pretrained("Qwen/Qwen-Image", dtype=torch.bfloat16)

>>> pipe.enable_group_offload(
...     onload_device=torch.device("cuda"),
...     offload_device=torch.device("cpu"),
...     offload_type="leaf_level",
...     use_stream=True,
... )
>>> image = pipe("a beautiful sunset").images[0]
```

#### enable_model_cpu_offload[[diffusers.DiffusionPipeline.enable_model_cpu_offload]]

```python
enable_model_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1152)

**Parámetros:**

gpu_id (`int`, *opcional*) : El ID del acelerador que se utilizará en la inferencia. Si no se especifica, el valor predeterminado será 0.

device (`torch.Device` o `str`, *opcional*, valor predeterminado None) : El tipo de dispositivo de PyTorch del acelerador que se utilizará en la inferencia. Si no se especifica, se detectará y utilizará automáticamente el acelerador disponible.

Descarga todos los modelos a la CPU usando accelerate, reduciendo el uso de memoria con un bajo impacto en el rendimiento. En comparación con `enable_sequential_cpu_offload`, este método mueve un modelo completo a la aceleradora cuando se llama a su método `forward`, y el modelo permanece en la aceleradora hasta que se ejecute el siguiente modelo. El ahorro de memoria es menor que con `enable_sequential_cpu_offload`, pero el rendimiento es mucho mejor debido a la ejecución iterativa de `unet`.

#### enable_sequential_cpu_offload[[diffusers.DiffusionPipeline.enable_sequential_cpu_offload]]

```python
enable_sequential_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1273)

**Parámetros:**

gpu_id (`int`, *opcional*) : El ID del acelerador que se utilizará en la inferencia. Si no se especifica, el valor predeterminado será 0.

device (`torch.Device` o `str`, *opcional*, valor predeterminado None) : El tipo de dispositivo de PyTorch del acelerador que se utilizará en la inferencia. Si no se especifica, se detectará y utilizará automáticamente el acelerador disponible.

Descarga todos los modelos a la CPU usando 🤗 Accelerate, reduciendo significativamente el uso de memoria. Al llamarse, los state dicts de todos los componentes `torch.nn.Module` (excepto los que están en `self._exclude_from_cpu_offload`) se guardan en la CPU y luego se mueven a `torch.device('meta')` y se cargan en el acelerador solo cuando se llama al método `forward` de su submódulo específico. La descarga se realiza a nivel de submódulo. El ahorro de memoria es mayor que con `enable_model_cpu_offload`, pero el rendimiento es menor.

#### enable_xformers_memory_efficient_attention[[diffusers.DiffusionPipeline.enable_xformers_memory_efficient_attention]]

```python
enable_xformers_memory_efficient_attention(attention_op: typing.Optional[typing.Callable] = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1975)

**Parámetros:**

attention_op (`Callable`, *opcional*) : Anula el operador `None` predeterminado para su uso como argumento `op` de la función [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) de xFormers.

Habilita la atención eficiente en memoria desde [xFormers](https://facebookresearch.github.io/xformers/). Cuando esta opción está habilitada, debe observar un menor uso de memoria de GPU y una posible aceleración durante la inferencia. No se garantiza una aceleración durante el entrenamiento.

> [!WARNING] > ⚠️ Cuando la atención eficiente en memoria y la atención segmentada están ambas habilitadas, la atención eficiente
attention tiene > precedencia.

Ejemplos:

```py
>>> import torch
>>> from diffusers import DiffusionPipeline
>>> from xformers.ops import MemoryEfficientAttentionFlashAttentionOp

>>> pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1", dtype=torch.float16)
>>> pipe = pipe.to("cuda")
>>> pipe.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)
>>> # Workaround for not accepting attention shape using VAE for Flash Attention
>>> pipe.vae.enable_xformers_memory_efficient_attention(attention_op=None)
```

#### from_pipe[[diffusers.DiffusionPipeline.from_pipe]]

```python
from_pipe(pipeline, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2083)

**Parámetros:**

pipeline (`DiffusionPipeline`) : El pipeline a partir del cual se creará un nuevo pipeline.

**Devuelve:** `DiffusionPipeline`

Un nuevo pipeline con los mismos pesos y configuraciones que `pipeline`.

Crea un nuevo pipeline a partir de un pipeline dado. Este método es útil para crear un nuevo pipeline a partir de los componentes de un pipeline existente sin reasignar memoria adicional.

Ejemplos:

```py
>>> from diffusers import StableDiffusionPipeline, StableDiffusionSAGPipeline

>>> pipe = StableDiffusionPipeline.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5")
>>> new_pipe = StableDiffusionSAGPipeline.from_pipe(pipe)
```

#### from_pretrained[[diffusers.DiffusionPipeline.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L638)

**Parámetros:**

pretrained_model_name_or_path (`str` o `os.PathLike`, *opcional*) : Puede ser:  - Una cadena, el *repo id* (por ejemplo `CompVis/ldm-text2im-large-256`) de un pipeline preentrenado alojado en el Hub. - Una ruta a un *directorio* (por ejemplo `./my_pipeline_directory/`) que contenga los pesos del pipeline guardados usando [save_pretrained()](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline.save_pretrained).

dtype (`torch.dtype` o `dict[str, Union[str, torch.dtype]]`, *opcional*) : Anula el `torch.dtype` predeterminado y carga el modelo con otro dtype. Para cargar submodelos con un dtype diferente, pasa un `dict` (por ejemplo, `{'transformer': torch.bfloat16, 'vae': torch.float16}`). Establece el dtype predeterminado para los componentes no especificados con `default` (por ejemplo, `{'transformer': torch.bfloat16, 'default': torch.float16}`). Si un componente no está especificado y no se establece un valor predeterminado, se utiliza `torch.float32`.

custom_pipeline (`str`, *opcional*) : > [!WARNING] > 🧪 Esta es una función experimental y puede cambiar en el futuro.  Puede ser:  - Una cadena de caracteres, el *repo id* (por ejemplo `hf-internal-testing/diffusers-dummy-pipeline`) de un pipeline personalizado alojado en el Hub. El repositorio debe contener un archivo llamado pipeline.py que defina el pipeline personalizado. - Una cadena de caracteres, el *nombre del archivo* de un pipeline de la comunidad alojado en GitHub bajo [Community](https://github.com/huggingface/diffusers/tree/main/examples/community). Los nombres de archivo válidos deben coincidir con el nombre del archivo y no con el script del pipeline (`clip_guided_stable_diffusion` en lugar de `clip_guided_stable_diffusion.py`). Los pipelines de la comunidad siempre se cargan desde la rama main actual de GitHub. - Una ruta a un directorio (`./my_pipeline_directory/`) que contiene un pipeline personalizado. El directorio debe contener un archivo llamado `pipeline.py` que defina el pipeline personalizado.  Para obtener más información sobre cómo cargar y crear pipelines personalizados, consulte [Carga y adición de pipelines personalizados](https://huggingface.co/docs/diffusers/using-diffusers/custom_pipeline_overview)

force_download (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe forzar la (re)descarga de los pesos del modelo y los archivos de configuración, reemplazando las versiones en caché si existen.

cache_dir (`Union[str, os.PathLike]`, *opcional*) : Ruta a un directorio donde se almacena en caché la configuración de un modelo preentrenado descargado si no se utiliza la caché estándar.

proxies (`Dict[str, str]`, *opcional*) : Un diccionario de servidores proxy a utilizar por protocolo o punto de acceso, por ejemplo, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Los proxies se utilizan en cada solicitud.

output_loading_info(`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver también un diccionario que contenga las claves faltantes, las claves inesperadas y los mensajes de error.

local_files_only (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben cargar únicamente los pesos y archivos de configuración del modelo localmente. Si se establece en `True`, el modelo no se descargará desde el Hub.

token (`str` o *bool*, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. Si es `True`, se utiliza el token generado por `diffusers-cli login` (almacenado en `~/.huggingface`).

revision (`str`, *opcional*, valor predeterminado `"main"`) : La versión específica del modelo que se va a utilizar. Puede ser el nombre de una rama, el nombre de una etiqueta, un id de commit o cualquier identificador permitido por Git.

custom_revision (`str`, *opcional*) : La versión específica del modelo a utilizar. Puede ser un nombre de rama, un nombre de etiqueta o un id de commit similar a `revision` al cargar un pipeline personalizado desde el Hub. Por defecto, se utiliza la última versión estable de 🤗 Diffusers.

mirror (`str`, *opcional*) : Origen de espejo para resolver problemas de accesibilidad si estás descargando un modelo en China. No garantizamos la oportunidad ni la seguridad del origen, y debes consultar el sitio de espejo para obtener más información.

device_map (`str`, *opcional*) : Estrategia que dicta cómo deben colocarse los diferentes componentes de un pipeline en los dispositivos disponibles. Actualmente, solo se admite `device_map` "balanced". Consulta [esto](https://huggingface.co/docs/diffusers/main/en/tutorials/inference_with_big_models#device-placement) para obtener más información.

max_memory (`Dict`, *opcional*) : Un diccionario de identificador de dispositivo para la memoria máxima. Si no se establece, se usará por defecto la memoria máxima disponible para cada GPU y la RAM de CPU disponible.

offload_folder (`str` o `os.PathLike`, *opcional*) : La ruta para descargar los pesos si device_map contiene el valor `"disk"`.

offload_state_dict (`bool`, *opcional*) : Si `True`, descarga temporalmente el state dict de la CPU al disco duro para evitar quedarse sin RAM de CPU si el peso del state dict de la CPU + el shard más grande del checkpoint no cabe. El valor predeterminado es `True` cuando hay alguna descarga al disco.

low_cpu_mem_usage (`bool`, *opcional*, por defecto `True` si la versión de torch >= 1.9.0, en caso contrario `False`) : Acelera la carga del modelo cargando solo los pesos preentrenados y no inicializando los pesos. Esto también intenta no usar más de 1x el tamaño del modelo en la memoria de CPU (incluida la memoria pico) mientras se carga el modelo. Solo se admite para PyTorch >= 1.9.0. Si estás usando una versión anterior de PyTorch, establecer este argumento en `True` generará un error.

use_safetensors (`bool`, *opcional*, valor predeterminado `None`) : Si se establece en `None`, se descargan los pesos de safetensors si están disponibles **y** si la biblioteca safetensors está instalada. Si se establece en `True`, el modelo se carga forzosamente desde los pesos de safetensors. Si se establece en `False`, no se cargan los pesos de safetensors.

use_onnx (`bool`, *opcional*, valor predeterminado `None`) : Si se establece en `True`, los pesos de ONNX siempre se descargarán si están presentes. Si se establece en `False`, los pesos de ONNX nunca se descargarán. De forma predeterminada, `use_onnx` toma el valor del atributo de clase `_is_onnx`, que es `False` para los pipelines no-ONNX y `True` para los pipelines ONNX. Los pesos de ONNX incluyen tanto los archivos que terminan en `.onnx` como en `.pb`.

kwargs (resto del diccionario de argumentos de palabra clave, *opcional*) : Se puede usar para sobrescribir las variables de carga y guardado (los componentes de pipeline de la clase de pipeline específica). Los componentes sobrescritos se pasan directamente al método `__init__` de los pipelines. Consulte el ejemplo siguiente para obtener más información.

variant (`str`, *opcional*) : Carga los pesos desde un nombre de archivo de variante especificado, como `"fp16"` o `"ema"`.

disable_mmap ('bool', *opcional*, valor predeterminado 'False') : Si se debe deshabilitar mmap al cargar un modelo de Safetensors. Esta opción puede ofrecer un mejor rendimiento cuando el modelo está en una unidad de red o en un disco duro, que pueden no manejar bien la naturaleza de búsquedas aleatorias de mmap.

Instanciar un pipeline de difusión de PyTorch a partir de pesos de pipeline preentrenados.

El pipeline se configura en modo de evaluación (`model.eval()`) de forma predeterminada.

Si obtienes el siguiente mensaje de error, necesitas ajustar los pesos para tu tarea de destino:

```
Some weights of UNet2DConditionModel were not initialized from the model checkpoint at stable-diffusion-v1-5/stable-diffusion-v1-5 and are newly initialized because the shapes did not match:
- conv_in.weight: found shape torch.Size([320, 4, 3, 3]) in the checkpoint and torch.Size([320, 9, 3, 3]) in the model instantiated
You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
```

> [!TIP] > Para usar modelos privados o [gated](https://huggingface.co/docs/hub/models-gated#gated-models), inicia sesión
con `hf > auth login`.

Ejemplos:

```py
>>> from diffusers import DiffusionPipeline

>>> # Download pipeline from huggingface.co and cache.
>>> pipeline = DiffusionPipeline.from_pretrained("CompVis/ldm-text2im-large-256")

>>> # Download pipeline that requires an authorization token
>>> # For more information on access tokens, please refer to this section
>>> # of the documentation](https://huggingface.co/docs/hub/security-tokens)
>>> pipeline = DiffusionPipeline.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5")

>>> # Use a different scheduler
>>> from diffusers import LMSDiscreteScheduler

>>> scheduler = LMSDiscreteScheduler.from_config(pipeline.scheduler.config)
>>> pipeline.scheduler = scheduler
```

#### maybe_free_model_hooks[[diffusers.DiffusionPipeline.maybe_free_model_hooks]]

```python
maybe_free_model_hooks()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1250)

Método que realiza lo siguiente:
- Descarga todos los componentes.
- Elimina todos los hooks del modelo que se añadieron al usar `enable_model_cpu_offload` y luego los aplica de nuevo. En caso de que el modelo no haya sido offloaded, esta función no hace nada.
- Restablece los hooks con estado de los componentes denoiser de diffusers si se añadieron con `register_hook()`.

Asegúrate de añadir esta función al final de la función `__call__` de tu pipeline para que funcione correctamente al aplicar `enable_model_cpu_offload`.

#### numpy_to_pil[[diffusers.DiffusionPipeline.numpy_to_pil]]

```python
numpy_to_pil(images)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1945)

Convierte una imagen de NumPy o un lote de imágenes en una imagen de PIL.

#### remove_all_hooks[[diffusers.DiffusionPipeline.remove_all_hooks]]

```python
remove_all_hooks()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1143)

Elimina todos los hooks que se añadieron al usar `enable_sequential_cpu_offload` o `enable_model_cpu_offload`.

#### reset_device_map[[diffusers.DiffusionPipeline.reset_device_map]]

```python
reset_device_map()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1470)

Restablece los mapas de dispositivos (si los hay) a None.

#### save_pretrained[[diffusers.DiffusionPipeline.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, use_flashpack: bool = False, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L254)

**Parámetros:**

save_directory (`str` o `os.PathLike`) : Directorio para guardar un 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 punto de control antes de ser fragmentado. Los fragmentos del punto de control tendrán cada uno un tamaño inferior a este valor. Si se expresa como una cadena de caracteres, debe consistir en dígitos seguidos de una unidad (como `"5GB"`). Si se expresa como un entero, la unidad es bytes. Tenga en cuenta que este límite se reducirá después de un cierto período de tiempo (a partir de octubre de 2024) para permitir a los usuarios actualizar a la última versión de `diffusers`. Esto se hace para establecer un tamaño predeterminado común para este argumento en diferentes bibliotecas del ecosistema de Hugging Face (`transformers` y `accelerate`, por ejemplo).

push_to_hub (`bool`, *opcional*, por defecto `False`) : Si se debe o no subir el modelo al Hugging Face model hub después de guardarlo. Puede especificar el repositorio al que desea subirlo con `repo_id` (por defecto, usará el nombre de `save_directory` en su espacio de nombres).

kwargs (`Dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se pasan al método [push_to_hub()](/docs/diffusers/v0.43.0/es/api/schedulers/overview#diffusers.utils.PushToHubMixin.push_to_hub).

Guarda todas las variables guardables del pipeline en un directorio. Una variable del pipeline se puede guardar y cargar si su clase implementa tanto un método de guardado como uno de carga. El pipeline se recarga fácilmente mediante el método de clase [from_pretrained()](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained).

#### diffusers.StableDiffusionMixin.enable_freeu[[diffusers.StableDiffusionMixin.enable_freeu]]

```python
diffusers.StableDiffusionMixin.enable_freeu(s1: float, s2: float, b1: float, b2: float)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2267)

**Parámetros:**

s1 (`float`) : Factor de escala para la etapa 1 para atenuar las contribuciones de las características de salto. Esto se hace para mitigar el "efecto de sobre-almohadillado" en el proceso de desruido mejorado.

s2 (`float`) : Factor de escala para la etapa 2 para atenuar las contribuciones de las características de salto. Esto se hace para mitigar el "efecto de sobre-almohadillado" en el proceso de desruido mejorado.

b1 (`float`) : Factor de escala para la etapa 1 para amplificar las contribuciones de las características del backbone.

b2 (`float`) : Factor de escala para la etapa 2 para amplificar las contribuciones de las características del backbone.

Activa el mecanismo FreeU tal como se describe en https://huggingface.co/papers/2309.11497.

Los sufijos después de los factores de escalado representan las etapas en las que se están aplicando.

Consulte el [repositorio oficial](https://github.com/ChenyangSi/FreeU) para conocer las combinaciones de valores que funcionan bien en diferentes pipelines, como Stable Diffusion v1, v2 y Stable Diffusion XL.

#### diffusers.StableDiffusionMixin.disable_freeu[[diffusers.StableDiffusionMixin.disable_freeu]]

```python
diffusers.StableDiffusionMixin.disable_freeu()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2289)

Desactiva el mecanismo FreeU si está habilitado.

## PushToHubMixin[[diffusers.utils.PushToHubMixin]]

#### diffusers.utils.PushToHubMixin[[diffusers.utils.PushToHubMixin]]

```python
diffusers.utils.PushToHubMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/utils/hub_utils.py#L491)

Un Mixin para subir un modelo, un programador o un pipeline al Hugging Face Hub.

#### push_to_hub[[diffusers.utils.PushToHubMixin.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, private: bool | None = None, token: str | None = None, create_pr: bool = False, safe_serialization: bool = True, variant: str | None = None, subfolder: str | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/utils/hub_utils.py#L526)

**Parámetros:**

repo_id (`str`) : El nombre del repositorio al que deseas subir tus archivos de modelo, programador o pipeline. Debe incluir el nombre de tu organización cuando subas a una organización. `repo_id` también puede ser una ruta a un directorio local.

commit_message (`str`, *opcional*) : Mensaje para el commit al hacer push. El valor predeterminado es `"Upload {object}"`.

private (`bool`, *opcional*) : Si se debe hacer el repositorio privado. Si es `None` (predeterminado), el repositorio será público a menos que el valor predeterminado de la organización sea privado. Este valor se ignora si el repositorio ya existe.

token (`str`, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. El token generado al ejecutar `hf auth login` (guardado en `~/.huggingface`).

create_pr (`bool`, *opcional*, por defecto `False`) : Si se debe crear una PR con los archivos subidos o realizar el commit directamente.

safe_serialization (`bool`, *opcional*, por defecto `True`) : Si se deben convertir o no los pesos del modelo al formato `safetensors`.

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

Sube archivos de modelo, programador o pipeline al 🤗 Hugging Face Hub.

Ejemplos:

```python
from diffusers import UNet2DConditionModel

unet = UNet2DConditionModel.from_pretrained("stabilityai/stable-diffusion-2", subfolder="unet")

# Push the `unet` to your namespace with the name "my-finetuned-unet".
unet.push_to_hub("my-finetuned-unet")

# Push the `unet` to an organization with the name "my-finetuned-unet".
unet.push_to_hub("your-org/my-finetuned-unet")
```

## Callbacks[[diffusers.callbacks.PipelineCallback]]

#### diffusers.callbacks.PipelineCallback[[diffusers.callbacks.PipelineCallback]]

```python
diffusers.callbacks.PipelineCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L7)

Clase base para todos los callbacks oficiales utilizados en un pipeline. Esta clase proporciona una estructura para implementar callbacks personalizados y garantiza que todos los callbacks tengan una interfaz coherente.

Implemente lo siguiente: `tensor_inputs`: debe devolver una lista de entradas de tensor específicas para su callback. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline. `callback_fn`: este método define la funcionalidad principal de su callback.

#### diffusers.callbacks.SDCFGCutoffCallback[[diffusers.callbacks.SDCFGCutoffCallback]]

```python
diffusers.callbacks.SDCFGCutoffCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L69)

Función de callback para las pipelines de Stable Diffusion. Después de un número determinado de pasos (establecido por `cutoff_step_ratio` o `cutoff_step_index`), este callback desactivará el CFG.

Nota: Este callback modifica el pipeline cambiando el atributo `_guidance_scale` a 0.0 después del paso de corte.

#### diffusers.callbacks.SDXLCFGCutoffCallback[[diffusers.callbacks.SDXLCFGCutoffCallback]]

```python
diffusers.callbacks.SDXLCFGCutoffCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L98)

Función de callback para las Pipelines base de Stable Diffusion XL. Después de un número determinado de pasos (establecido por `cutoff_step_ratio` o `cutoff_step_index`), este callback desactivará el CFG.

Nota: Este callback modifica el pipeline cambiando el atributo `_guidance_scale` a 0.0 después del paso de corte.

#### diffusers.callbacks.SDXLControlnetCFGCutoffCallback[[diffusers.callbacks.SDXLControlnetCFGCutoffCallback]]

```python
diffusers.callbacks.SDXLControlnetCFGCutoffCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L140)

Función de callback para las pipelines de Controlnet Stable Diffusion XL. Después de un número determinado de pasos (establecido por `cutoff_step_ratio` o `cutoff_step_index`), esta callback deshabilitará el CFG.

Nota: Este callback modifica el pipeline cambiando el atributo `_guidance_scale` a 0.0 después del paso de corte.

#### diffusers.callbacks.IPAdapterScaleCutoffCallback[[diffusers.callbacks.IPAdapterScaleCutoffCallback]]

```python
diffusers.callbacks.IPAdapterScaleCutoffCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L188)

Función de callback para cualquier pipeline que herede de `IPAdapterMixin`. Después de un número determinado de pasos (establecido por `cutoff_step_ratio` o `cutoff_step_index`), este callback establecerá la escala del IP Adapter en `0.0`.

Nota: Este callback modifica los procesadores de atención del IP Adapter estableciendo la escala en 0.0 después del paso de corte.

#### diffusers.callbacks.SD3CFGCutoffCallback[[diffusers.callbacks.SD3CFGCutoffCallback]]

```python
diffusers.callbacks.SD3CFGCutoffCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L212)

Función de callback para los pipelines de Stable Diffusion 3. Después de un número determinado de pasos (establecido por `cutoff_step_ratio` o `cutoff_step_index`), este callback desactivará el CFG.

Nota: Este callback modifica el pipeline cambiando el atributo `_guidance_scale` a 0.0 después del paso de corte.