# Imagen a imagen

Image-to-image es similar a [text-to-image](conditional_image_generation), pero además de un prompt, también puedes pasar una imagen inicial como punto de partida para el proceso de difusión. La imagen inicial se codifica en el espacio latente y se le añade ruido. Luego, el modelo de difusión latente toma un prompt y la imagen latente con ruido, predice el ruido añadido y elimina el ruido predicho de la imagen latente inicial para obtener la nueva imagen latente. Por último, un decodificador decodifica la nueva imagen latente de vuelta a una imagen.

Con 🤗 Diffusers, es tan fácil como 1-2-3:

1. Cargue un punto de control en la clase [AutoPipelineForImage2Image](/docs/diffusers/main/es/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image); este pipeline maneja automáticamente la carga de la clase de pipeline correcta en función del punto de control:

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

pipeline = AutoPipelineForImage2Image.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16, 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()
```

> [!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 necesita 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 una imagen para pasarla a la tubería:

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

3. Pase un prompt y una imagen a la pipeline para generar una imagen:

```py
prompt = "cat wizard, gandalf, lord of the rings, detailed, fantasy, cute, adorable, Pixar, Disney, 8k"
image = pipeline(prompt, image=init_image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    imagen inicial
  
  
    
    imagen generada
  

## Modelos populares

Los modelos de imagen a imagen más populares son [Stable Diffusion v1.5](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5), [Stable Diffusion XL (SDXL)](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) y [Kandinsky 2.2](https://huggingface.co/kandinsky-community/kandinsky-2-2-decoder). Los resultados de los modelos Stable Diffusion y Kandinsky varían debido a las diferencias en su arquitectura y proceso de entrenamiento; en general, se puede esperar que SDXL produzca imágenes de mayor calidad que Stable Diffusion v1.5. Echemos un vistazo rápido a cómo usar cada uno de estos modelos y comparemos sus resultados.

### Stable Diffusion v1.5

Stable Diffusion v1.5 es un modelo de difusión latente inicializado a partir de un checkpoint anterior y afinado adicionalmente durante 595K pasos en imágenes de 512x512. Para usar este pipeline para image-to-image, debes preparar una imagen inicial para pasarla al pipeline. Luego, puedes pasar un prompt y la imagen al pipeline para generar una nueva imagen:

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

pipeline = AutoPipelineForImage2Image.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()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    imagen inicial
  
  
    
    imagen generada
  

### Stable Diffusion XL (SDXL)

SDXL es una versión más potente del modelo Stable Diffusion. Utiliza un modelo base más grande y un modelo refiner adicional para aumentar la calidad de la salida del modelo base. Lea la guía de [SDXL](../api/pipelines/stable_diffusion/stable_diffusion_xl) para obtener una explicación más detallada sobre cómo usar este modelo y otras técnicas que emplea para generar imágenes de alta calidad.

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

pipeline = AutoPipelineForImage2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0", 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()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-sdxl-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image, strength=0.5).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    imagen inicial
  
  
    
    imagen generada
  

### Kandinsky 2.2

El modelo Kandinsky es diferente de los modelos Stable Diffusion porque utiliza un modelo de prior de imagen para crear embeddings de imagen. Los embeddings ayudan a crear una mejor alineación entre el texto y las imágenes, permitiendo que el modelo de difusión latente genere mejores imágenes.

La forma más sencilla de usar Kandinsky 2.2 es:

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

pipeline = AutoPipelineForImage2Image.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16, 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()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    imagen inicial
  
  
    
    imagen generada
  

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

Hay varios parámetros importantes que puedes configurar en el pipeline y que afectarán al proceso de generación de imágenes y a la calidad de las imágenes. Veamos más de cerca qué hacen estos parámetros y cómo afecta su modificación a la salida.

### Fuerza

`strength` es uno de los parámetros más importantes a considerar y tendrá un gran impacto en la imagen generada. Determina en qué medida la imagen generada se asemeja a la imagen inicial. En otras palabras:

- 📈 un valor de `strength` más alto otorga al modelo más "creatividad" para generar una imagen diferente a la imagen inicial; un valor de `strength` de 1.0 significa que la imagen inicial se ignora más o menos
- 📉 un valor de `strength` más bajo significa que la imagen generada es más similar a la imagen inicial

Los parámetros `strength` y `num_inference_steps` están relacionados porque `strength` determina el número de pasos de ruido a añadir. Por ejemplo, si `num_inference_steps` es 50 y `strength` es 0.8, esto significa añadir 40 (50 * 0.8) pasos de ruido a la imagen inicial y luego desruidar durante 40 pasos para obtener la imagen recién generada.

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

pipeline = AutoPipelineForImage2Image.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()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image, strength=0.8).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    strength = 0.4
  
  
    
    strength = 0.6
  
  
    
    strength = 1.0
  

### Escala de guía

El parámetro `guidance_scale` se utiliza para controlar el grado de alineación entre la imagen generada y el texto de la solicitud. Un valor más alto de `guidance_scale` significa que la imagen generada está más alineada con la solicitud, mientras que un valor más bajo de `guidance_scale` significa que la imagen generada tiene más margen para desviarse de la solicitud.

Puedes combinar `guidance_scale` con `strength` para un control aún más preciso sobre la expresividad del modelo. Por ejemplo, combina un alto `strength + guidance_scale` para una creatividad máxima o utiliza una combinación de bajo `strength` y bajo `guidance_scale` para generar una imagen que se asemeje a la imagen inicial pero que no esté tan estrictamente ligada al prompt.

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

pipeline = AutoPipelineForImage2Image.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()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

# pass prompt and image to pipeline
image = pipeline(prompt, image=init_image, guidance_scale=8.0).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    guidance_scale = 0.1
  
  
    
    guidance_scale = 5.0
  
  
    
    guidance_scale = 10.0
  

### Prompt negativo

Un prompt negativo condiciona al modelo para que *no* incluya ciertos elementos en una imagen, y puede utilizarse para mejorar la calidad de la imagen o modificarla. Por ejemplo, puedes mejorar la calidad de la imagen incluyendo prompts negativos como "poor details" o "blurry" para animar al modelo a generar una imagen de mayor calidad. O bien, puedes modificar una imagen especificando los elementos que se deben excluir de ella.

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

pipeline = AutoPipelineForImage2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0", 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()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
negative_prompt = "ugly, deformed, disfigured, poor details, bad anatomy"

# pass prompt and image to pipeline
image = pipeline(prompt, negative_prompt=negative_prompt, image=init_image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

  
    
    negative_prompt = "feo, deformado, desfigurado, detalles pobres, mala anatomía"
  
  
    
    negative_prompt = "jungle"
  

## Pipelines de imagen a imagen encadenados

Existen otras formas interesantes de utilizar un pipeline de imagen a imagen, además de simplemente generar una imagen (aunque eso también es bastante genial). Puedes llevarlo un paso más allá y encadenarlo con otros pipelines.

### Texto a imagen a imagen

Encadenar un pipeline de texto a imagen y un pipeline de imagen a imagen permite generar una imagen a partir de texto y utilizar la imagen generada como imagen inicial para el pipeline de imagen a imagen. Esto es útil si se desea generar una imagen completamente desde cero. Por ejemplo, encademos un modelo de Stable Diffusion y un modelo de Kandinsky.

Comience generando una imagen con el pipeline de texto a imagen:

```py
from diffusers import AutoPipelineForText2Image, AutoPipelineForImage2Image
import torch
from diffusers.utils import 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("Astronaut in a jungle, cold color palette, muted colors, detailed, 8k").images[0]
text2image
```

Ahora puede pasar esta imagen generada a la pipeline de imagen a imagen:

```py
pipeline = AutoPipelineForImage2Image.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16, 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()

image2image = pipeline("Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", image=text2image).images[0]
make_image_grid([text2image, image2image], rows=1, cols=2)
```

### Imagen a imagen a imagen

También puede encadenar varios pipelines de imagen a imagen para crear imágenes más interesantes. Esto puede ser útil para realizar transferencias de estilo de forma iterativa en una imagen, generar GIFs cortos, restaurar el color de una imagen o restaurar áreas faltantes de una imagen.

Comience generando una imagen:

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

pipeline = AutoPipelineForImage2Image.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()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

# pass prompt and image to pipeline
image = pipeline(prompt, image=init_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.

Pase la salida latente de este pipeline al siguiente pipeline para generar una imagen en un [estilo de arte de cómic](https://huggingface.co/ogkalu/Comic-Diffusion):

```py
pipeline = AutoPipelineForImage2Image.from_pretrained(
    "ogkalu/Comic-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()

# need to include the token "charliebo artstyle" in the prompt to use this checkpoint
image = pipeline("Astronaut in a jungle, charliebo artstyle", image=image, output_type="latent").images[0]
```

Repite una vez más para generar la imagen final en un [estilo de pixel art](https://huggingface.co/kohbanye/pixel-art-style):

```py
pipeline = AutoPipelineForImage2Image.from_pretrained(
    "kohbanye/pixel-art-style", 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()

# need to include the token "pixelartstyle" in the prompt to use this checkpoint
image = pipeline("Astronaut in a jungle, pixelartstyle", image=image).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

### Imagen a amplificador a superresolución

Otra forma de encadenar tu pipeline de imagen a imagen es con un pipeline de escalado y superresolución para aumentar realmente el nivel de detalle en una imagen.

Comience con un pipeline de imagen a imagen:

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

pipeline = AutoPipelineForImage2Image.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()

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

# pass prompt and image to pipeline
image_1 = pipeline(prompt, image=init_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.

Encadenarlo a un pipeline de upscaler para aumentar la resolución de la imagen:

```py
from diffusers import StableDiffusionLatentUpscalePipeline

upscaler = StableDiffusionLatentUpscalePipeline.from_pretrained(
    "stabilityai/sd-x2-latent-upscaler", dtype=torch.float16, use_safetensors=True
)
upscaler.enable_model_cpu_offload()
upscaler.enable_xformers_memory_efficient_attention()

image_2 = upscaler(prompt, image=image_1).images[0]
```

Por último, encadenarlo a un pipeline de superresolución para mejorar aún más la resolución:

```py
from diffusers import StableDiffusionUpscalePipeline

super_res = StableDiffusionUpscalePipeline.from_pretrained(
    "stabilityai/stable-diffusion-x4-upscaler", dtype=torch.float16, variant="fp16", use_safetensors=True
)
super_res.enable_model_cpu_offload()
super_res.enable_xformers_memory_efficient_attention()

image_3 = super_res(prompt, image=image_2).images[0]
make_image_grid([init_image, image_3.resize((512, 512))], rows=1, cols=2)
```

## Controlar la generación de imágenes

Intentar generar una imagen que se vea exactamente como lo deseas puede ser difícil, por lo que las técnicas y modelos de generación controlada son tan útiles. Si bien puedes usar `negative_prompt` para controlar parcialmente la generación de imágenes, existen métodos más robustos como el ponderado de prompts y ControlNets.

### Pesos de los prompts

El ponderado de prompts permite escalar la representación de cada concepto en un prompt. Por ejemplo, en un prompt como "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", puedes elegir aumentar o disminuir los embeddings de "astronaut" y "jungle". La biblioteca [Compel](https://github.com/damian0815/compel) proporciona una sintaxis simple para ajustar los pesos de los prompts y generar los embeddings. Puedes aprender a crear los embeddings en la guía de [Ponderado de prompts](weighted_prompts).

[AutoPipelineForImage2Image](/docs/diffusers/main/es/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image) tiene un parámetro `prompt_embeds` (y `negative_prompt_embeds` si estás usando un prompt negativo) donde puedes pasar los embeddings que reemplazan al parámetro `prompt`.

```py
from diffusers import AutoPipelineForImage2Image
import torch

pipeline = AutoPipelineForImage2Image.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()

image = pipeline(prompt_embeds=prompt_embeds, # generated from Compel
    negative_prompt_embeds=negative_prompt_embeds, # generated from Compel
    image=init_image,
).images[0]
```

### ControlNet

ControlNets ofrecen una forma más flexible y precisa de controlar la generación de imágenes, ya que puedes utilizar una imagen de condicionamiento adicional. La imagen de condicionamiento puede ser una imagen canny, un mapa de profundidad, una segmentación de imagen e incluso garabatos. Sea cual sea el tipo de imagen de condicionamiento que elijas, el ControlNet genera una imagen que preserva la información contenida en ella.

Por ejemplo, condicional una imagen con un mapa de profundidad para conservar la información espacial de la imagen.

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

# prepare image
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
init_image = load_image(url)
init_image = init_image.resize((958, 960)) # resize to depth image dimensions
depth_image = load_image("https://huggingface.co/lllyasviel/control_v11f1p_sd15_depth/resolve/main/images/control.png")
make_image_grid([init_image, depth_image], rows=1, cols=2)
```

Carga un modelo de ControlNet condicionado en mapas de profundidad y el [AutoPipelineForImage2Image](/docs/diffusers/main/es/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image):

```py
from diffusers import ControlNetModel, AutoPipelineForImage2Image
import torch

controlnet = ControlNetModel.from_pretrained("lllyasviel/control_v11f1p_sd15_depth", dtype=torch.float16, variant="fp16", use_safetensors=True)
pipeline = AutoPipelineForImage2Image.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5", controlnet=controlnet, 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()
```

Ahora genera una nueva imagen condicionada en el mapa de profundidad, la imagen inicial y el prompt:

```py
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
image_control_net = pipeline(prompt, image=init_image, control_image=depth_image).images[0]
make_image_grid([init_image, depth_image, image_control_net], rows=1, cols=3)
```

  
    
    imagen inicial
  
  
    
    imagen de profundidad
  
  
    
    Imagen de ControlNet
  

Aplicaremos un nuevo [estilo](https://huggingface.co/nitrosocke/elden-ring-diffusion) a la imagen generada desde ControlNet encadenándolo con un pipeline de imagen a imagen:

```py
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 astronaut in a jungle" # include the token "elden ring style" in the prompt
negative_prompt = "ugly, deformed, disfigured, poor details, bad anatomy"

image_elden_ring = pipeline(prompt, negative_prompt=negative_prompt, image=image_control_net, strength=0.45, guidance_scale=10.5).images[0]
make_image_grid([init_image, depth_image, image_control_net, image_elden_ring], rows=2, cols=2)
```

  

## Optimizar

Ejecutar modelos de difusión es computacionalmente costoso e intensivo, pero con algunos trucos de optimización es totalmente posible ejecutarlos en GPUs de consumo y de nivel gratuito. Por ejemplo, puedes usar una forma de atención más eficiente en memoria, como la [atención de producto punto escalado](../optimization/fp16#scaled-dot-product-attention) de PyTorch 2.0 o [xFormers](../optimization/attention_backends) (puedes usar uno u otro, pero no hay necesidad de usar ambos). También puedes descargar el modelo a la GPU mientras los demás componentes de la pipeline esperan en la CPU.

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

Con [`torch.compile`](../optimization/fp16#torchcompile), puedes aumentar aún más la velocidad de inferencia envolviendo tu UNet con él:

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

Para obtener más información, consulte las guías [Reduce memory usage](../optimization/memory) y [Accelerate inference](../optimization/fp16).