# T2I-Adapter

[T2I-Adapter: Learning Adapters to Dig out More Controllable Ability for Text-to-Image Diffusion Models](https://huggingface.co/papers/2302.08453) de Chong Mou, Xintao Wang, Liangbin Xie, Jian Zhang, Zhongang Qi, Ying Shan, Xiaohu Qie.

Con los modelos preentrenados podemos proporcionar imágenes de control (por ejemplo, un mapa de profundidad) para controlar la generación de imágenes a partir de texto de Stable Diffusion, de modo que siga la estructura de la imagen de profundidad y complete los detalles.

El resumen del artículo es el siguiente:

*La increíble capacidad generativa de los modelos de texto a imagen (T2I) a gran escala ha demostrado un gran poder para aprender estructuras complejas y semánticas significativas. Sin embargo, depender únicamente de prompts de texto no permite aprovechar por completo el conocimiento aprendido por el modelo, especialmente cuando se necesita un control flexible y preciso (por ejemplo, de color y estructura). En este artículo, nos proponemos «extraer» las capacidades que los modelos T2I han aprendido de forma implícita y, a continuación, utilizarlas de manera explícita para controlar la generación de forma más granular. Específicamente, proponemos aprender T2I-Adapters simples y ligeros para alinear el conocimiento interno de los modelos T2I con señales de control externas, manteniendo congelados los modelos T2I originales. De esta manera, podemos entrenar varios adaptadores según diferentes condiciones, logrando efectos ricos de control y edición en el color y la estructura de los resultados generados. Además, los T2I-Adapters propuestos poseen propiedades de valor práctico, como la composabilidad y la capacidad de generalización. Experimentos extensos demuestran que nuestro T2I-Adapter ofrece una calidad de generación prometedora y una amplia gama de aplicaciones.*

Este modelo fue aportado por el colaborador de la comunidad [HimariO](https://github.com/HimariO) ❤️ .

## StableDiffusionAdapterPipeline[[diffusers.StableDiffusionAdapterPipeline]]

#### diffusers.StableDiffusionAdapterPipeline[[diffusers.StableDiffusionAdapterPipeline]]

```python
diffusers.StableDiffusionAdapterPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, adapter: diffusers.models.adapter.T2IAdapter | diffusers.models.adapter.MultiAdapter | list[diffusers.models.adapter.T2IAdapter], scheduler: KarrasDiffusionSchedulers, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, requires_safety_checker: bool = True)
```

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

**Parámetros:**

adapter (`T2IAdapter` o `MultiAdapter` o `list[T2IAdapter]`) : Proporciona una condición adicional al unet durante el proceso de desruido. Si configuras varios Adapter como una lista, las salidas de cada Adapter se suman para crear una condición adicional combinada.

adapter_weights (`list[float]`, *opcional*, valor predeterminado None) : lista de flotantes que representa el peso que se multiplicará a la salida de cada adaptador antes de sumarlos.

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder (`CLIPTextModel`) : Codificador de texto congelado. Stable Diffusion utiliza la parte de texto de [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), específicamente la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).

tokenizer (`CLIPTokenizer`) : Tokenizador de la clase [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).

unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitectura de U-Net condicional para desruidar los latentes de imagen codificados.

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Puede ser uno de [DDIMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/pndm#diffusers.PNDMScheduler).

safety_checker (`StableDiffusionSafetyChecker`) : Módulo de clasificación que estima si las imágenes generadas podrían considerarse ofensivas o dañinas. Consulte la [ficha del modelo](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) para obtener más detalles.

feature_extractor (`CLIPImageProcessor`) : Modelo que extrae características de las imágenes generadas para usarlas como entradas del `safety_checker`.

Pipeline para la generación de imágenes a partir de texto usando Stable Diffusion aumentado con T2I-Adapter https://huggingface.co/papers/2302.08453

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la ejecución en un dispositivo específico, etc.)

#### __call__[[diffusers.StableDiffusionAdapterPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, image: typing.Union[torch.Tensor, PIL.Image.Image, list[PIL.Image.Image]] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, guidance_scale: float = 7.5, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, cross_attention_kwargs: dict[str, typing.Any] | None = None, adapter_conditioning_scale: float | list[float] = 1.0, clip_skip: int | None = None)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.

image (`torch.Tensor`, `PIL.Image.Image`, `list[torch.Tensor]` o `list[PIL.Image.Image]` o `list[list[PIL.Image.Image]]`) : La condición de entrada del Adapter. El Adapter utiliza esta condición de entrada para generar la guía para Unet. Si el tipo se especifica como `torch.Tensor`, se pasa al Adapter tal cual. También se puede aceptar PIL.Image.Image` como imagen. La imagen de control se redimensiona automáticamente para que quepa en la imagen de salida.

height (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : La altura en píxeles de la imagen generada.

width (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : El ancho en píxeles de la imagen generada.

num_inference_steps (`int`, *opcional*, valor predeterminado 50) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento `sigmas` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`.

guidance_scale (`float`, *opcional*, valor predeterminado 7.5) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de orientación se habilita estableciendo `guidance_scale > 1`. Una escala de orientación más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación.

eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) en el artículo de DDIM: https://huggingface.co/papers/2010.02502. Solo se aplica a [schedulers.DDIMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/ddim#diffusers.DDIMScheduler), se ignorará en los demás.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.stable_diffusion.StableDiffusionAdapterPipelineOutput` en lugar de una tupla simple.

