# Изображение в изображение

Image-to-image is similar to [text-to-image](conditional_image_generation), but in addition to a prompt, you can also pass an initial image as a starting point for the diffusion process. The initial image is encoded to latent space and noise is added to it. Then the latent diffusion model takes a prompt and the noisy latent image, predicts the added noise, and removes the predicted noise from the initial latent image to get the new latent image. Lastly, a decoder decodes the new latent image back into an image.

С 🤗 Diffusers это так же просто, как 1-2-3:

1. Загрузите контрольную точку в класс [AutoPipelineForImage2Image](/docs/diffusers/v0.43.0/ru/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image); этот конвейер автоматически загружает правильный класс конвейера на основе контрольной точки:

```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]
> В ходе выполнения руководства вы заметите, что мы используем [enable_model_cpu_offload()](/docs/diffusers/v0.43.0/ru/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload) и [enable_xformers_memory_efficient_attention()](/docs/diffusers/v0.43.0/ru/api/pipelines/overview#diffusers.DiffusionPipeline.enable_xformers_memory_efficient_attention), чтобы экономить память и увеличивать скорость инференса. Если вы используете PyTorch 2.0, то вам не нужно вызывать [enable_xformers_memory_efficient_attention()](/docs/diffusers/v0.43.0/ru/api/pipelines/overview#diffusers.DiffusionPipeline.enable_xformers_memory_efficient_attention) для вашего пайплайна, так как он уже использует нативное [scaled-dot product attention](../optimization/fp16#scaled-dot-product-attention) из PyTorch 2.0.

2. Загрузите изображение для передачи в конвейер:

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

3. Передайте промпт и изображение в пайплайн, чтобы сгенерировать изображение:

```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)
```

  
    
    изображение по умолчанию
  
  
    
    сгенерированное изображение
  

## Популярные модели

Самыми популярными моделями для генерации изображений по изображению являются [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) и [Kandinsky 2.2](https://huggingface.co/kandinsky-community/kandinsky-2-2-decoder). Результаты, получаемые моделями Stable Diffusion и Kandinsky, различаются из-за особенностей их архитектуры и процесса обучения; как правило, можно ожидать, что SDXL будет создавать изображения более высокого качества, чем Stable Diffusion v1.5. Давайте кратко рассмотрим, как использовать каждую из этих моделей, и сравним их результаты.

### Stable Diffusion v1.5

Stable Diffusion v1.5 — это модель латентной диффузии, инициализированная из более раннего контрольного файла и дополнительно дообученная в течение 595K шагов на изображениях 512x512. Чтобы использовать этот конвейер для задачи image-to-image, вам необходимо подготовить исходное изображение для передачи в конвейер. Затем вы можете передать в конвейер промпт и изображение, чтобы сгенерировать новое изображение:

```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)
```

  
    
    изображение по умолчанию
  
  
    
    сгенерированное изображение
  

### Stable Diffusion XL (SDXL)

SDXL — это более мощная версия модели Stable Diffusion. Она использует более крупную базовую модель и дополнительную модель-рефинер для повышения качества вывода базовой модели. Ознакомьтесь с руководством [SDXL](../api/pipelines/stable_diffusion/stable_diffusion_xl), чтобы получить более подробное описание того, как использовать эту модель, а также другие методы, которые она применяет для создания изображений высокого качества.

```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)
```

  
    
    изображение по умолчанию
  
  
    
    сгенерированное изображение
  

### Kandinsky 2.2

Модель Kandinsky отличается от моделей Stable Diffusion тем, что использует модель-приор изображения для создания эмбеддингов изображений. Эмбеддинги помогают обеспечить более точное согласование текста и изображений, что позволяет латентной диффузионной модели генерировать изображения более высокого качества.

Самый простой способ использования Kandinsky 2.2:

```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)
```

  
    
    изображение по умолчанию
  
  
    
    сгенерированное изображение
  

## Настройка параметров конвейера

В пайплайне есть несколько важных параметров, которые можно настроить и которые влияют на процесс генерации изображений и их качество. Давайте подробнее рассмотрим, что делают эти параметры и как их изменение влияет на результат.

### Сила

`strength` — один из важнейших параметров, который оказывает огромное влияние на сгенерированное изображение. Он определяет, насколько сгенерированное изображение похоже на исходное. Иными словами:

- 📈 более высокое значение `strength` даёт модели больше «свободы» для генерации изображения, отличающегося от исходного; значение `strength` 1.0 означает, что исходное изображение в значительной степени игнорируется
- 📉 чем ниже значение `strength`, тем больше сгенерированное изображение похоже на исходное

Параметры `strength` и `num_inference_steps` связаны, поскольку `strength` определяет количество шагов добавления шума. Например, если `num_inference_steps` равно 50, а `strength` — 0.8, это означает, что к исходному изображению добавляется 40 (50 * 0.8) шагов шума, после чего выполняется 40 шагов шумоподавления для получения нового изображения.

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

### Масштаб направляющего сигнала

Параметр `guidance_scale` используется для управления степенью соответствия сгенерированного изображения текстовому промпту. Чем выше значение `guidance_scale`, тем точнее изображение соответствует промпту, а чем ниже значение `guidance_scale`, тем больше у изображения свободы отклоняться от промпта.

Вы можете сочетать `guidance_scale` с `strength` для ещё более точного контроля над выразительностью модели. Например, используйте высокое значение `strength + guidance_scale` для максимальной креативности или комбинацию низких значений `strength` и `guidance_scale`, чтобы сгенерировать изображение, похожее на исходное, но не столь строго привязанное к промпту.

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

### Негативный промпт

Отрицательный промпт указывает модели *не* включать в изображение определённые элементы и может использоваться для улучшения качества изображения или его модификации. Например, вы можете повысить качество изображения, добавив в отрицательный промпт такие фразы, как «poor details» или «blurry», чтобы побудить модель сгенерировать изображение более высокого качества. Либо вы можете модифицировать изображение, указав элементы, которые следует исключить из него.

```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 = "ugly, deformed, disfigured, poor details, bad anatomy"
  
  
    
    negative_prompt = "jungle"
  

