# Inpainting

Inpainting, bir görüntünün belirli alanlarını değiştirir veya düzenler. Bu, görüntü onarımı için (kusur ve artefaktların kaldırılması gibi) veya bir görüntü alanının tamamen yeni bir şeyle değiştirilmesi için faydalı bir araç haline getirir. Inpainting, bir görüntünün hangi bölgelerinin doldurulacağını belirlemek için bir maskeye dayanır; inpainting yapılacak alan beyaz piksellerle, korunacak alan ise siyah piksellerle temsil edilir. Beyaz pikseller, prompt tarafından doldurulur.

🤗 Diffusers ile inpainting işlemini şu şekilde yapabilirsiniz:

1. Bir inpainting checkpoint'ini [AutoPipelineForInpainting](/docs/diffusers/main/tr/api/pipelines/auto_pipeline#diffusers.AutoPipelineForInpainting) sınıfıyla yükleyin. Bu, checkpoint'e dayanarak yüklenmesi gereken uygun pipeline sınıfını otomatik olarak algılar:

```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]
> Kılavuz boyunca, belleği tasarruflu kullanmak ve çıkarım hızını artırmak için [enable_model_cpu_offload()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload) ve [enable_xformers_memory_efficient_attention()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.enable_xformers_memory_efficient_attention) işlevlerini kullandığımızı fark edeceksiniz. PyTorch 2.0 kullanıyorsanız, hattınızda [enable_xformers_memory_efficient_attention()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.enable_xformers_memory_efficient_attention) işlevini çağırmak gerekmez çünkü PyTorch 2.0'ın yerel [scaled-dot product attention](../optimization/fp16#scaled-dot-product-attention) mekanizmasını zaten kullanıyor olacaktır.

2. Taban ve maske görüntülerini yükleyin:

```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. Görseli doldurmak için bir istem oluşturun ve temel ile maske görselleriyle birlikte hattın (pipeline) girdisine iletin:

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

  
    
    temel görüntü
  
  
    
    mask görüntüsü
  
  
    
    oluşturulan görsel
  

## Bir maske görüntüsü oluşturun

Bu kılavuz boyunca, kullanım kolaylığı için tüm kod örneklerinde maske görüntüsü sağlanmaktadır. Kendi görüntülerinizde inpaint işlemi yapabilirsiniz, ancak bunun için bir maske görüntüsü oluşturmanız gerekir. Bir maske görüntüsü oluşturmak için aşağıdaki Space'i kullanın.

Doldurmak için bir taban görüntü yükleyin ve maske çizmek için eskiz aracını kullanın. İşiniz bittiğinde, maske görüntüsünü oluşturmak ve indirmek için **Run** düğmesine tıklayın.

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

### Maske bulanıklığı