callback (`Callable`, *opcional*) : Una función que se llamará cada `callback_steps` pasos durante la inferencia. La función se llamará con los siguientes argumentos: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *opcional*, valor predeterminado 1) : La frecuencia con la que se llamará a la función `callback`. Si no se especifica, la callback se llamará en cada paso.

cross_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttnProcessor` tal como se define en `self.processor` dentro de [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

adapter_conditioning_scale (`float` o `list[float]`, *opcional*, valor predeterminado 1.0) : Las salidas del adaptador se multiplican por `adapter_conditioning_scale` antes de sumarse al residual en el unet original. Si se especifican varios adaptadores en init, puedes establecer la escala correspondiente como una lista.

clip_skip (`int`, *opcional*) : Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la capa previa a la final para calcular los embeddings del prompt.

**Devuelve:** `~pipelines.stable_diffusion.StableDiffusionAdapterPipelineOutput` o `tuple`

`~pipelines.stable_diffusion.StableDiffusionAdapterPipelineOutput` if `return_dict` is True, otherwise a `tuple. When returning a tuple, the first element is a list with the generated images, and the second element is a list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work" (nsfw) content, according to the `safety_checker`.

Función invocada al llamar a la pipeline para la generación.

Ejemplos:
```py
>>> from PIL import Image
>>> from diffusers.utils import load_image
>>> import torch
>>> from diffusers import StableDiffusionAdapterPipeline, T2IAdapter

>>> image = load_image(
...     "https://huggingface.co/datasets/diffusers/docs-images/resolve/main/t2i-adapter/color_ref.png"
... )

>>> color_palette = image.resize((8, 8))
>>> color_palette = color_palette.resize((512, 512), resample=Image.Resampling.NEAREST)

>>> adapter = T2IAdapter.from_pretrained("TencentARC/t2iadapter_color_sd14v1", torch_dtype=torch.float16)
>>> pipe = StableDiffusionAdapterPipeline.from_pretrained(
...     "CompVis/stable-diffusion-v1-4",
...     adapter=adapter,
...     torch_dtype=torch.float16,
... )

>>> pipe.to("cuda")

>>> out_image = pipe(
...     "At night, glowing cubes in front of the beach",
...     image=color_palette,
... ).images[0]
```

#### enable_attention_slicing[[diffusers.StableDiffusionAdapterPipeline.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]
```

#### disable_attention_slicing[[diffusers.StableDiffusionAdapterPipeline.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.

#### enable_xformers_memory_efficient_attention[[diffusers.StableDiffusionAdapterPipeline.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)
```

#### disable_xformers_memory_efficient_attention[[diffusers.StableDiffusionAdapterPipeline.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/).

#### encode_prompt[[diffusers.StableDiffusionAdapterPipeline.encode_prompt]]

