Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /ru /using-diffusers /inpaint.md
mishig
1 day ago
preview code
download
raw
48.6 kB
# Инпейнтинг

Inpainting заменяет или редактирует определённые области изображения. Это делает его полезным инструментом для восстановления изображений, например, для удаления дефектов и артефактов, или даже для замены области изображения чем-то совершенно новым. Inpainting опирается на маску, чтобы определить, какие области изображения необходимо заполнить; область для inpainting представлена белыми пикселями, а область, которую нужно сохранить, — чёрными пикселями. Белые пиксели заполняются на основе промпта.

С помощью 🤗 Diffusers выполнить inpainting можно так:

1. Загрузите контрольную точку для инпейнтинга с помощью класса [AutoPipelineForInpainting](/docs/diffusers/main/ru/api/pipelines/auto_pipeline#diffusers.AutoPipelineForInpainting). Он автоматически определит подходящий класс пайплайна для загрузки на основе контрольной точки:

```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]
> В ходе выполнения руководства вы заметите, что мы используем [enable_model_cpu_offload()](/docs/diffusers/main/ru/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload) и [enable_xformers_memory_efficient_attention()](/docs/diffusers/main/ru/api/pipelines/overview#diffusers.DiffusionPipeline.enable_xformers_memory_efficient_attention), чтобы экономить память и увеличивать скорость инференса. Если вы используете PyTorch 2.0, нет необходимости вызывать [enable_xformers_memory_efficient_attention()](/docs/diffusers/main/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/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")
```

3. Создайте промпт для инпейнтинга изображения и передайте его в пайплайн вместе с базовым изображением и маской:

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

  
    
    базовый образ
  
  
    
    маска изображения
  
  
    
    сгенерированное изображение
  
## Создание изображения маски

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

Загрузите базовое изображение для инпейнтинга и используйте инструмент «Скетч», чтобы нарисовать маску. Когда закончите, нажмите **Run**, чтобы сгенерировать и скачать изображение маски.

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

### Размытие маски

Метод [blur()](/docs/diffusers/main/ru/api/image_processor#diffusers.VaeImageProcessor.blur) предоставляет возможность настроить способ слияния исходного изображения и области инпейнта. Степень размытия определяется параметром `blur_factor`. Увеличение значения `blur_factor` усиливает размытие по краям маски, смягчая переход между исходным изображением и областью инпейнта. Низкое или нулевое значение `blur_factor` сохраняет более чёткие края маски.

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

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

  
    
    маска без размытия
  
  
    
    маска с применённым размытием
  
## Популярные модели

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

### Stable Diffusion Inpainting

Stable Diffusion Inpainting — это латентная диффузионная модель, дообученная на изображениях 512x512 для задачи inpainting. Это хорошая отправная точка, поскольку модель работает относительно быстро и генерирует изображения высокого качества. Чтобы использовать эту модель для inpainting, необходимо передать в пайплайн промпт, базовое изображение и маску:

```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 в Stable Diffusion XL (SDXL)

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

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

Семейство моделей Kandinsky похоже на SDXL, поскольку также использует две модели: модель image prior создаёт эмбеддинги изображений, а диффузионная модель генерирует изображения на их основе. Вы можете загрузить модель image prior и диффузионную модель отдельно, но самый простой способ использовать Kandinsky 2.2 — загрузить его в класс [AutoPipelineForInpainting](/docs/diffusers/main/ru/api/pipelines/auto_pipeline#diffusers.AutoPipelineForInpainting), который под капотом использует [KandinskyV22InpaintCombinedPipeline](/docs/diffusers/main/ru/api/pipelines/kandinsky_v22#diffusers.KandinskyV22InpaintCombinedPipeline).

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

  
    
    базовый образ
  
  
    
    Stable Diffusion Inpainting
  
  
    
    Stable Diffusion XL Inpainting
  
  
    
    Kandinsky 2.2 Inpainting
  
## Чекпоинты, не предназначенные для инпейнта

До сих пор в этом руководстве использовались контрольные точки, специфичные для inpaint, такие как [stable-diffusion-v1-5/stable-diffusion-inpainting](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-inpainting). Однако можно также использовать обычные контрольные точки, например [stable-diffusion-v1-5/stable-diffusion-v1-5](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5). Давайте сравним результаты двух контрольных точек.

Изображение слева сгенерировано из обычного контрольного пункта, а изображение справа — из контрольного пункта для 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/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
  
Однако для более простых задач, таких как удаление объекта с изображения (например, камней на дороге), обычный чекпоинт даёт довольно хорошие результаты. Разница между обычным чекпоинтом и чекпоинтом для инпейнта менее заметна.

```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
  
Компромисс при использовании чекпоинта, не предназначенного специально для инпейнта, заключается в том, что общее качество изображения может быть ниже, однако, как правило, область маски сохраняется (именно поэтому виден её контур). Чекпоинты, специально обученные для инпейнта, намеренно обучаются для генерации изображений с более высоким качеством, что включает создание более естественного перехода между замаскированной и незамаскированной областями. В результате эти чекпоинты с большей вероятностью изменят вашу незамаскированную область.

Если для вашей задачи важно сохранить немаскированную область изображения, вы можете использовать метод [VaeImageProcessor.apply_overlay()](/docs/diffusers/main/ru/api/image_processor#diffusers.VaeImageProcessor.apply_overlay), чтобы принудительно оставить её неизменной, что приведёт к несколько менее естественным переходам между маскированной и немаскированной областями.

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

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

Изображательные характеристики — такие как качество и «креативность» — зависят от параметров конвейера. Понимание того, что делают эти параметры, важно для получения желаемого результата. Рассмотрим наиболее важные параметры и посмотрим, как их изменение влияет на вывод.

### Сила

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

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

```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
  
### Масштаб направляющего сигнала

`guidance_scale` влияет на степень соответствия текстового промпта и сгенерированного изображения.

* 📈 высокое значение `guidance_scale` означает, что промпт и сгенерированное изображение тесно согласованы, поэтому результат представляет собой более строгую интерпретацию промпта
* 📉 низкое значение `guidance_scale` означает, что промпт и сгенерированное изображение связаны менее строго, поэтому результат может сильнее отличаться от промпта

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

```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
  
### Негативный промпт

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

```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"
  
### Обрезка маски отступов

Один из способов повысить качество изображения при inpainting — использовать параметр [`padding_mask_crop`](https://huggingface.co/docs/diffusers/v0.25.0/en/api/pipelines/stable_diffusion/inpaint#diffusers.StableDiffusionInpaintPipeline.__call__.padding_mask_crop). При включении этого параметра область маски обрезается с заданным пользователем отступом, а та же область вырезается и из исходного изображения. И изображение, и маска масштабируются до более высокого разрешения для inpainting, а затем накладываются на исходное изображение. Это простой и быстрый способ улучшить качество изображения без использования отдельного конвейера, такого как [StableDiffusionUpscalePipeline](/docs/diffusers/main/ru/api/pipelines/stable_diffusion/upscale#diffusers.StableDiffusionUpscalePipeline).

Добавьте параметр `padding_mask_crop` в вызов конвейера и установите для него нужное значение отступов.

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

  
    
    изображение для inpaint по умолчанию
  
  
    
    восстановление изображения с включённым `padding_mask_crop`
  
## Цепочки пайплайнов для инпейнтинга

[AutoPipelineForInpainting](/docs/diffusers/main/ru/api/pipelines/auto_pipeline#diffusers.AutoPipelineForInpainting) можно объединять с другими пайплайнами 🤗 Diffusers для редактирования их результатов. Это часто полезно для повышения качества вывода из других диффузионных пайплайнов, а при использовании нескольких пайплайнов их объединение позволяет экономить память, сохраняя результаты в латентном пространстве и повторно используя одни и те же компоненты пайплайна.

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

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

Начните с пайплайна text-to-image, чтобы создать замок:

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

Загрузите изображение маски вывода, полученного выше:

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

А теперь заполним замаскированную область изображением водопада:

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

  
    
    text-to-image
  
  
    
    inpaint
  
### Inpaint-to-image-to-image

Вы также можете подключить конвейер inpainting перед другим конвейером, например image-to-image или апскейлером, чтобы улучшить качество.

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

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

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

```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]
> Важно указать `output_type="latent"` в конвейере, чтобы все выходные данные оставались в латентном пространстве и избежать ненужного шага декодирования-кодирования. Это работает только в том случае, если связанные конвейеры используют одну и ту же VAE. Например, в разделе [Text-to-image-to-inpaint](#text-to-image-to-inpaint) Kandinsky 2.2 использует класс VAE, отличный от того, что применяется в модели Stable Diffusion, поэтому это не сработает. Но если вы используете Stable Diffusion v1.5 для обоих конвейеров, то можете оставить всё в латентном пространстве, так как оба используют [AutoencoderKL](/docs/diffusers/main/ru/api/models/autoencoderkl#diffusers.AutoencoderKL).
Наконец, вы можете передать это изображение в пайплайн image-to-image, чтобы внести последние штрихи. Более эффективно использовать метод [from_pipe()](/docs/diffusers/main/ru/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image.from_pipe) для переиспользования существующих компонентов пайплайна и избежать ненужной повторной загрузки всех компонентов пайплайна в память.
```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)
```
  
    
    изображение по умолчанию
  
  
    
    inpaint
  
  
    
    image-to-image
  
Задачи преобразования изображения в изображение и восстановления изображений (inpainting) на самом деле очень похожи. Преобразование изображения в изображение генерирует новое изображение, похожее на предоставленное исходное. Восстановление изображений делает то же самое, но преобразует только область изображения, заданную маской, а остальная часть изображения остаётся неизменной. Inpainting можно рассматривать как более точный инструмент для внесения конкретных изменений, тогда как image-to-image имеет более широкий охват для внесения более масштабных изменений.
## Управление генерацией изображений
Достичь точного соответствия изображения вашим ожиданиям сложно, поскольку процесс денойзинга является случайным. Хотя вы можете управлять некоторыми аспектами генерации, настраивая параметры вроде `negative_prompt`, существуют более эффективные методы контроля генерации изображений.

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

Взвешивание промпта (prompt weighting) предоставляет количественный способ масштабирования представления концепций в промпте. С его помощью можно увеличивать или уменьшать величину вектора текстового эмбеддинга для каждой концепции в промпте, что впоследствии определяет, насколько сильно каждая концепция будет представлена в генерируемом результате. Библиотека [Compel](https://github.com/damian0815/compel) предлагает интуитивно понятный синтаксис для масштабирования весов промпта и генерации эмбеддингов. Узнайте, как создавать эмбеддинги, в руководстве [Prompt weighting](../using-diffusers/weighted_prompts).

После генерации эмбеддингов передайте их в параметр `prompt_embeds` (а также `negative_prompt_embeds`, если вы используете негативный промпт) в [AutoPipelineForInpainting](/docs/diffusers/main/ru/api/pipelines/auto_pipeline#diffusers.AutoPipelineForInpainting). Эмбеддинги заменяют параметр `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

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

Например, давайте зададим условие для изображения с помощью ControlNet, предварительно обученного на изображениях для 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)
```

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

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

Вы можете пойти дальше и объединить это с конвейером image-to-image, чтобы применить новый [стиль](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)
```

  
    
    изображение по умолчанию
  
  
    
    ControlNet inpaint
  
  
    
    image-to-image
  
## Оптимизация

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

Вы также можете выгрузить модель на CPU, чтобы сэкономить ещё больше памяти:

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

Чтобы ещё больше ускорить код инференса, используйте [`torch_compile`](../optimization/fp16#torchcompile). Вам следует обернуть `torch.compile` вокруг наиболее ресурсоёмкого компонента конвейера, которым обычно является UNet:

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

Подробнее в разделе [Оптимизация и масштабирование](../optimization/overview#optimization-techniques).
Xet Storage Details

Size:: 48.6 kB
Xet hash:: 017c4fca30870b7e74506fb9d3289242c542ceb1c69cbf6463ab84985b229adb
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.