# Inpainting

El inpainting reemplaza o edita áreas específicas de una imagen. Esto lo convierte en una herramienta útil para la restauración de imágenes, como la eliminación de defectos y artefactos, o incluso para reemplazar un área de la imagen con algo completamente nuevo. El inpainting se basa en una máscara para determinar qué regiones de la imagen deben rellenarse; el área a inpaintear se representa con píxeles blancos y el área a conservar se representa con píxeles negros. Los píxeles blancos se rellenan mediante el prompt.

Con 🤗 Diffusers, así es como puedes hacer inpainting:

1. Carga un punto de control de inpainting con la clase [AutoPipelineForInpainting](/docs/diffusers/main/es/api/pipelines/auto_pipeline#diffusers.AutoPipelineForInpainting). Esto detectará automáticamente la clase de pipeline adecuada para cargar en función del punto de control:

```py
import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image, make_image_grid

pipeline = AutoPipelineForInpainting.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder-inpaint", dtype=torch.float16
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()
```

> [!TIP]
> A lo largo de la guía, notará que usamos [enable_model_cpu_offload()](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload) y [enable_xformers_memory_efficient_attention()](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline.enable_xformers_memory_efficient_attention) para ahorrar memoria y aumentar la velocidad de inferencia. Si está usando PyTorch 2.0, no es necesario llamar a [enable_xformers_memory_efficient_attention()](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline.enable_xformers_memory_efficient_attention) en su pipeline, ya que ya estará utilizando la [scaled-dot product attention](../optimization/fp16#scaled-dot-product-attention) nativa de PyTorch 2.0.

2. Cargue las imágenes de base y máscara:

```py
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")
```

3. Crea un prompt para rellenar la imagen y pásalo a la pipeline junto con las imágenes base y de máscara:

```py
prompt = "a black cat with glowing eyes, cute, adorable, disney, pixar, highly detailed, 8k"
negative_prompt = "bad anatomy, deformed, ugly, disfigured"
image = pipeline(prompt=prompt, negative_prompt=negative_prompt, image=init_image, mask_image=mask_image).images[0]
make_image_grid([init_image, mask_image, image], rows=1, cols=3)
```

  
    
    imagen base
  
  
    
    imagen de máscara
  
  
    
    imagen generada
  

## Crear una imagen de máscara

A lo largo de esta guía, la imagen de máscara se proporciona en todos los ejemplos de código para mayor comodidad. Puedes realizar inpainting en tus propias imágenes, pero necesitarás crear una imagen de máscara para ello. Usa el Space de abajo para crear fácilmente una imagen de máscara.

Sube una imagen base para retocar y usa la herramienta de boceto para dibujar una máscara. Cuando termines, haz clic en **Run** para generar y descargar la imagen de la máscara.

<iframe src="https://stevhliu-inpaint-mask-maker.hf.space" frameborder="0" width="850" height="450"
>

### Desenfoque de máscara

El método [blur()](/docs/diffusers/main/es/api/image_processor#diffusers.VaeImageProcessor.blur) ofrece una opción para definir cómo se combinan la imagen original y el área de inpainting. La cantidad de desenfoque se determina mediante el parámetro `blur_factor`. Aumentar el `blur_factor` incrementa el desenfoque aplicado a los bordes de la máscara, suavizando la transición entre la imagen original y el área de inpainting. Un `blur_factor` bajo o cero preserva los bordes más definidos de la máscara.

Para usar esto, cree una máscara difuminada con el procesador de imágenes.

```py
import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image
from PIL import Image

pipeline = AutoPipelineForInpainting.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16).to('cuda')  # or "mps", "xpu", "cpu"

mask = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/seashore_mask.png")
blurred_mask = pipeline.mask_processor.blur(mask, blur_factor=33)
blurred_mask
```

  
    
    máscara sin desenfoque
  
  
    
    máscara con desenfoque aplicado
  

## Modelos populares

[Stable Diffusion Inpainting](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-inpainting), [Stable Diffusion XL (SDXL) Inpainting](https://huggingface.co/diffusers/stable-diffusion-xl-1.0-inpainting-0.1) y [Kandinsky 2.2 Inpainting](https://huggingface.co/kandinsky-community/kandinsky-2-2-decoder-inpaint) son algunos de los modelos más populares para inpainting. SDXL suele generar imágenes de mayor resolución que Stable Diffusion v1.5, y Kandinsky 2.2 también es capaz de generar imágenes de alta calidad.

### Stable Diffusion Inpainting

Stable Diffusion Inpainting es un modelo de difusión latente afinado en imágenes de 512x512 para inpainting. Es un buen punto de partida porque es relativamente rápido y genera imágenes de buena calidad. Para usar este modelo para inpainting, debes pasar un prompt, una imagen base y una imagen de máscara a la pipeline:

```py
import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image, make_image_grid

pipeline = AutoPipelineForInpainting.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-inpainting", dtype=torch.float16, variant="fp16"
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# load base and mask image
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")

generator = torch.Generator("cuda").manual_seed(92)
prompt = "concept art digital painting of an elven castle, inspired by lord of the rings, highly detailed, 8k"
image = pipeline(prompt=prompt, image=init_image, mask_image=mask_image, generator=generator).images[0]
make_image_grid([init_image, mask_image, image], rows=1, cols=3)
```

### Inpainting de Stable Diffusion XL (SDXL)

SDXL es una versión más grande y potente de Stable Diffusion v1.5. Este modelo puede seguir un proceso de dos etapas (aunque cada modelo también puede usarse de forma independiente); el modelo base genera una imagen y un modelo de refinamiento toma esa imagen para mejorar aún más sus detalles y calidad. Consulta la guía de [SDXL](../api/pipelines/stable_diffusion/stable_diffusion_xl) para obtener una guía más completa sobre cómo usar SDXL y configurar sus parámetros.

```py
import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image, make_image_grid

pipeline = AutoPipelineForInpainting.from_pretrained(
    "diffusers/stable-diffusion-xl-1.0-inpainting-0.1", dtype=torch.float16, variant="fp16"
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# load base and mask image
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")

generator = torch.Generator("cuda").manual_seed(92)
prompt = "concept art digital painting of an elven castle, inspired by lord of the rings, highly detailed, 8k"
image = pipeline(prompt=prompt, image=init_image, mask_image=mask_image, generator=generator).images[0]
make_image_grid([init_image, mask_image, image], rows=1, cols=3)
```

### Kandinsky 2.2 Inpainting

La familia de modelos Kandinsky es similar a SDXL porque también utiliza dos modelos; el modelo de prior de imagen crea embeddings de imagen y el modelo de difusión genera imágenes a partir de ellos. Puedes cargar el modelo de prior de imagen y el modelo de difusión por separado, pero la forma más sencilla de usar Kandinsky 2.2 es cargarlo en la clase [AutoPipelineForInpainting](/docs/diffusers/main/es/api/pipelines/auto_pipeline#diffusers.AutoPipelineForInpainting), que utiliza [KandinskyV22InpaintCombinedPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky_v22#diffusers.KandinskyV22InpaintCombinedPipeline) internamente.

```py
import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image, make_image_grid

pipeline = AutoPipelineForInpainting.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder-inpaint", dtype=torch.float16
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# load base and mask image
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")

generator = torch.Generator("cuda").manual_seed(92)
prompt = "concept art digital painting of an elven castle, inspired by lord of the rings, highly detailed, 8k"
image = pipeline(prompt=prompt, image=init_image, mask_image=mask_image, generator=generator).images[0]
make_image_grid([init_image, mask_image, image], rows=1, cols=3)
```

  
    
    imagen base
  
  
    
    Stable Diffusion Inpainting
  
  
    
    Stable Diffusion XL Inpainting
  
  
    
    Kandinsky 2.2 Inpainting
  

## Puntos de control específicos no de relleno

Hasta ahora, esta guía ha utilizado puntos de control específicos para inpaint, como [stable-diffusion-v1-5/stable-diffusion-inpainting](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-inpainting). Pero también puedes usar puntos de control regulares, como [stable-diffusion-v1-5/stable-diffusion-v1-5](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5). Comparemos los resultados de los dos puntos de control.

La imagen de la izquierda se genera desde un checkpoint regular, y la imagen de la derecha es de un checkpoint de inpaint. Inmediatamente notará que la imagen de la izquierda no es tan limpia y aún se puede ver el contorno del área que el modelo debe inpaint. La imagen de la derecha es mucho más limpia y el área inpaintada parece más natural.

```py
import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image, make_image_grid

pipeline = AutoPipelineForInpainting.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16"
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# load base and mask image
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")

generator = torch.Generator("cuda").manual_seed(92)
prompt = "concept art digital painting of an elven castle, inspired by lord of the rings, highly detailed, 8k"
image = pipeline(prompt=prompt, image=init_image, mask_image=mask_image, generator=generator).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

```py
import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image, make_image_grid

pipeline = AutoPipelineForInpainting.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-inpainting", dtype=torch.float16, variant="fp16"
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# load base and mask image
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")

generator = torch.Generator("cuda").manual_seed(92)
prompt = "concept art digital painting of an elven castle, inspired by lord of the rings, highly detailed, 8k"
image = pipeline(prompt=prompt, image=init_image, mask_image=mask_image, generator=generator).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    stable-diffusion-v1-5/stable-diffusion-v1-5
  
  
    
    stable-diffusion-v1-5/stable-diffusion-inpainting
  

Sin embargo, para tareas más básicas, como borrar un objeto de una imagen (por ejemplo, las rocas en el camino), un checkpoint regular produce resultados bastante buenos. No hay una diferencia tan notable entre el checkpoint regular y el checkpoint de inpaint.

```py
import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image, make_image_grid

pipeline = AutoPipelineForInpainting.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16"
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# load base and mask image
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/road-mask.png")

image = pipeline(prompt="road", image=init_image, mask_image=mask_image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

```py
import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image, make_image_grid

pipeline = AutoPipelineForInpainting.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-inpainting", dtype=torch.float16, variant="fp16"
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# load base and mask image
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/road-mask.png")

image = pipeline(prompt="road", image=init_image, mask_image=mask_image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    stable-diffusion-v1-5/stable-diffusion-v1-5
  
  
    
    stable-diffusion-v1-5/stable-diffusion-inpainting
  

La desventaja de usar un checkpoint no específico para inpainting es que la calidad general de la imagen puede ser inferior, pero generalmente tiende a preservar el área de la máscara (por eso se puede ver el contorno de la máscara). Los checkpoints específicos para inpainting se entrenan intencionalmente para generar imágenes inpaintadas de mayor calidad, y eso incluye crear una transición más natural entre las áreas enmascaradas y no enmascaradas. Como resultado, es más probable que estos checkpoints modifiquen su área no enmascarada.

Si preservar el área sin máscara es importante para su tarea, puede usar el método [VaeImageProcessor.apply_overlay()](/docs/diffusers/main/es/api/image_processor#diffusers.VaeImageProcessor.apply_overlay) para forzar que el área sin máscara de una imagen permanezca igual, a costa de transiciones algo menos naturales entre las áreas con y sin máscara.

```py
import PIL
import numpy as np
import torch

from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image, make_image_grid

device = "cuda"  # or "mps", "xpu", "cpu"
pipeline = AutoPipelineForInpainting.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-inpainting",
    dtype=torch.float16,
    variant="fp16"
)
pipeline = pipeline.to(device)

img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"

init_image = load_image(img_url).resize((512, 512))
mask_image = load_image(mask_url).resize((512, 512))

prompt = "Face of a yellow cat, high resolution, sitting on a park bench"
repainted_image = pipeline(prompt=prompt, image=init_image, mask_image=mask_image).images[0]
repainted_image.save("repainted_image.png")

unmasked_unchanged_image = pipeline.image_processor.apply_overlay(mask_image, init_image, repainted_image)
unmasked_unchanged_image.save("force_unmasked_unchanged.png")
make_image_grid([init_image, mask_image, repainted_image, unmasked_unchanged_image], rows=2, cols=2)
```

## Configurar los parámetros de la canalización

Las características de la imagen, como la calidad y la "creatividad", dependen de los parámetros de la pipeline. Conocer qué hacen estos parámetros es importante para obtener los resultados que se desean. Veamos los parámetros más importantes y cómo afecta su modificación a la salida.

### Fuerza

`strength` es una medida de la cantidad de ruido que se añade a la imagen base, lo que influye en qué tan similar es la imagen de salida a la imagen base.

* 📈 un valor de `strength` alto significa que se añade más ruido a la imagen y el proceso de desruidoado tarda más, pero obtendrás imágenes de mayor calidad que difieren más de la imagen base
* 📉 un valor de `strength` bajo significa que se añade menos ruido a la imagen y el proceso de desruido es más rápido, pero la calidad de la imagen puede no ser tan buena y la imagen generada se parecerá más a la imagen base

```py
import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image, make_image_grid

pipeline = AutoPipelineForInpainting.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-inpainting", dtype=torch.float16, variant="fp16"
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# load base and mask image
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")

prompt = "concept art digital painting of an elven castle, inspired by lord of the rings, highly detailed, 8k"
image = pipeline(prompt=prompt, image=init_image, mask_image=mask_image, strength=0.6).images[0]
make_image_grid([init_image, mask_image, image], rows=1, cols=3)
```

  
    
    strength = 0.6
  
  
    
    strength = 0.8
  
  
    
    strength = 1.0
  

### Escala de guía

`guidance_scale` afecta el grado de alineación entre el texto del prompt y la imagen generada.

* 📈 un valor alto de `guidance_scale` significa que el prompt y la imagen generada están estrechamente alineados, por lo que la salida es una interpretación más estricta del prompt
* 📉 un valor bajo de `guidance_scale` significa que el prompt y la imagen generada están alineados de forma más laxa, por lo que la salida puede ser más variada respecto al prompt

Puedes usar `strength` y `guidance_scale` juntos para tener más control sobre lo expresivo que es el modelo. Por ejemplo, una combinación de valores altos de `strength` y `guidance_scale` otorga al modelo la mayor libertad creativa.

```py
import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image, make_image_grid

pipeline = AutoPipelineForInpainting.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-inpainting", dtype=torch.float16, variant="fp16"
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# load base and mask image
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")

prompt = "concept art digital painting of an elven castle, inspired by lord of the rings, highly detailed, 8k"
image = pipeline(prompt=prompt, image=init_image, mask_image=mask_image, guidance_scale=2.5).images[0]
make_image_grid([init_image, mask_image, image], rows=1, cols=3)
```

  
    
    guidance_scale = 2.5
  
  
    
    guidance_scale = 7.5
  
  
    
    guidance_scale = 12.5
  

### Prompt negativo

Un prompt negativo asume el papel opuesto al de un prompt; guía al modelo para que no genere ciertos elementos en una imagen. Esto es útil para mejorar rápidamente la calidad de la imagen y evitar que el modelo genere cosas que no deseas.

```py
import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image, make_image_grid

pipeline = AutoPipelineForInpainting.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-inpainting", dtype=torch.float16, variant="fp16"
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# load base and mask image
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")

prompt = "concept art digital painting of an elven castle, inspired by lord of the rings, highly detailed, 8k"
negative_prompt = "bad architecture, unstable, poor details, blurry"
image = pipeline(prompt=prompt, negative_prompt=negative_prompt, image=init_image, mask_image=mask_image).images[0]
make_image_grid([init_image, mask_image, image], rows=1, cols=3)
```

  
    
    negative_prompt = "bad architecture, unstable, poor details, blurry"
  

### Recorte de la máscara de relleno

Un método para mejorar la calidad de la imagen en el inpainting es utilizar el parámetro [`padding_mask_crop`](https://huggingface.co/docs/diffusers/v0.25.0/en/api/pipelines/stable_diffusion/inpaint#diffusers.StableDiffusionInpaintPipeline.__call__.padding_mask_crop). Cuando está habilitado, esta opción recorta el área enmascarada con un relleno especificado por el usuario y también recorta la misma área de la imagen original. Tanto la imagen como la máscara se escalan a una resolución más alta para el inpainting y luego se superponen sobre la imagen original. Esta es una forma rápida y sencilla de mejorar la calidad de la imagen sin utilizar una pipeline separada como [StableDiffusionUpscalePipeline](/docs/diffusers/main/es/api/pipelines/stable_diffusion/upscale#diffusers.StableDiffusionUpscalePipeline).

Agrega el parámetro `padding_mask_crop` a la llamada de la pipeline y establécelo en el valor de relleno deseado.

```py
import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image
from PIL import Image

generator = torch.Generator(device='cuda').manual_seed(0)  # or "mps", "xpu", "cpu"
pipeline = AutoPipelineForInpainting.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16).to('cuda')

base = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/seashore.png")
mask = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/seashore_mask.png")

image = pipeline("boat", image=base, mask_image=mask, strength=0.75, generator=generator, padding_mask_crop=32).images[0]
image
```

  
    
    imagen de inpaint predeterminada
  
  
    
    reconstruir imagen con `padding_mask_crop` habilitado
  

## Pipelines de inpainting encadenados

[AutoPipelineForInpainting](/docs/diffusers/main/es/api/pipelines/auto_pipeline#diffusers.AutoPipelineForInpainting) se puede encadenar con otros pipelines de 🤗 Diffusers para editar sus salidas. Esto suele ser útil para mejorar la calidad de la salida de otros pipelines de difusión, y si se utilizan varios pipelines, puede ser más eficiente en memoria encadenarlos para mantener las salidas en el espacio latente y reutilizar los mismos componentes del pipeline.

### Texto a imagen a inpainting

Encadenar un pipeline de texto a imagen y un pipeline de inpainting permite realizar inpainting en la imagen generada, sin necesidad de proporcionar una imagen base desde el principio. Esto facilita editar tus salidas favoritas de texto a imagen sin tener que generar una imagen completamente nueva.

Comience con el pipeline de texto a imagen para crear un castillo:

```py
import torch
from diffusers import AutoPipelineForText2Image, AutoPipelineForInpainting
from diffusers.utils import load_image, make_image_grid

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16, variant="fp16", use_safetensors=True
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

text2image = pipeline("concept art digital painting of an elven castle, inspired by lord of the rings, highly detailed, 8k").images[0]
```

Cargue la imagen de la máscara de la salida anterior:

```py
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_text-chain-mask.png")
```

Y ahora rellenemos el área enmascarada con una cascada:

```py
pipeline = AutoPipelineForInpainting.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder-inpaint", dtype=torch.float16
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

prompt = "digital painting of a fantasy waterfall, cloudy"
image = pipeline(prompt=prompt, image=text2image, mask_image=mask_image).images[0]
make_image_grid([text2image, mask_image, image], rows=1, cols=3)
```

  
    
    texto a imagen
  
  
    
    inpaint
  

### Inpaint-to-image-to-image

También puede encadenar un pipeline de inpainting antes de otro pipeline, como image-to-image o un upscaler, para mejorar la calidad.

Comience aplicando inpainting a una imagen:

```py
import torch
from diffusers import AutoPipelineForInpainting, AutoPipelineForImage2Image
from diffusers.utils import load_image, make_image_grid

pipeline = AutoPipelineForInpainting.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-inpainting", dtype=torch.float16, variant="fp16"
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# load base and mask image
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")

prompt = "concept art digital painting of an elven castle, inspired by lord of the rings, highly detailed, 8k"
image_inpainting = pipeline(prompt=prompt, image=init_image, mask_image=mask_image).images[0]

# resize image to 1024x1024 for SDXL
image_inpainting = image_inpainting.resize((1024, 1024))
```

Ahora pasemos la imagen a otro pipeline de inpainting con el modelo refiner de SDXL para mejorar los detalles y la calidad de la imagen:

```py
pipeline = AutoPipelineForInpainting.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0", dtype=torch.float16, variant="fp16"
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

image = pipeline(prompt=prompt, image=image_inpainting, mask_image=mask_image, output_type="latent").images[0]
```

> [!TIP]
> Es importante especificar `output_type="latent"` en el pipeline para mantener todas las salidas en el espacio latente y evitar un paso innecesario de decodificación y codificación. Esto solo funciona si los pipelines encadenados utilizan el mismo VAE. Por ejemplo, en la sección [Text-to-image-to-inpaint](#text-to-image-to-inpaint), Kandinsky 2.2 utiliza una clase de VAE diferente a la del modelo Stable Diffusion, por lo que no funcionará. Pero si usas Stable Diffusion v1.5 para ambos pipelines, puedes mantener todo en el espacio latente porque ambos utilizan [AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL).

Por último, puedes pasar esta imagen a un pipeline de imagen a imagen para darle los últimos retoques. Es más eficiente usar el método [from_pipe()](/docs/diffusers/main/es/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image.from_pipe) para reutilizar los componentes existentes del pipeline y evitar cargar innecesariamente todos los componentes del pipeline en memoria de nuevo.

```py
pipeline = AutoPipelineForImage2Image.from_pipe(pipeline)
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

image = pipeline(prompt=prompt, image=image).images[0]
make_image_grid([init_image, mask_image, image_inpainting, image], rows=2, cols=2)
```

  
    
    imagen inicial
  
  
    
    inpaint
  
  
    
    image-to-image
  

La generación de imagen a imagen y el inpainting son, en realidad, tareas muy similares. La generación de imagen a imagen crea una nueva imagen que se asemeja a la imagen existente proporcionada. El inpainting hace lo mismo, pero solo transforma el área de la imagen definida por la máscara y el resto de la imagen permanece sin cambios. Puedes pensar en el inpainting como una herramienta más precisa para realizar cambios específicos, mientras que la generación de imagen a imagen tiene un alcance más amplio para realizar cambios más generales.

## Controlar la generación de imágenes

Lograr que una imagen se vea exactamente como se desea es un desafío porque el proceso de desruido es aleatorio. Si bien es posible controlar ciertos aspectos de la generación configurando parámetros como `negative_prompt`, existen métodos mejores y más eficientes para controlar la generación de imágenes.

### Pesos de los prompts

El ponderado de prompts ofrece una forma cuantificable de escalar la representación de los conceptos en un prompt. Puede utilizarlo para aumentar o disminuir la magnitud del vector de embedding de texto para cada concepto en el prompt, lo que determina en consecuencia cuánto de cada concepto se genera. La biblioteca [Compel](https://github.com/damian0815/compel) ofrece una sintaxis intuitiva para escalar los pesos del prompt y generar los embeddings. Aprenda a crear los embeddings en la guía de [Ponderado de prompts](../using-diffusers/weighted_prompts).

Una vez que hayas generado los embeddings, pásalos al parámetro `prompt_embeds` (y `negative_prompt_embeds` si estás usando un prompt negativo) en [AutoPipelineForInpainting](/docs/diffusers/main/es/api/pipelines/auto_pipeline#diffusers.AutoPipelineForInpainting). Los embeddings reemplazan al parámetro `prompt`:

```py
import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import make_image_grid

pipeline = AutoPipelineForInpainting.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-inpainting", dtype=torch.float16,
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

image = pipeline(prompt_embeds=prompt_embeds, # generated from Compel
    negative_prompt_embeds=negative_prompt_embeds, # generated from Compel
    image=init_image,
    mask_image=mask_image
).images[0]
make_image_grid([init_image, mask_image, image], rows=1, cols=3)
```

### ControlNet

Los modelos ControlNet se utilizan junto con otros modelos de difusión como Stable Diffusion, y ofrecen una forma aún más flexible y precisa de controlar cómo se genera una imagen. Un ControlNet acepta una imagen de condicionamiento adicional como entrada que guía al modelo de difusión para que preserve las características presentes en ella.

Por ejemplo, condicionemos una imagen con un ControlNet preentrenado en imágenes de inpaint:

```py
import torch
import numpy as np
from diffusers import ControlNetModel, StableDiffusionControlNetInpaintPipeline
from diffusers.utils import load_image, make_image_grid

# load ControlNet
controlnet = ControlNetModel.from_pretrained("lllyasviel/control_v11p_sd15_inpaint", dtype=torch.float16, variant="fp16")

# pass ControlNet to the pipeline
pipeline = StableDiffusionControlNetInpaintPipeline.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-inpainting", controlnet=controlnet, dtype=torch.float16, variant="fp16"
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

# load base and mask image
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")

# prepare control image
def make_inpaint_condition(init_image, mask_image):
    init_image = np.array(init_image.convert("RGB")).astype(np.float32) / 255.0
    mask_image = np.array(mask_image.convert("L")).astype(np.float32) / 255.0

    assert init_image.shape[0:1] == mask_image.shape[0:1], "image and image_mask must have the same image size"
    init_image[mask_image > 0.5] = -1.0  # set as masked pixel
    init_image = np.expand_dims(init_image, 0).transpose(0, 3, 1, 2)
    init_image = torch.from_numpy(init_image)
    return init_image

control_image = make_inpaint_condition(init_image, mask_image)
```

Ahora genera una imagen a partir de las imágenes base, de máscara y de control. Notarás que las características de la imagen base se conservan fuertemente en la imagen generada.

```py
prompt = "concept art digital painting of an elven castle, inspired by lord of the rings, highly detailed, 8k"
image = pipeline(prompt=prompt, image=init_image, mask_image=mask_image, control_image=control_image).images[0]
make_image_grid([init_image, mask_image, PIL.Image.fromarray(np.uint8(control_image[0][0])).convert('RGB'), image], rows=2, cols=2)
```

Puede llevar esto un paso más allá y encadenarlo con un pipeline de imagen a imagen para aplicar un nuevo [estilo](https://huggingface.co/nitrosocke/elden-ring-diffusion):

```py
from diffusers import AutoPipelineForImage2Image

pipeline = AutoPipelineForImage2Image.from_pretrained(
    "nitrosocke/elden-ring-diffusion", dtype=torch.float16,
)
pipeline.enable_model_cpu_offload()
# remove following line if xFormers is not installed or you have PyTorch 2.0 or higher installed
pipeline.enable_xformers_memory_efficient_attention()

prompt = "elden ring style castle" # include the token "elden ring style" in the prompt
negative_prompt = "bad architecture, deformed, disfigured, poor details"

image_elden_ring = pipeline(prompt, negative_prompt=negative_prompt, image=image).images[0]
make_image_grid([init_image, mask_image, image, image_elden_ring], rows=2, cols=2)
```

  
    
    imagen inicial
  
  
    
    ControlNet inpaint
  
  
    
    image-to-image
  

## Optimizar

Ejecutar modelos de difusión puede ser difícil y lento si tienes recursos limitados, pero no tiene por qué ser así con algunos trucos de optimización. Una de las optimizaciones más grandes (y fáciles) que puedes activar es cambiar a una atención eficiente en memoria. Si usas PyTorch 2.0, [scaled-dot product attention](../optimization/fp16#scaled-dot-product-attention) se habilita automáticamente y no necesitas hacer nada más. Para usuarios de versiones de PyTorch anteriores a 2.0, puedes instalar y usar la implementación de atención eficiente en memoria de [xFormers](../optimization/attention_backends). Ambas opciones reducen el uso de memoria y aceleran la inferencia.

También puede descargar el modelo a la CPU para ahorrar aún más memoria:

```diff
+ pipeline.enable_xformers_memory_efficient_attention()
+ pipeline.enable_model_cpu_offload()
```

Para acelerar aún más tu código de inferencia, usa [`torch_compile`](../optimization/fp16#torchcompile). Deberás envolver `torch.compile` alrededor del componente más intensivo de la tubería, que normalmente es el UNet:

```py
pipeline.unet = torch.compile(pipeline.unet, mode="reduce-overhead", fullgraph=True)
```

Obtenga más información en [Optimización y escalado](../optimization/overview#optimization-techniques).