```python
encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

device : (`torch.device`): dispositivo de torch

num_images_per_prompt (`int`) : número de imágenes que deben generarse por prompt

do_classifier_free_guidance (`bool`) : si se debe usar o no la guía libre de clasificador

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

lora_scale (`float`, *opcional*) : Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.

clip_skip (`int`, *opcional*) : Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la capa previa a la final para calcular los embeddings del prompt.

Codifica el prompt en estados ocultos del codificador de texto.

#### get_guidance_scale_embedding[[diffusers.StableDiffusionAdapterPipeline.get_guidance_scale_embedding]]

```python
get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32)
```

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

**Parámetros:**

w (`torch.Tensor`) : Genera vectores de incrustación con una escala de guía especificada para enriquecer posteriormente las incrustaciones de paso temporal.

embedding_dim (`int`, *opcional*, valor predeterminado 512) : Dimensión de las incrustaciones a generar.

dtype (`torch.dtype`, *opcional*, valor predeterminado `torch.float32`) : Tipo de datos de los embeddings generados.

**Devuelve:** `torch.Tensor`

Vectores de incrustación con forma `(len(w), embedding_dim)`.

Ver https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298

## StableDiffusionXLAdapterPipeline[[diffusers.StableDiffusionXLAdapterPipeline]]

#### diffusers.StableDiffusionXLAdapterPipeline[[diffusers.StableDiffusionXLAdapterPipeline]]

```python
diffusers.StableDiffusionXLAdapterPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, text_encoder_2: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, tokenizer_2: CLIPTokenizer, unet: UNet2DConditionModel, adapter: diffusers.models.adapter.T2IAdapter | diffusers.models.adapter.MultiAdapter | list[diffusers.models.adapter.T2IAdapter], scheduler: KarrasDiffusionSchedulers, force_zeros_for_empty_prompt: bool = True, feature_extractor: CLIPImageProcessorPil = None, image_encoder: CLIPVisionModelWithProjection = None)
```

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

**Parámetros:**

adapter (`T2IAdapter` o `MultiAdapter` o `list[T2IAdapter]`) : Proporciona una condición adicional al unet durante el proceso de desruido. Si configuras varios Adapter como una lista, las salidas de cada Adapter se suman para crear una condición adicional combinada.

adapter_weights (`list[float]`, *opcional*, valor predeterminado None) : lista de flotantes que representa el peso que se multiplicará a la salida de cada adaptador antes de sumarlos.

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder (`CLIPTextModel`) : Codificador de texto congelado. Stable Diffusion utiliza la parte de texto de [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), específicamente la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).

tokenizer (`CLIPTokenizer`) : Tokenizador de la clase [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).

unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitectura de U-Net condicional para desruidar los latentes de imagen codificados.

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Puede ser uno de [DDIMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/pndm#diffusers.PNDMScheduler).

safety_checker (`StableDiffusionSafetyChecker`) : Módulo de clasificación que estima si las imágenes generadas podrían considerarse ofensivas o dañinas. Consulte la [ficha del modelo](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) para obtener más detalles.

feature_extractor (`CLIPImageProcessor`) : Modelo que extrae características de las imágenes generadas para usarlas como entradas del `safety_checker`.

Pipeline para la generación de imágenes a partir de texto usando Stable Diffusion aumentado con T2I-Adapter https://huggingface.co/papers/2302.08453

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la ejecución en un dispositivo específico, etc.)

El pipeline también hereda los siguientes métodos de carga:
- [load_textual_inversion()](/docs/diffusers/v0.43.0/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual
- [from_single_file()](/docs/diffusers/v0.43.0/es/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) para la carga de archivos `.ckpt`
- [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA
- [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA
- [load_ip_adapter()](/docs/diffusers/v0.43.0/es/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para cargar IP Adapters

#### __call__[[diffusers.StableDiffusionXLAdapterPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, denoising_end: float | None = None, guidance_scale: float = 5.0, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, cross_attention_kwargs: dict[str, typing.Any] | None = None, guidance_rescale: float = 0.0, original_size: tuple[int, int] | None = None, crops_coords_top_left: tuple[int, int] = (0, 0), target_size: tuple[int, int] | None = None, negative_original_size: tuple[int, int] | None = None, negative_crops_coords_top_left: tuple[int, int] = (0, 0), negative_target_size: tuple[int, int] | None = None, adapter_conditioning_scale: float | list[float] = 1.0, adapter_conditioning_factor: float = 1.0, clip_skip: int | None = None)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.

prompt_2 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que se enviarán al `tokenizer_2` y al `text_encoder_2`. Si no se define, se utiliza `prompt` en ambos text-encoders

image (`torch.Tensor`, `PIL.Image.Image`, `list[torch.Tensor]` o `list[PIL.Image.Image]` o `list[list[PIL.Image.Image]]`) : La condición de entrada del Adapter. El Adapter utiliza esta condición de entrada para generar la guía para Unet. Si el tipo se especifica como `torch.Tensor`, se pasa al Adapter tal cual. También se puede aceptar PIL.Image.Image` como imagen. La imagen de control se redimensiona automáticamente para que quepa en la imagen de salida.