[blur()](/docs/diffusers/main/tr/api/image_processor#diffusers.VaeImageProcessor.blur) yöntemi, orijinal görüntü ile inpaint alanının nasıl birleştirileceğine dair bir seçenek sunar. Bulanıklık miktarı `blur_factor` parametresi tarafından belirlenir. `blur_factor` değerini artırmak, maske kenarlarına uygulanan bulanıklık miktarını artırarak orijinal görüntü ile inpaint alanı arasındaki geçişi yumuşatır. Düşük veya sıfır bir `blur_factor` değeri, maske kenarlarının daha keskin olmasını korur.

Bunu kullanmak için, görüntü işleyici ile bulanık bir maske oluşturun.

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

  
    
    bulanıklık olmadan maske
  
  
    
    bulanıklaştırma uygulanmış maske
  

## Popüler modeller

[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) ve [Kandinsky 2.2 Inpainting](https://huggingface.co/kandinsky-community/kandinsky-2-2-decoder-inpaint), inpainting için en popüler modeller arasında yer alır. SDXL, Stable Diffusion v1.5'e kıyasla genellikle daha yüksek çözünürlüklü görüntüler üretir ve Kandinsky 2.2 de yüksek kaliteli görüntüler oluşturabilir.

### Stable Diffusion Inpainting

Stable Diffusion Inpainting, inpainting üzerinde 512x512 boyutlu görsellerle ince ayarlanmış bir latent difüzyon modelidir. Görece hızlı olması ve iyi kalitede görseller üretmesi nedeniyle iyi bir başlangıç noktasıdır. Bu modeli inpainting için kullanmak için pipeline'a bir prompt, temel ve maske görseli iletmeniz gerekir:

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

### Stable Diffusion XL (SDXL) Inpainting

SDXL, Stable Diffusion v1.5'in daha büyük ve daha güçlü bir versiyonudur. Bu model, iki aşamalı bir model sürecini izleyebilir (her model tek başına da kullanılabilir); temel model bir görüntü oluşturur ve bir iyileştirici (refiner) model bu görüntüyü alarak detaylarını ve kalitesini daha da artırır. SDXL'i nasıl kullanacağınız ve parametrelerini nasıl yapılandıracağınız hakkında daha kapsamlı bir rehber için [SDXL](../api/pipelines/stable_diffusion/stable_diffusion_xl) rehberine göz atın.

```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 model ailesi, iki model kullandığı için SDXL ile benzerdir; image prior modeli görüntü gömümlerini (embeddings) oluşturur ve diffusion modeli bunlardan görüntüler üretir. Image prior ve diffusion modellerini ayrı ayrı yükleyebilirsiniz ancak Kandinsky 2.2'yi kullanmanın en kolay yolu, altında [KandinskyV22InpaintCombinedPipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky_v22#diffusers.KandinskyV22InpaintCombinedPipeline) kullanan [AutoPipelineForInpainting](/docs/diffusers/main/tr/api/pipelines/auto_pipeline#diffusers.AutoPipelineForInpainting) sınıfına yüklemektir.

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

  
    
    temel görüntü
  
  
    
    Stable Diffusion Inpainting
  
  
    
    Stable Diffusion XL Inpainting
  
  
    
    Kandinsky 2.2 Inpainting
  

## Non-inpaint'e özgü olmayan kontrol noktaları

Şimdiye kadar bu kılavuz, [stable-diffusion-v1-5/stable-diffusion-inpainting](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-inpainting) gibi inpaint'e özel checkpoint'ler kullandı. Ancak [stable-diffusion-v1-5/stable-diffusion-v1-5](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) gibi standart checkpoint'leri de kullanabilirsiniz. İki checkpoint'in sonuçlarını karşılaştıralım.

Soldaki görüntü normal bir kontrol noktasından, sağdaki görüntü ise inpaint kontrol noktasından üretilmiştir. Soldaki görüntünün sağdaki kadar temiz olmadığını ve modelin inpaint etmesi gereken alanın konturunun hâlâ görülebildiğini hemen fark edeceksiniz. Sağdaki görüntü çok daha temiz ve inpaint edilen alan daha doğal görünüyor.

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

Ancak, bir görüntüden nesne silme gibi daha temel görevlerde (örneğin yol üzerindeki kayaları silmek gibi), standart bir checkpoint oldukça iyi sonuçlar verir. Standart checkpoint ile inpaint checkpoint arasındaki fark o kadar belirgin değildir.

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

Girişim (inpaint) işlemine özel olmayan bir kontrol noktası (checkpoint) kullanmanın ödünleşimi, genel görüntü kalitesinin daha düşük olabilmesidir; ancak bu kontrol noktaları genellikle maske alanını koruma eğilimindedir (bu nedenle maske konturunu görebilirsiniz). Girişime özel kontrol noktaları, daha yüksek kalitede girişimlenmiş görüntüler üretmek için bilinçli olarak eğitilir ve bu, maskelenmiş ve maskelenmemiş alanlar arasında daha doğal bir geçiş oluşturmayı da içerir. Sonuç olarak, bu kontrol noktalarının maskelenmemiş alanınızı değiştirme olasılığı daha yüksektir.

Görevinizde maskelenmemiş alanın korunması önemliyse, maskelenmiş ve maskelenmemiş alanlar arasında biraz daha yapay geçişlere izin vererek bir görüntünün maskelenmemiş alanının aynı kalmasını sağlamak için [VaeImageProcessor.apply_overlay()](/docs/diffusers/main/tr/api/image_processor#diffusers.VaeImageProcessor.apply_overlay) yöntemini kullanabilirsiniz.

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

## Hattın parametrelerini yapılandır

Görsel özellikler - kalite ve "yaratıcılık" gibi - pipeline parametrelerine bağlıdır. Bu parametrelerin ne işe yaradığını bilmek, istediğiniz sonuçları elde etmek için önemlidir. En önemli parametrelere bir bakalım ve bunları değiştirmenin çıktıyı nasıl etkilediğini görelim.

### Güç

`strength`, taban görüntüye ne kadar gürültü eklendiğinin bir ölçüsüdür ve çıktı ile taban görüntü arasındaki benzerliği etkiler.

* 📈 yüksek bir `strength` değeri, bir görselin daha fazla gürültüye maruz kaldığı ve gürültüden arındırma sürecinin daha uzun sürdüğü anlamına gelir; ancak temel görselden daha farklı ve daha yüksek kalitede görseller elde edersiniz
* 📉 düşük bir `strength` değeri, bir görselin daha az gürültüye maruz kaldığı ve gürültü azaltma sürecinin daha hızlı olduğu anlamına gelir; ancak görsel kalitesi o kadar iyi olmayabilir ve üretilen görsel, temel görseli daha fazla andırır

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

### Yönlendirme ölçeği

`guidance_scale`, metin komutu ile üretilen görsel arasındaki uyumu etkiler.

* 📈 yüksek bir `guidance_scale` değeri, istemin ve üretilen görselin sıkı bir şekilde hizalı olduğu anlamına gelir; bu nedenle çıktı, istemin daha katı bir yorumudur
* 📉 düşük bir `guidance_scale` değeri, istem ile üretilen görselin daha gevşek bir şekilde hizalı olduğu anlamına gelir; bu nedenle çıktı, istemden daha fazla farklılık gösterebilir

Modelin ne kadar ifade edici olacağı üzerinde daha fazla kontrol için `strength` ve `guidance_scale` değerlerini birlikte kullanabilirsiniz. Örneğin, yüksek `strength` ve `guidance_scale` değerlerinin birleşimi modele en yüksek yaratıcı özgürlüğü sağlar.

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

### Negatif istem

Negatif bir prompt, bir promptun tam tersi bir rol üstlenir; modeli, bir görüntüde belirli şeyleri üretmekten uzaklaştırır. Bu, görüntü kalitesini hızla iyileştirmek ve modelin istemediğiniz şeyleri üretmesini önlemek için kullanışlıdır.

```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 = "kötü mimari, istikrarsız, düşük detay, bulanık"
  

### Dolgu maskesi kırpma

Görsel doldurma (inpainting) kalitesini artırmak için [`padding_mask_crop`](https://huggingface.co/docs/diffusers/v0.25.0/en/api/pipelines/stable_diffusion/inpaint#diffusers.StableDiffusionInpaintPipeline.__call__.padding_mask_crop) parametresini kullanabilirsiniz. Bu seçenek etkinleştirildiğinde, maskelenmiş alan kullanıcı tarafından belirlenen bir dolgu (padding) ile kırpılır ve aynı alan orijinal görselden de kırpılır. Hem görsel hem de maske, doldurma işlemi için daha yüksek bir çözünürlüğe ölçeklenir ve ardından orijinal görselin üzerine bindirilir. Bu, [StableDiffusionUpscalePipeline](/docs/diffusers/main/tr/api/pipelines/stable_diffusion/upscale#diffusers.StableDiffusionUpscalePipeline) gibi ayrı bir pipeline kullanmadan görsel kalitesini geliştirmenin hızlı ve kolay bir yoludur.

Pipeline çağrısına `padding_mask_crop` parametresini ekleyin ve istenen dolgu değerine ayarlayın.

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

  
    
    varsayılan inpaint görüntüsü
  
  
    
    `padding_mask_crop` etkinleştirilmiş şekilde görüntü inpainting'i
  

## Zincirleme inpainting pipeline'ları

[AutoPipelineForInpainting](/docs/diffusers/main/tr/api/pipelines/auto_pipeline#diffusers.AutoPipelineForInpainting), diğer 🤗 Diffusers pipeline’larıyla zincirlenerek çıktıları düzenlemek için kullanılabilir. Bu, genellikle diğer difüzyon pipeline’larınızdan gelen çıktı kalitesini iyileştirmek için faydalıdır ve birden fazla pipeline kullanıyorsanız, çıktıları latent uzayda tutmak ve aynı pipeline bileşenlerini yeniden kullanmak için onları zincirlemenin daha bellek verimli olabileceğini belirtmek gerekir.

### Metinden görüntüye, görüntüden inpaint

Bir metinden görüntüye ve inpainting hattını zincirleme olarak kullanmak, üretilen görüntüyü inpaint etmenizi sağlar ve başlangıçta bir temel görüntü sunmanıza gerek kalmaz. Bu, tamamen yeni bir görüntü üretmek zorunda kalmadan favori metinden görüntüye çıktılarınızı düzenlemenizi kolaylaştırır.

Bir kale oluşturmak için metinden görüntüye hattıyla başlayın:

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

Yukarıdaki çıktının mask görüntüsünü yükleyin:

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

Ve maskelenmiş alanı bir şelale ile dolduralım:

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

  
    
    metinden görüntüye
  
  
    
    inpaint
  

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

Görüntü kalitesini artırmak için inpainting hattını, görüntüden görüntüye veya bir upscaler gibi başka bir hattın önüne zincirleyebilirsiniz.

Bir görüntüde inpainting yaparak başlayın:

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

Şimdi, görsel detaylarını ve kalitesini artırmak için görseli SDXL'in refiner modeliyle başka bir inpainting hattına gönderelim:

```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]
> Hattın gereksiz bir kodlama-çözme adımından kaçınmak için tüm çıktıları gizli uzayda tutmak üzere `output_type="latent"` parametresini belirtmek önemlidir. Bu, zincirlenmiş hatların aynı VAE'yi kullanması durumunda işe yarar. Örneğin, [Text-to-image-to-inpaint](#text-to-image-to-inpaint) bölümünde Kandinsky 2.2, Stable Diffusion modelinden farklı bir VAE sınıfı kullandığı için bu yöntem işe yaramaz. Ancak her iki hat için de Stable Diffusion v1.5 kullanırsanız, her ikisi de [AutoencoderKL](/docs/diffusers/main/tr/api/models/autoencoderkl#diffusers.AutoencoderKL) kullandığı için her şeyi gizli uzayda tutabilirsiniz.

Son olarak, bu görseli bir görselden görseli (image-to-image) hattına (pipeline) ileterek son rötuşları yapabilirsiniz. Mevcut hat bileşenlerini yeniden kullanmak ve tüm hat bileşenlerini gereksiz yere tekrar belleğe yüklemekten kaçınmak için [from_pipe()](/docs/diffusers/main/tr/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image.from_pipe) yöntemini kullanmak daha verimlidir.

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

  
    
    başlangıç görüntüsü
  
  
    
    inpaint
  
  
    
    görselden görseli
  

Görselden görselde ve inpainting aslında çok benzer görevlerdir. Görselden görselde, sağlanan mevcut görseli andıran yeni bir görsel oluşturulur. Inpainting de aynı şeyi yapar, ancak yalnızca maskenin tanımladığı görsel alanını dönüştürür ve görselin geri kalanı değiştirilmez. Inpainting'i, spesifik değişiklikler yapmak için daha hassas bir araç olarak; görselden görselde ise daha kapsamlı değişiklikler yapmak için daha geniş bir kapsam olarak düşünebilirsiniz.

## Görsel üretimini kontrol et

İstediğiniz görünüme sahip bir görüntü elde etmek, gürültü azaltma sürecinin rastgele olması nedeniyle zordur. `negative_prompt` gibi parametreleri yapılandırarak üretimin belirli yönlerini kontrol edebilirsiniz, ancak görüntü üretimini kontrol etmek için daha iyi ve daha verimli yöntemler mevcuttur.

### İstem ağırlıklandırma

Prompt ağırlıklandırma, bir prompt içindeki kavramların temsilini ölçeklendirmek için ölçülebilir bir yöntem sunar. Prompttaki her bir kavram için metin gömme vektörünün büyüklüğünü artırabilir veya azaltabilirsiniz; bu da her bir kavramın ne kadarının üretileceğini belirler. [Compel](https://github.com/damian0815/compel) kütüphanesi, prompt ağırlıklarını ölçeklendirmek ve gömme (embedding) oluşturmak için sezgisel bir sözdizimi sunar. Gömme oluşturma yöntemini [Prompt ağırlıklandırma](../using-diffusers/weighted_prompts) kılavuzunda inceleyin.

Embedding'leri oluşturduktan sonra bunları [AutoPipelineForInpainting](/docs/diffusers/main/tr/api/pipelines/auto_pipeline#diffusers.AutoPipelineForInpainting) içindeki `prompt_embeds` (negatif prompt kullanıyorsanız `negative_prompt_embeds`) parametresine iletin. Embedding'ler `prompt` parametresinin yerini alır:

```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 modelleri, Stable Diffusion gibi diğer difüzyon modelleriyle birlikte kullanılır ve bir görüntünün nasıl oluşturulacağını kontrol etmenin daha esnek ve doğru bir yolunu sunar. Bir ControlNet, difüzyon modelinin bu görüntüdeki özellikleri korumasını yönlendiren ek bir koşullandırma görüntüsü girdisi alır.

Örneğin, inpaint görüntülerinde ön eğitilmiş bir ControlNet ile bir görüntü koşullandıralım:

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

Şimdi taban, maske ve kontrol görüntülerinden bir görüntü oluşturun. Oluşturulan görüntüde taban görüntüsünün özelliklerinin güçlü bir şekilde korunduğunu fark edeceksiniz.

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

Bunu bir adım daha ileriye taşıyıp yeni bir [stil](https://huggingface.co/nitrosocke/elden-ring-diffusion) uygulamak için görüntüden görüntüye hattıyla zincirleyebilirsiniz:

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

  
    
    başlangıç görüntüsü
  
  
    
    ControlNet inpaint
  
  
    
    görselden görseli
  

## Optimize et

Kaynak kısıtlıysa difüzyon modellerini çalıştırmak zor ve yavaş olabilir, ancak birkaç optimizasyon püf noktasıyla bu durumun böyle olması gerekmez. Etkinleştirebileceğiniz en büyük (ve en kolay) optimizasyonlardan biri, bellek verimli dikkate geçmektir. PyTorch 2.0 kullanıyorsanız, [scaled-dot product attention](../optimization/fp16#scaled-dot-product-attention) otomatik olarak etkinleştirilir ve başka bir şey yapmanıza gerek yoktur. PyTorch 2.0 dışındaki kullanıcılar için, bellek verimli dikkatin [xFormers](../optimization/attention_backends) uygulamasını kurup kullanabilirsiniz. Her iki seçenek de bellek kullanımını azaltır ve çıkarımı hızlandırır.

Modeli daha fazla bellek tasarrufu sağlamak için CPU'ya da aktarabilirsiniz:

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

Çıkarım kodunuzu daha da hızlandırmak için [`torch_compile`](../optimization/fp16#torchcompile) kullanın. `torch.compile` ile, genellikle UNet olan, hattın en yoğun bileşenini sarmalayıp çevrelemelisiniz:

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

Daha fazla bilgi için [Bellek kullanımını azaltma](../optimization/memory) ve [Çıkarımı hızlandırma](../optimization/fp16) kılavuzlarına göz atın.