## Цепочки пайплайнов «изображение в изображение»

Существуют и другие интересные способы использования конвейера image-to-image, помимо простой генерации изображения (хотя и это довольно круто). Вы можете пойти дальше и объединить его с другими конвейерами.

### Текст-в-изображение-в-изображение

Chaining a text-to-image and image-to-image pipeline allows you to generate an image from text and use the generated image as the initial image for the image-to-image pipeline. This is useful if you want to generate an image entirely from scratch. For example, let's chain a Stable Diffusion and a Kandinsky model.

Начните с генерации изображения с помощью конвейера text-to-image:

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

Теперь вы можете передать это сгенерированное изображение в пайплайн image-to-image:

```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)
```

### Изображение-в-изображение-в-изображение

Вы также можете объединять несколько image-to-image конвейеров в цепочку, чтобы создавать более интересные изображения. Это полезно для итеративного применения стилевой трансформации к изображению, генерации коротких GIF-анимаций, восстановления цвета на изображении или восстановления отсутствующих областей изображения.

Начните с генерации изображения:

```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]
> Важно указать `output_type="latent"` в конвейере, чтобы все выходные данные оставались в латентном пространстве и избежать ненужного шага декодирования-кодирования. Это работает только в том случае, если связанные конвейеры используют одну и ту же VAE.

Передайте латентный вывод из этого конвейера в следующий конвейер, чтобы сгенерировать изображение в [стиле комиксов](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]
```

Повторите ещё раз, чтобы сгенерировать финальное изображение в [стиле пиксель-арт](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)
```

### Изображение в апскейлер в супер-разрешение

Ещё один способ связать ваш image-to-image pipeline — использовать upscaler и super-resolution pipeline, чтобы значительно повысить уровень детализации изображения.

Начните с пайплайна image-to-image:

```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]
> Важно указать `output_type="latent"` в конвейере, чтобы все выходные данные оставались в *латентном* пространстве и избежать лишнего шага декодирования-кодирования. Это работает только в том случае, если связанные конвейеры используют одну и ту же VAE.

Подключите его к конвейеру апскейлера, чтобы повысить разрешение изображения:

```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]
```

Наконец, объедините его с конвейером супер-разрешения, чтобы дополнительно повысить разрешение:

```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)
```

## Управление генерацией изображений

Попытка сгенерировать изображение, которое выглядит именно так, как вы хотите, может оказаться сложной задачей, поэтому методы и модели контролируемой генерации так полезны. Хотя с помощью `negative_prompt` можно частично управлять генерацией изображений, существуют более надёжные методы, такие как взвешивание промптов и ControlNets.

### Взвешивание промптов

Взвешивание промпта позволяет масштабировать представление каждого концепта в промпте. Например, в промпте вида "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" вы можете увеличить или уменьшить эмбеддинги слов "astronaut" и "jungle". Библиотека [Compel](https://github.com/damian0815/compel) предоставляет простой синтаксис для настройки весов промпта и генерации эмбеддингов. О том, как создать эмбеддинги, вы можете узнать в руководстве [Взвешивание промпта](weighted_prompts).

[AutoPipelineForImage2Image](/docs/diffusers/v0.43.0/ru/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image) имеет параметр `prompt_embeds` (а также `negative_prompt_embeds`, если вы используете негативный промпт), в который можно передать эмбеддинги, заменяющие параметр `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 обеспечивают более гибкий и точный способ управления генерацией изображений, поскольку для этого можно использовать дополнительное изображение-условие. В качестве изображения-условия может выступать canny-изображение, карта глубины, результат сегментации изображения и даже наброски! Какой бы тип изображения-условия вы ни выбрали, ControlNet сгенерирует изображение, сохраняющее содержащуюся в нём информацию.

Например, давайте зададим условие для изображения с помощью карты глубины, чтобы сохранить пространственную информацию в изображении.

```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)
```

Загрузите модель ControlNet, использующую карты глубины в качестве условия, и [AutoPipelineForImage2Image](/docs/diffusers/v0.43.0/ru/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()
```

Теперь сгенерируйте новое изображение, используя в качестве условий карту глубины, исходное изображение и промпт:

```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)
```

  
    
    изображение по умолчанию
  
  
    
    изображение глубины
  
  
    
    Изображение ControlNet
  

Применим новый [стиль](https://huggingface.co/nitrosocke/elden-ring-diffusion) к изображению, сгенерированному с помощью ControlNet, объединив его с пайплайном image-to-image:

```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)
```

  

## Оптимизация

Запуск диффузионных моделей требует значительных вычислительных ресурсов, но с помощью нескольких оптимизационных приёмов их вполне можно запускать на потребительских и бесплатных GPU. Например, вы можете использовать более эффективную по памяти форму внимания, такую как [scaled-dot product attention](../optimization/fp16#scaled-dot-product-attention) из PyTorch 2.0 или [xFormers](../optimization/attention_backends) (можно использовать один из них, но нет необходимости применять оба). Также можно выгружать модель на GPU, пока остальные компоненты пайплайна ожидают на CPU.

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

С помощью [`torch.compile`](../optimization/fp16#torchcompile) вы можете ещё больше ускорить инференс, обернув ваш UNet этим инструментом:

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

Чтобы узнать больше, ознакомьтесь с руководствами [Сокращение использования памяти](../optimization/memory) и [Ускорение вывода](../optimization/fp16).