height (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : La altura en píxeles de la imagen generada. Cualquier valor inferior a 512 píxeles no funcionará bien con [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) ni con puntos de control que no estén específicamente afinados en resoluciones bajas.

width (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : El ancho en píxeles de la imagen generada. Cualquier valor inferior a 512 píxeles no funcionará bien con [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) ni con puntos de control que no estén específicamente afinados en resoluciones bajas.

num_inference_steps (`int`, *opcional*, valor predeterminado 50) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento `sigmas` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`.

denoising_end (`float`, *opcional*) : Cuando se especifica, determina la fracción (entre 0.0 y 1.0) del proceso total de desruido que debe completarse antes de que se termine prematuramente de forma intencional. Como resultado, la muestra devuelta aún conservará una cantidad sustancial de ruido, tal como lo determinan los pasos discretos seleccionados por el programador. El parámetro denoising_end debería utilizarse idealmente cuando esta pipeline forma parte de una configuración multipipeline de "Mixture of Denoisers", como se detalla en [**Refining the Image Output**](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/stable_diffusion_xl#refining-the-image-output)

guidance_scale (`float`, *opcional*, valor predeterminado 5.0) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de orientación se habilita estableciendo `guidance_scale > 1`. Una escala de orientación más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

negative_prompt_2 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen y que se enviarán a `tokenizer_2` y `text_encoder_2`. Si no se define, `negative_prompt` se utiliza en ambos text-encoders

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación.

eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) en el artículo de DDIM: https://huggingface.co/papers/2010.02502. Solo se aplica a [schedulers.DDIMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/ddim#diffusers.DDIMScheduler), se ignorará en los demás.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, los embeddings de texto agrupados se generarán a partir del argumento de entrada `prompt`.

negative_pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, los pooled negative_prompt_embeds se generarán a partir del argumento de entrada `negative_prompt`.

ip_adapter_image : (`PipelineImageInput`, *opcional*): Entrada de imagen opcional para trabajar con IP Adapters.

ip_adapter_image_embeds (`list[torch.Tensor]`, *opcional*) : Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma `(batch_size, num_images, emb_dim)`. Debe contener la incrustación de imagen negativa si `do_classifier_free_guidance` está establecido en `True`. Si no se proporciona, las incrustaciones se calculan a partir del argumento de entrada `ip_adapter_image`.

output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.stable_diffusion_xl.StableDiffusionAdapterPipelineOutput` en lugar de una tupla simple.

callback (`Callable`, *opcional*) : Una función que se llamará cada `callback_steps` pasos durante la inferencia. La función se llamará con los siguientes argumentos: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *opcional*, valor predeterminado 1) : La frecuencia con la que se llamará a la función `callback`. Si no se especifica, la callback se llamará en cada paso.

cross_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

guidance_rescale (`float`, *opcional*, valor predeterminado 0.0) : Factor de reescalado de guía propuesto por [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) `guidance_scale` se define como `φ` en la ecuación 16. de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). El factor de reescalado de guía debe corregir la sobreexposición al usar SNR terminal cero.

original_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Si `original_size` no es igual a `target_size`, la imagen parecerá haber sido reescalada hacia abajo o hacia arriba. `original_size` tiene como valor predeterminado `(height, width)` si no se especifica. Parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952).

crops_coords_top_left (`tuple[int]`, *opcional*, valor predeterminado (0, 0)) : `crops_coords_top_left` se puede utilizar para generar una imagen que parezca "recortada" desde la posición `crops_coords_top_left` hacia abajo. Generalmente, se logran imágenes favorables y bien centradas estableciendo `crops_coords_top_left` en (0, 0). Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952).

target_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : En la mayoría de los casos, `target_size` debe establecerse en la altura y el ancho deseados de la imagen generada. Si no se especifica, el valor predeterminado será `(height, width)`. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952).

negative_original_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de una resolución de imagen específica. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208.

negative_crops_coords_top_left (`tuple[int]`, *opcional*, valor predeterminado (0, 0)) : Para condicionar negativamente el proceso de generación en función de unas coordenadas de recorte específicas. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208.

negative_target_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de la resolución de imagen objetivo. Debe ser igual que `target_size` en la mayoría de los casos. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208.

adapter_conditioning_scale (`float` o `list[float]`, *opcional*, valor predeterminado 1.0) : Las salidas del adaptador se multiplican por `adapter_conditioning_scale` antes de sumarse al residual en el unet original. Si se especifican varios adaptadores en init, puedes establecer la escala correspondiente como una lista.

