# ControlNet

  

ControlNet se introdujo en [Adding Conditional Control to Text-to-Image Diffusion Models](https://huggingface.co/papers/2302.05543) por Lvmin Zhang, Anyi Rao y Maneesh Agrawala.

Con un modelo de ControlNet, puedes proporcionar una imagen de control adicional para condicionar y controlar la generación de Stable Diffusion. Por ejemplo, si proporcionas un mapa de profundidad, el modelo de ControlNet genera una imagen que preservará la información espacial del mapa de profundidad. Es una forma más flexible y precisa de controlar el proceso de generación de imágenes.

El resumen del artículo es:

*Presentamos ControlNet, una arquitectura de red neuronal para añadir controles de condicionamiento espacial a grandes modelos de difusión de texto a imagen preentrenados. ControlNet bloquea los grandes modelos de difusión listos para producción y reutiliza sus capas de codificación profundas y robustas, preentrenadas con miles de millones de imágenes, como una base sólida para aprender un conjunto diverso de controles condicionales. La arquitectura neuronal se conecta mediante "convoluciones cero" (capas de convolución inicializadas en cero) que hacen crecer progresivamente los parámetros desde cero y garantizan que ningún ruido perjudicial pueda afectar el ajuste fino. Probamos varios controles de condicionamiento, por ejemplo, bordes, profundidad, segmentación, pose humana, etc., con Stable Diffusion, utilizando una o varias condiciones, con o sin indicaciones. Mostramos que el entrenamiento de ControlNets es robusto con conjuntos de datos pequeños (<50k) y grandes (>1m). Resultados extensos muestran que ControlNet puede facilitar aplicaciones más amplias para controlar los modelos de difusión de imágenes.*

Este modelo fue aportado por [takuma104](https://huggingface.co/takuma104). ❤️

El código original se encuentra en [lllyasviel/ControlNet](https://github.com/lllyasviel/ControlNet), y puedes encontrar los puntos de control oficiales de ControlNet en el perfil de Hub de [lllyasviel](https://huggingface.co/lllyasviel).

> [!TIP]
> Asegúrate de consultar la [guía de Schedulers](../../using-diffusers/schedulers) para aprender a explorar el equilibrio entre la velocidad y la calidad del scheduler, y consulta la sección [reutilizar componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a cargar eficientemente los mismos componentes en múltiples pipelines.

## StableDiffusionControlNetPipeline[[diffusers.StableDiffusionControlNetPipeline]]

#### diffusers.StableDiffusionControlNetPipeline[[diffusers.StableDiffusionControlNetPipeline]]

```python
diffusers.StableDiffusionControlNetPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, controlnet: diffusers.models.controlnets.controlnet.ControlNetModel | list[diffusers.models.controlnets.controlnet.ControlNetModel] | tuple[diffusers.models.controlnets.controlnet.ControlNetModel] | diffusers.models.controlnets.multicontrolnet.MultiControlNetModel, scheduler: KarrasDiffusionSchedulers, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: CLIPVisionModelWithProjection = None, requires_safety_checker: bool = True)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/controlnet/pipeline_controlnet.py#L162)

**Parámetros:**

vae ([AutoencoderKL](/docs/diffusers/main/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](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` para tokenizar texto.

unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Un `UNet2DConditionModel` para desruidar los latentes de imagen codificados.

controlnet ([ControlNetModel](/docs/diffusers/main/es/api/models/controlnet#diffusers.ControlNetModel) o `list[ControlNetModel]`) : Proporciona una condición adicional al `unet` durante el proceso de desruido. Si configuras varios ControlNet como una lista, las salidas de cada ControlNet se suman para crear una condición adicional combinada.

scheduler ([SchedulerMixin](/docs/diffusers/main/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/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/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 sobre los posibles daños de un modelo.

feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : Un `CLIPImageProcessor` para extraer características de las imágenes generadas; se utiliza como entrada para el `safety_checker`.

Pipeline para la generación de imágenes a partir de texto usando Stable Diffusion con la guía de ControlNet.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).

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

#### __call__[[diffusers.StableDiffusionControlNetPipeline.__call__]]

```python
__call__(prompt: str | list[str] = 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 = None, sigmas: list = 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, 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, cross_attention_kwargs: dict[str, typing.Any] | None = None, controlnet_conditioning_scale: float | list[float] = 1.0, guess_mode: bool = False, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, clip_skip: int | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list = ['latents'], **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/controlnet/pipeline_controlnet.py#L907)

**Parámetros:**

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

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, `list[np.ndarray]`, : `list[list[torch.Tensor]]`, `list[list[np.ndarray]]` o `list[list[PIL.Image.Image]]`): La condición de entrada de ControlNet para proporcionar orientación a la `unet` durante la generación. Si el tipo se especifica como `torch.Tensor`, se pasa a ControlNet tal cual. También se puede aceptar `PIL.Image.Image` como imagen. Las dimensiones de la imagen de salida son, por defecto, las dimensiones de `image`. Si se pasan la altura y/o el ancho, `image` se redimensiona en consecuencia. Si se especifican varios ControlNets en `init`, las imágenes deben pasarse como una lista para que cada elemento de la lista pueda agruparse correctamente como entrada para un solo ControlNet. Cuando `prompt` es una lista y se pasa una lista de imágenes para un solo ControlNet, cada una se emparejará con cada prompt de la lista `prompt`. Esto también se aplica a varios ControlNets, donde se puede pasar una lista de listas de imágenes para agruparlas para cada prompt y cada ControlNet.

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

width (`int`, *opcional*, valor predeterminado `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) : Un valor más alto de la escala de guía anima al modelo a generar imágenes estrechamente vinculadas al `prompt` de texto a costa de una menor calidad de imagen. La escala de guía se habilita cuando `guidance_scale > 1`.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar lo que no debe incluirse en la generación de la imagen. Si no se define, debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale < 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 (η) del artículo [DDIM](https://huggingface.co/papers/2010.02502). Solo se aplica al [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler) y se ignora en otros programadores.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](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 proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan 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.Image` o `np.array`.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) en lugar de una tupla simple.

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

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

guess_mode (`bool`, *opcional*, valor predeterminado `False`) : El codificador de ControlNet intenta reconocer el contenido de la imagen de entrada incluso si eliminas todos los prompts. Se recomienda un valor de `guidance_scale` entre 3.0 y 5.0.

control_guidance_start (`float` o `list[float]`, *opcional*, valor predeterminado 0.0) : El porcentaje de pasos totales en el que ControlNet comienza a aplicarse.

control_guidance_end (`float` o `list[float]`, *opcional*, valor predeterminado 1.0) : El porcentaje de pasos totales en el que ControlNet deja de aplicarse.

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.

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

**Devuelve:** [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) o `tuple`

Si `return_dict` es `True`, se devuelve [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw).

La función de llamada para el pipeline de generación.

Ejemplos:
```py
>>> # !pip install opencv-python transformers accelerate
>>> from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, UniPCMultistepScheduler
>>> from diffusers.utils import load_image
>>> import numpy as np
>>> import torch

>>> import cv2
>>> from PIL import Image

>>> # download an image
>>> image = load_image(
...     "https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
... )
>>> image = np.array(image)

>>> # get canny image
>>> image = cv2.Canny(image, 100, 200)
>>> image = image[:, :, None]
>>> image = np.concatenate([image, image, image], axis=2)
>>> canny_image = Image.fromarray(image)

>>> # load control net and stable diffusion v1-5
>>> controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny", torch_dtype=torch.float16)
>>> pipe = StableDiffusionControlNetPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5", controlnet=controlnet, torch_dtype=torch.float16
... )

>>> # speed up diffusion process with faster scheduler and memory optimization
>>> pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
>>> # remove following line if xformers is not installed
>>> pipe.enable_xformers_memory_efficient_attention()

>>> pipe.enable_model_cpu_offload()

>>> # generate image
>>> generator = torch.manual_seed(0)
>>> image = pipe(
...     "futuristic-looking woman", num_inference_steps=20, generator=generator, image=canny_image
... ).images[0]
```

#### enable_attention_slicing[[diffusers.StableDiffusionControlNetPipeline.enable_attention_slicing]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2048)

**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.StableDiffusionControlNetPipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2085)

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.StableDiffusionControlNetPipeline.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/main/src/diffusers/pipelines/pipeline_utils.py#L1993)

**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.StableDiffusionControlNetPipeline.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2024)

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

#### load_textual_inversion[[diffusers.StableDiffusionControlNetPipeline.load_textual_inversion]]

```python
load_textual_inversion(pretrained_model_name_or_path: str | list[str] | dict[str, torch.Tensor] | list[dict[str, torch.Tensor]], token: str | list[str] | None = None, tokenizer: 'PreTrainedTokenizer' | None = None, text_encoder: 'PreTrainedModel' | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/textual_inversion.py#L271)

**Parámetros:**

pretrained_model_name_or_path (`str` o `os.PathLike` o `list[str or os.PathLike]` o `Dict` o `list[Dict]`) : Puede ser cualquiera de los siguientes o una lista de ellos:  - Una cadena de texto, el *model id* (por ejemplo `sd-concepts-library/low-poly-hd-logos-icons`) de un modelo preentrenado alojado en el Hub. - Una ruta a un *directorio* (por ejemplo `./my_text_inversion_directory/`) que contiene los pesos de textual inversion. - Una ruta a un *archivo* (por ejemplo `./my_text_inversions.pt`) que contiene pesos de textual inversion. - Un [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict).

token (`str` o `list[str]`, *opcional*) : Anula el token que se usará para los pesos de inversión textual. Si `pretrained_model_name_or_path` es una lista, `token` también debe ser una lista de la misma longitud.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel), *opcional*) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). Si no se especifica, la función tomará self.tokenizer.

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer), *opcional*) : Un `CLIPTokenizer` para tokenizar texto. Si no se especifica, la función tomará self.tokenizer.

weight_name (`str`, *opcional*) : Nombre de un archivo de pesos personalizado. Debe usarse cuando: - El archivo de inversión textual guardado está en formato 🤗 Diffusers, pero se guardó con un nombre de pesos específico como `text_inv.bin`. - El archivo de inversión textual guardado está en formato Automatic1111.

cache_dir (`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.

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.

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.

hf_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.

subfolder (`str`, *opcional*, valor predeterminado `""`) : La ubicación de la subcarpeta de un archivo de modelo dentro de un repositorio de modelos más grande en el Hub o localmente.

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.

Carga los embeddings de Textual Inversion en el codificador de texto de [StableDiffusionPipeline](/docs/diffusers/main/es/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) (se admiten tanto el formato de 🤗 Diffusers como el de Automatic1111).

Ejemplo:

Para cargar un vector de incrustación de Textual Inversion en formato 🤗 Diffusers:

```py
from diffusers import StableDiffusionPipeline
import torch

model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")

pipe.load_textual_inversion("sd-concepts-library/cat-toy")

prompt = "A <cat-toy> backpack"

image = pipe(prompt, num_inference_steps=50).images[0]
image.save("cat-backpack.png")
```

Para cargar un vector de incrustación de Textual Inversion en formato Automatic1111, asegúrese de descargar primero el vector (por ejemplo, desde [civitAI](https://civitai.com/models/3036?modelVersionId=9857)) y luego cargar el vector

localmente:

```py
from diffusers import StableDiffusionPipeline
import torch

model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")

pipe.load_textual_inversion("./charturnerv2.pt", token="charturnerv2")

prompt = "charturnerv2, multiple views of the same character in the same outfit, a character turnaround of a woman wearing a black jacket and red shirt, best quality, intricate details."

image = pipe(prompt, num_inference_steps=50).images[0]
image.save("character.png")
```

#### encode_prompt[[diffusers.StableDiffusionControlNetPipeline.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/main/src/diffusers/pipelines/controlnet/pipeline_controlnet.py#L298)

**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.StableDiffusionControlNetPipeline.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/main/src/diffusers/pipelines/controlnet/pipeline_controlnet.py#L850)

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

## StableDiffusionControlNetImg2ImgPipeline[[diffusers.StableDiffusionControlNetImg2ImgPipeline]]

#### diffusers.StableDiffusionControlNetImg2ImgPipeline[[diffusers.StableDiffusionControlNetImg2ImgPipeline]]

```python
diffusers.StableDiffusionControlNetImg2ImgPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, controlnet: diffusers.models.controlnets.controlnet.ControlNetModel | list[diffusers.models.controlnets.controlnet.ControlNetModel] | tuple[diffusers.models.controlnets.controlnet.ControlNetModel] | diffusers.models.controlnets.multicontrolnet.MultiControlNetModel, scheduler: KarrasDiffusionSchedulers, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: CLIPVisionModelWithProjection = None, requires_safety_checker: bool = True)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/controlnet/pipeline_controlnet_img2img.py#L140)

**Parámetros:**

vae ([AutoencoderKL](/docs/diffusers/main/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](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` para tokenizar texto.

unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Un `UNet2DConditionModel` para desruidar los latentes de imagen codificados.

controlnet ([ControlNetModel](/docs/diffusers/main/es/api/models/controlnet#diffusers.ControlNetModel) o `list[ControlNetModel]`) : Proporciona una condición adicional al `unet` durante el proceso de desruido. Si configuras varios ControlNet como una lista, las salidas de cada ControlNet se suman para crear una condición adicional combinada.

scheduler ([SchedulerMixin](/docs/diffusers/main/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/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/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 sobre los posibles daños de un modelo.

feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : Un `CLIPImageProcessor` para extraer características de las imágenes generadas; se utiliza como entrada para el `safety_checker`.

Pipeline para la generación de imagen a imagen usando Stable Diffusion con la guía de ControlNet.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).

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

#### __call__[[diffusers.StableDiffusionControlNetImg2ImgPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, control_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, strength: float = 0.8, num_inference_steps: int = 50, 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, 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, cross_attention_kwargs: dict[str, typing.Any] | None = None, controlnet_conditioning_scale: float | list[float] = 0.8, guess_mode: bool = False, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, clip_skip: int | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list = ['latents'], **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/controlnet/pipeline_controlnet_img2img.py#L905)

**Parámetros:**

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

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, `list[np.ndarray]`, : `list[list[torch.Tensor]]`, `list[list[np.ndarray]]` o `list[list[PIL.Image.Image]]`): La imagen inicial que se utilizará como punto de partida para el proceso de generación de imágenes. También puede aceptar latentes de imagen como `image`, y si se pasan latentes directamente, no se codifican de nuevo.

control_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, `list[np.ndarray]`, : `list[list[torch.Tensor]]`, `list[list[np.ndarray]]` o `list[list[PIL.Image.Image]]`): La condición de entrada de ControlNet para proporcionar orientación a la `unet` durante la generación. Si el tipo se especifica como `torch.Tensor`, se pasa a ControlNet tal cual. También se puede aceptar `PIL.Image.Image` como imagen. Las dimensiones de la imagen de salida son, por defecto, las dimensiones de `image`. Si se pasan la altura y/o el ancho, `image` se redimensiona en consecuencia. Si se especifican varios ControlNets en `init`, las imágenes deben pasarse como una lista para que cada elemento de la lista pueda agruparse correctamente como entrada para un solo ControlNet.

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

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

strength (`float`, *opcional*, valor predeterminado 0.8) : Indica el grado en que se transforma la `image` de referencia. Debe estar entre 0 y 1. `image` se utiliza como punto de partida y se añade más ruido a medida que aumenta el `strength`. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuando `strength` es 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado en `num_inference_steps`. Un valor de 1 ignora esencialmente `image`.

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.

guidance_scale (`float`, *opcional*, valor predeterminado 7.5) : Un valor más alto de la escala de guía anima al modelo a generar imágenes estrechamente vinculadas al `prompt` de texto a costa de una menor calidad de imagen. La escala de guía se habilita cuando `guidance_scale > 1`.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar lo que no debe incluirse en la generación de la imagen. Si no se define, debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale < 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 (η) del artículo [DDIM](https://huggingface.co/papers/2010.02502). Solo se aplica al [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler) y se ignora en otros programadores.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](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 proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan 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.Image` o `np.array`.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) en lugar de una tupla simple.

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

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

guess_mode (`bool`, *opcional*, valor predeterminado `False`) : El codificador de ControlNet intenta reconocer el contenido de la imagen de entrada incluso si eliminas todos los prompts. Se recomienda un valor de `guidance_scale` entre 3.0 y 5.0.

control_guidance_start (`float` o `list[float]`, *opcional*, valor predeterminado 0.0) : El porcentaje de pasos totales en el que ControlNet comienza a aplicarse.

control_guidance_end (`float` o `list[float]`, *opcional*, valor predeterminado 1.0) : El porcentaje de pasos totales en el que ControlNet deja de aplicarse.

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.

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

**Devuelve:** [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) o `tuple`

Si `return_dict` es `True`, se devuelve [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw).

La función de llamada para el pipeline de generación.

Ejemplos:
```py
>>> # !pip install opencv-python transformers accelerate
>>> from diffusers import StableDiffusionControlNetImg2ImgPipeline, ControlNetModel, UniPCMultistepScheduler
>>> from diffusers.utils import load_image
>>> import numpy as np
>>> import torch

>>> import cv2
>>> from PIL import Image

>>> # download an image
>>> image = load_image(
...     "https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
... )
>>> np_image = np.array(image)

>>> # get canny image
>>> np_image = cv2.Canny(np_image, 100, 200)
>>> np_image = np_image[:, :, None]
>>> np_image = np.concatenate([np_image, np_image, np_image], axis=2)
>>> canny_image = Image.fromarray(np_image)

>>> # load control net and stable diffusion v1-5
>>> controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny", torch_dtype=torch.float16)
>>> pipe = StableDiffusionControlNetImg2ImgPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5", controlnet=controlnet, torch_dtype=torch.float16
... )

>>> # speed up diffusion process with faster scheduler and memory optimization
>>> pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
>>> pipe.enable_model_cpu_offload()

>>> # generate image
>>> generator = torch.manual_seed(0)
>>> image = pipe(
...     "futuristic-looking woman",
...     num_inference_steps=20,
...     generator=generator,
...     image=image,
...     control_image=canny_image,
... ).images[0]
```

#### enable_attention_slicing[[diffusers.StableDiffusionControlNetImg2ImgPipeline.enable_attention_slicing]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2048)

**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.StableDiffusionControlNetImg2ImgPipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2085)

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.StableDiffusionControlNetImg2ImgPipeline.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/main/src/diffusers/pipelines/pipeline_utils.py#L1993)

**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.StableDiffusionControlNetImg2ImgPipeline.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2024)

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

#### load_textual_inversion[[diffusers.StableDiffusionControlNetImg2ImgPipeline.load_textual_inversion]]

```python
load_textual_inversion(pretrained_model_name_or_path: str | list[str] | dict[str, torch.Tensor] | list[dict[str, torch.Tensor]], token: str | list[str] | None = None, tokenizer: 'PreTrainedTokenizer' | None = None, text_encoder: 'PreTrainedModel' | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/textual_inversion.py#L271)

**Parámetros:**

pretrained_model_name_or_path (`str` o `os.PathLike` o `list[str or os.PathLike]` o `Dict` o `list[Dict]`) : Puede ser cualquiera de los siguientes o una lista de ellos:  - Una cadena de texto, el *model id* (por ejemplo `sd-concepts-library/low-poly-hd-logos-icons`) de un modelo preentrenado alojado en el Hub. - Una ruta a un *directorio* (por ejemplo `./my_text_inversion_directory/`) que contiene los pesos de textual inversion. - Una ruta a un *archivo* (por ejemplo `./my_text_inversions.pt`) que contiene pesos de textual inversion. - Un [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict).

token (`str` o `list[str]`, *opcional*) : Anula el token que se usará para los pesos de inversión textual. Si `pretrained_model_name_or_path` es una lista, `token` también debe ser una lista de la misma longitud.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel), *opcional*) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). Si no se especifica, la función tomará self.tokenizer.

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer), *opcional*) : Un `CLIPTokenizer` para tokenizar texto. Si no se especifica, la función tomará self.tokenizer.

weight_name (`str`, *opcional*) : Nombre de un archivo de pesos personalizado. Debe usarse cuando: - El archivo de inversión textual guardado está en formato 🤗 Diffusers, pero se guardó con un nombre de pesos específico como `text_inv.bin`. - El archivo de inversión textual guardado está en formato Automatic1111.

cache_dir (`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.

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.

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.

hf_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.

subfolder (`str`, *opcional*, valor predeterminado `""`) : La ubicación de la subcarpeta de un archivo de modelo dentro de un repositorio de modelos más grande en el Hub o localmente.

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.

Carga los embeddings de Textual Inversion en el codificador de texto de [StableDiffusionPipeline](/docs/diffusers/main/es/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) (se admiten tanto el formato de 🤗 Diffusers como el de Automatic1111).

Ejemplo:

Para cargar un vector de incrustación de Textual Inversion en formato 🤗 Diffusers:

```py
from diffusers import StableDiffusionPipeline
import torch

model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")

pipe.load_textual_inversion("sd-concepts-library/cat-toy")

prompt = "A <cat-toy> backpack"

image = pipe(prompt, num_inference_steps=50).images[0]
image.save("cat-backpack.png")
```

Para cargar un vector de incrustación de Textual Inversion en formato Automatic1111, asegúrese de descargar primero el vector (por ejemplo, desde [civitAI](https://civitai.com/models/3036?modelVersionId=9857)) y luego cargar el vector

localmente:

```py
from diffusers import StableDiffusionPipeline
import torch

model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")

pipe.load_textual_inversion("./charturnerv2.pt", token="charturnerv2")

prompt = "charturnerv2, multiple views of the same character in the same outfit, a character turnaround of a woman wearing a black jacket and red shirt, best quality, intricate details."

image = pipe(prompt, num_inference_steps=50).images[0]
image.save("character.png")
```

#### encode_prompt[[diffusers.StableDiffusionControlNetImg2ImgPipeline.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/main/src/diffusers/pipelines/controlnet/pipeline_controlnet_img2img.py#L276)

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

## StableDiffusionControlNetInpaintPipeline[[diffusers.StableDiffusionControlNetInpaintPipeline]]

#### diffusers.StableDiffusionControlNetInpaintPipeline[[diffusers.StableDiffusionControlNetInpaintPipeline]]

```python
diffusers.StableDiffusionControlNetInpaintPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, controlnet: diffusers.models.controlnets.controlnet.ControlNetModel | list[diffusers.models.controlnets.controlnet.ControlNetModel] | tuple[diffusers.models.controlnets.controlnet.ControlNetModel] | diffusers.models.controlnets.multicontrolnet.MultiControlNetModel, scheduler: KarrasDiffusionSchedulers, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: CLIPVisionModelWithProjection = None, requires_safety_checker: bool = True)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/controlnet/pipeline_controlnet_inpaint.py#L128)

**Parámetros:**

vae ([AutoencoderKL](/docs/diffusers/main/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](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` para tokenizar texto.

unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Un `UNet2DConditionModel` para desruidar los latentes de imagen codificados.

controlnet ([ControlNetModel](/docs/diffusers/main/es/api/models/controlnet#diffusers.ControlNetModel) o `list[ControlNetModel]`) : Proporciona una condición adicional al `unet` durante el proceso de desruido. Si configuras varios ControlNet como una lista, las salidas de cada ControlNet se suman para crear una condición adicional combinada.

scheduler ([SchedulerMixin](/docs/diffusers/main/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/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/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 sobre los posibles daños de un modelo.

feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : Un `CLIPImageProcessor` para extraer características de las imágenes generadas; se utiliza como entrada para el `safety_checker`.

Pipeline para el inpainting de imágenes usando Stable Diffusion con la guía de ControlNet.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).

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

> [!TIP] > Este pipeline se puede utilizar con puntos de control que hayan sido específicamente afinados para inpainting >
([stable-diffusion-v1-5/stable-diffusion-inpainting](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-inpainting))
> as well as checkpoints de Stable Diffusion de texto a imagen predeterminados >
([stable-diffusion-v1-5/stable-diffusion-v1-5](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5)).
> Los puntos de control de Stable Diffusion de texto a imagen predeterminados podrían ser preferibles para los ControlNets que han sido ajustados
en > esos, como [lllyasviel/control_v11p_sd15_inpaint](https://huggingface.co/lllyasviel/control_v11p_sd15_inpaint).

#### __call__[[diffusers.StableDiffusionControlNetInpaintPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, control_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, padding_mask_crop: int | None = None, strength: float = 1.0, num_inference_steps: int = 50, 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, 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, cross_attention_kwargs: dict[str, typing.Any] | None = None, controlnet_conditioning_scale: float | list[float] = 0.5, guess_mode: bool = False, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, clip_skip: int | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list = ['latents'], **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/controlnet/pipeline_controlnet_inpaint.py#L994)

**Parámetros:**

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

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, : `list[PIL.Image.Image]`, o `list[np.ndarray]`): `Image`, array de NumPy o tensor que representa un lote de imágenes para usarse como punto de partida. Tanto para el array de NumPy como para el tensor de PyTorch, el rango de valores esperado está entre `[0, 1]`. Si es un tensor o una lista de tensors, la forma esperada debe ser `(B, C, H, W)` o `(C, H, W)`. Si es un array de NumPy o una lista de arrays, la forma esperada debe ser `(B, H, W, C)` o `(H, W, C)`. También puede aceptar latentes de imagen como `image`, pero si se pasan latentes directamente, no se vuelven a codificar.

mask_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, : `list[PIL.Image.Image]`, o `list[np.ndarray]`): `Image`, array de NumPy o tensor que representa un lote de imágenes para enmascarar `image`. Los píxeles blancos de la máscara se repintan, mientras que los píxeles negros se conservan. Si `mask_image` es una imagen PIL, se convierte a un solo canal (luminancia) antes de su uso. Si es un array de NumPy o un tensor de PyTorch, debe contener un solo canal de color (L) en lugar de 3, por lo que la forma esperada para un tensor de PyTorch sería `(B, 1, H, W)`, `(B, H, W)`, `(1, H, W)`, `(H, W)`. Y para un array de NumPy, sería para `(B, H, W, 1)`, `(B, H, W)`, `(H, W, 1)`, o `(H, W)`.

control_image (`torch.Tensor`, `PIL.Image.Image`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, : `list[list[torch.Tensor]]`, o `list[list[PIL.Image.Image]]`): La condición de entrada de ControlNet para proporcionar orientación a la `unet` durante la generación. Si el tipo se especifica como `torch.Tensor`, se pasa a ControlNet tal cual. También se puede aceptar `PIL.Image.Image` como imagen. Las dimensiones de la imagen de salida son, por defecto, las dimensiones de `image`. Si se pasan la altura y/o el ancho, `image` se redimensiona en consecuencia. Si se especifican varios ControlNets en `init`, las imágenes deben pasarse como una lista para que cada elemento de la lista pueda agruparse correctamente como entrada para un solo ControlNet.

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

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

padding_mask_crop (`int`, *opcional*, valor predeterminado `None`) : El tamaño del margen en el recorte que se aplicará a la imagen y la máscara. Si es `None`, no se aplica ningún recorte a la imagen y a mask_image. Si `padding_mask_crop` no es `None`, primero se buscará una región rectangular con la misma relación de aspecto que la imagen y que contenga toda el área enmascarada, y luego se expandirá esa área en función de `padding_mask_crop`. A continuación, la imagen y mask_image se recortarán según el área expandida antes de redimensionarlas al tamaño original de la imagen para el inpainting. Esto es útil cuando el área enmascarada es pequeña mientras que la imagen es grande y contiene información irrelevante para el inpainting, como el fondo.

strength (`float`, *opcional*, valor predeterminado 1.0) : Indica el grado en que se transforma la `image` de referencia. Debe estar entre 0 y 1. `image` se utiliza como punto de partida y se añade más ruido a medida que aumenta el `strength`. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuando `strength` es 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado en `num_inference_steps`. Un valor de 1 ignora esencialmente `image`.

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.

guidance_scale (`float`, *opcional*, valor predeterminado 7.5) : Un valor más alto de la escala de guía anima al modelo a generar imágenes estrechamente vinculadas al `prompt` de texto a costa de una menor calidad de imagen. La escala de guía se habilita cuando `guidance_scale > 1`.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar lo que no debe incluirse en la generación de la imagen. Si no se define, debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale < 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 (η) del artículo [DDIM](https://huggingface.co/papers/2010.02502). Solo se aplica al [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler) y se ignora en otros programadores.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](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 proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan 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.Image` o `np.array`.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) en lugar de una tupla simple.

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

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

guess_mode (`bool`, *opcional*, valor predeterminado `False`) : El codificador de ControlNet intenta reconocer el contenido de la imagen de entrada incluso si eliminas todos los prompts. Se recomienda un valor de `guidance_scale` entre 3.0 y 5.0.

control_guidance_start (`float` o `list[float]`, *opcional*, valor predeterminado 0.0) : El porcentaje de pasos totales en el que ControlNet comienza a aplicarse.

control_guidance_end (`float` o `list[float]`, *opcional*, valor predeterminado 1.0) : El porcentaje de pasos totales en el que ControlNet deja de aplicarse.

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.

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

**Devuelve:** [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) o `tuple`

Si `return_dict` es `True`, se devuelve [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw).

La función de llamada para el pipeline de generación.

Ejemplos:
```py
>>> # !pip install transformers accelerate
>>> from diffusers import StableDiffusionControlNetInpaintPipeline, ControlNetModel, DDIMScheduler
>>> from diffusers.utils import load_image
>>> import numpy as np
>>> import torch

>>> init_image = load_image(
...     "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png"
... )
>>> init_image = init_image.resize((512, 512))

>>> generator = torch.Generator(device="cpu").manual_seed(1)

>>> mask_image = load_image(
...     "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png"
... )
>>> mask_image = mask_image.resize((512, 512))

>>> def make_canny_condition(image):
...     image = np.array(image)
...     image = cv2.Canny(image, 100, 200)
...     image = image[:, :, None]
...     image = np.concatenate([image, image, image], axis=2)
...     image = Image.fromarray(image)
...     return image

>>> control_image = make_canny_condition(init_image)

>>> controlnet = ControlNetModel.from_pretrained(
...     "lllyasviel/control_v11p_sd15_inpaint", torch_dtype=torch.float16
... )
>>> pipe = StableDiffusionControlNetInpaintPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5", controlnet=controlnet, torch_dtype=torch.float16
... )

>>> pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
>>> pipe.enable_model_cpu_offload()

>>> # generate image
>>> image = pipe(
...     "a handsome man with ray-ban sunglasses",
...     num_inference_steps=20,
...     generator=generator,
...     eta=1.0,
...     image=init_image,
...     mask_image=mask_image,
...     control_image=control_image,
... ).images[0]
```

#### enable_attention_slicing[[diffusers.StableDiffusionControlNetInpaintPipeline.enable_attention_slicing]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2048)

**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.StableDiffusionControlNetInpaintPipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2085)

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.StableDiffusionControlNetInpaintPipeline.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/main/src/diffusers/pipelines/pipeline_utils.py#L1993)

**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.StableDiffusionControlNetInpaintPipeline.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2024)

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

#### load_textual_inversion[[diffusers.StableDiffusionControlNetInpaintPipeline.load_textual_inversion]]

```python
load_textual_inversion(pretrained_model_name_or_path: str | list[str] | dict[str, torch.Tensor] | list[dict[str, torch.Tensor]], token: str | list[str] | None = None, tokenizer: 'PreTrainedTokenizer' | None = None, text_encoder: 'PreTrainedModel' | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/textual_inversion.py#L271)

**Parámetros:**

pretrained_model_name_or_path (`str` o `os.PathLike` o `list[str or os.PathLike]` o `Dict` o `list[Dict]`) : Puede ser cualquiera de los siguientes o una lista de ellos:  - Una cadena de texto, el *model id* (por ejemplo `sd-concepts-library/low-poly-hd-logos-icons`) de un modelo preentrenado alojado en el Hub. - Una ruta a un *directorio* (por ejemplo `./my_text_inversion_directory/`) que contiene los pesos de textual inversion. - Una ruta a un *archivo* (por ejemplo `./my_text_inversions.pt`) que contiene pesos de textual inversion. - Un [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict).

token (`str` o `list[str]`, *opcional*) : Anula el token que se usará para los pesos de inversión textual. Si `pretrained_model_name_or_path` es una lista, `token` también debe ser una lista de la misma longitud.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel), *opcional*) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). Si no se especifica, la función tomará self.tokenizer.

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer), *opcional*) : Un `CLIPTokenizer` para tokenizar texto. Si no se especifica, la función tomará self.tokenizer.

weight_name (`str`, *opcional*) : Nombre de un archivo de pesos personalizado. Debe usarse cuando: - El archivo de inversión textual guardado está en formato 🤗 Diffusers, pero se guardó con un nombre de pesos específico como `text_inv.bin`. - El archivo de inversión textual guardado está en formato Automatic1111.

cache_dir (`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.

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.

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.

hf_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.

subfolder (`str`, *opcional*, valor predeterminado `""`) : La ubicación de la subcarpeta de un archivo de modelo dentro de un repositorio de modelos más grande en el Hub o localmente.

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.

Carga los embeddings de Textual Inversion en el codificador de texto de [StableDiffusionPipeline](/docs/diffusers/main/es/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) (se admiten tanto el formato de 🤗 Diffusers como el de Automatic1111).

Ejemplo:

Para cargar un vector de incrustación de Textual Inversion en formato 🤗 Diffusers:

```py
from diffusers import StableDiffusionPipeline
import torch

model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")

pipe.load_textual_inversion("sd-concepts-library/cat-toy")

prompt = "A <cat-toy> backpack"

image = pipe(prompt, num_inference_steps=50).images[0]
image.save("cat-backpack.png")
```

Para cargar un vector de incrustación de Textual Inversion en formato Automatic1111, asegúrese de descargar primero el vector (por ejemplo, desde [civitAI](https://civitai.com/models/3036?modelVersionId=9857)) y luego cargar el vector

localmente:

```py
from diffusers import StableDiffusionPipeline
import torch

model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")

pipe.load_textual_inversion("./charturnerv2.pt", token="charturnerv2")

prompt = "charturnerv2, multiple views of the same character in the same outfit, a character turnaround of a woman wearing a black jacket and red shirt, best quality, intricate details."

image = pipe(prompt, num_inference_steps=50).images[0]
image.save("character.png")
```

#### encode_prompt[[diffusers.StableDiffusionControlNetInpaintPipeline.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/main/src/diffusers/pipelines/controlnet/pipeline_controlnet_inpaint.py#L282)

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

## StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]

#### diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]

```python
diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray, nsfw_content_detected: list[bool] | None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_output.py#L10)

**Parámetros:**

images (`list[PIL.Image.Image]` o `np.ndarray`) : lista de imágenes PIL desruidas de longitud `batch_size` o matriz NumPy de forma `(batch_size, height, width, num_channels)`.

nsfw_content_detected (`list[bool]`) : lista que indica si la imagen generada correspondiente contiene contenido "no apto para el trabajo" (nsfw) o `None` si no se pudo realizar la verificación de seguridad.

Clase de salida para las tuberías de Stable Diffusion.