adapter_conditioning_factor (`float`, *opcional*, valor predeterminado 1.0) : La fracción de pasos de tiempo para los que se debe aplicar el adaptador. Si `adapter_conditioning_factor` es `0.0`, el adaptador no se aplica en absoluto. Si `adapter_conditioning_factor` es `1.0`, el adaptador se aplica para todos los pasos de tiempo. Si `adapter_conditioning_factor` es `0.5`, el adaptador se aplica para la mitad de los pasos de tiempo.

clip_skip (`int`, *opcional*) : Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la capa previa a la final para calcular los embeddings del prompt.

**Devuelve:** `~pipelines.stable_diffusion.StableDiffusionAdapterPipelineOutput` o `tuple`

`~pipelines.stable_diffusion.StableDiffusionAdapterPipelineOutput` si `return_dict` es True, de lo contrario una `tuple`. Al devolver una tupla, el primer elemento es una lista con las imágenes generadas.

Función invocada al llamar a la pipeline para la generación.

Ejemplos:
```py
>>> import torch
>>> from diffusers import T2IAdapter, StableDiffusionXLAdapterPipeline, DDPMScheduler
>>> from diffusers.utils import load_image

>>> sketch_image = load_image("https://huggingface.co/Adapter/t2iadapter/resolve/main/sketch.png").convert("L")

>>> model_id = "stabilityai/stable-diffusion-xl-base-1.0"

>>> adapter = T2IAdapter.from_pretrained(
...     "Adapter/t2iadapter",
...     subfolder="sketch_sdxl_1.0",
...     torch_dtype=torch.float16,
...     adapter_type="full_adapter_xl",
... )
>>> scheduler = DDPMScheduler.from_pretrained(model_id, subfolder="scheduler")

>>> pipe = StableDiffusionXLAdapterPipeline.from_pretrained(
...     model_id, adapter=adapter, torch_dtype=torch.float16, variant="fp16", scheduler=scheduler
... ).to("cuda")

>>> generator = torch.manual_seed(42)
>>> sketch_image_out = pipe(
...     prompt="a photo of a dog in real world, high quality",
...     negative_prompt="extra digit, fewer digits, cropped, worst quality, low quality",
...     image=sketch_image,
...     generator=generator,
...     guidance_scale=7.5,
... ).images[0]
```

#### enable_attention_slicing[[diffusers.StableDiffusionXLAdapterPipeline.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]
```

#### disable_attention_slicing[[diffusers.StableDiffusionXLAdapterPipeline.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.

#### enable_xformers_memory_efficient_attention[[diffusers.StableDiffusionXLAdapterPipeline.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)
```

#### disable_xformers_memory_efficient_attention[[diffusers.StableDiffusionXLAdapterPipeline.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/).

#### encode_prompt[[diffusers.StableDiffusionXLAdapterPipeline.encode_prompt]]

```python
encode_prompt(prompt: str, prompt_2: str | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | None = None, negative_prompt_2: str | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

prompt_2 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que se enviarán al `tokenizer_2` y al `text_encoder_2`. Si no se define, se utiliza `prompt` en ambos text-encoders

device : (`torch.device`): dispositivo de torch

num_images_per_prompt (`int`) : número de imágenes que deben generarse por prompt

do_classifier_free_guidance (`bool`) : si se debe usar o no la guía libre de clasificador

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

negative_prompt_2 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen y que se enviarán a `tokenizer_2` y `text_encoder_2`. Si no se define, `negative_prompt` se utiliza en ambos text-encoders

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, los embeddings de texto agrupados se generarán a partir del argumento de entrada `prompt`.

negative_pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, los pooled negative_prompt_embeds se generarán a partir del argumento de entrada `negative_prompt`.

lora_scale (`float`, *opcional*) : Una escala lora que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.

clip_skip (`int`, *opcional*) : Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la capa previa a la final para calcular los embeddings del prompt.

Codifica el prompt en estados ocultos del codificador de texto.

#### get_guidance_scale_embedding[[diffusers.StableDiffusionXLAdapterPipeline.get_guidance_scale_embedding]]

```python
get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32)
```

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

**Parámetros:**

w (`torch.Tensor`) : Genera vectores de incrustación con una escala de guía especificada para enriquecer posteriormente las incrustaciones de paso temporal.

embedding_dim (`int`, *opcional*, valor predeterminado 512) : Dimensión de las incrustaciones a generar.

dtype (`torch.dtype`, *opcional*, valor predeterminado `torch.float32`) : Tipo de datos de los embeddings generados.

**Devuelve:** `torch.Tensor`

Vectores de incrustación con forma `(len(w), embedding_dim)`.

Ver https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298