# Görselden görseli

Image-to-image, [text-to-image](conditional_image_generation) ile benzerdir; ancak bir istem (prompt) ek olarak, difüzyon sürecinin başlangıç noktası olarak bir başlangıç görseli de geçebilirsiniz. Başlangıç görseli latent uzaya kodlanır ve üzerine gürültü eklenir. Ardından latent difüzyon modeli, bir istem ve gürültülü latent görseli alır, eklenen gürültüyü tahmin eder ve başlangıç latent görselinden tahmin edilen gürültüyü çıkararak yeni latent görseli elde eder. Son olarak, bir çözücü (decoder) yeni latent görseli tekrar bir görsel olarak çözer.

🤗 Diffusers ile bu, 1-2-3 kadar kolaydır:

1. Bir kontrol noktasını [AutoPipelineForImage2Image](/docs/diffusers/main/tr/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image) sınıfına yükleyin; bu pipeline, kontrol noktasına dayanarak doğru pipeline sınıfını yüklemeyi otomatik olarak yönetir:

```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]
> 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 zorunda değilsiniz çünkü PyTorch 2.0'ın yerel [scaled-dot product attention](../optimization/fp16#scaled-dot-product-attention) özelliğini zaten kullanıyor olacaktır.

2. Hattaya aktarılacak bir görüntü yükleyin:

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

3. Bir istem ve bir görüntüyü boru hattına iletin:

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

  
    
    başlangıç görüntüsü
  
  
    
    oluşturulan görsel
  

## Popüler modeller

En popüler görüntüden görüntüye modeller [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) ve [Kandinsky 2.2](https://huggingface.co/kandinsky-community/kandinsky-2-2-decoder)'dir. Stable Diffusion ve Kandinsky modellerinin sonuçları, mimari farklılıkları ve eğitim süreçleri nedeniyle değişir; genel olarak SDXL'in Stable Diffusion v1.5'e kıyasla daha yüksek kaliteli görüntüler üretmesini bekleyebilirsiniz. Bu modellerin her birinin nasıl kullanılacağına ve sonuçlarının karşılaştırılmasına kısaca bakalım.

### Stable Diffusion v1.5

Stable Diffusion v1.5, daha önceki bir kontrol noktasından (checkpoint) başlatılan ve 512x512 boyutundaki görseller üzerinde 595K adım boyunca daha fazla ince ayar (finetune) yapılan bir latent difüzyon modelidir. Bu hattı (pipeline) görselden görseli (image-to-image) için kullanmak için, hatta iletilecek başlangıç görselini hazırlamanız gerekir. Ardından, yeni bir görsel üretmek için bir istemciyi (prompt) ve görseli hatta iletebilirsiniz:

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

  
    
    başlangıç görüntüsü
  
  
    
    oluşturulan görsel
  

### Stable Diffusion XL (SDXL)

SDXL, Stable Diffusion modelinin daha güçlü bir sürümüdür. Daha büyük bir temel model ve temel modelin çıktısının kalitesini artırmak için ek bir iyileştirici (refiner) model kullanır. Bu modelin nasıl kullanılacağına ve yüksek kaliteli görseller üretmek için kullandığı diğer tekniklere dair daha ayrıntılı bir anlatım için [SDXL](../api/pipelines/stable_diffusion/stable_diffusion_xl) kılavuzunu okuyun.

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

  
    
    başlangıç görüntüsü
  
  
    
    oluşturulan görsel
  

### Kandinsky 2.2

Kandinsky modeli, gömülü görüntüleri oluşturmak için bir görüntü öncesi modeli kullandığı için Stable Diffusion modellerinden farklıdır. Gömülü değerler, metin ile görüntüler arasında daha iyi bir hizalama oluşturarak gizli difüzyon modelinin daha iyi görüntüler üretmesine olanak tanır.

Kandinsky 2.2'yi kullanmanın en basit yolu şudur:

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

  
    
    başlangıç görüntüsü
  
  
    
    oluşturulan görsel
  

## Hattın parametrelerini yapılandır

Pipeline'da, görüntü oluşturma sürecini ve görüntü kalitesini etkileyecek birkaç önemli parametreyi yapılandırabilirsiniz. Bu parametrelerin ne işe yaradığına ve bunları değiştirmenin çıktıyı nasıl etkilediğine daha yakından bakalım.

### Güç

`strength`, dikkate alınması gereken en önemli parametrelerden biridir ve oluşturduğunuz görsel üzerinde büyük bir etkiye sahip olacaktır. Oluşturulan görselin başlangıç görseline ne kadar benzediğini belirler. Başka bir deyişle:

- 📈 daha yüksek bir `strength` değeri, modele başlangıç görüntüsünden farklı bir görüntü üretme konusunda daha fazla "yaratıcılık" sağlar; `strength` değeri 1.0 ise başlangıç görüntüsünün büyük ölçüde yok sayıldığını ifade eder
- 📉 daha düşük bir `strength` değeri, üretilen görüntünün başlangıç görüntüsüne daha benzer olduğu anlamına gelir

`strength` ve `num_inference_steps` parametreleri, `strength` eklenecek gürültü adım sayısını belirlediği için birbirine bağlıdır. Örneğin, `num_inference_steps` 50 ve `strength` 0.8 ise, bu, başlangıç görüntüsüne 40 (50 * 0.8) adım gürültü eklenip ardından yeni oluşturulan görüntüye ulaşmak için 40 adım boyunca gürültünün giderilmesi anlamına gelir.

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

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

`guidance_scale` parametresi, üretilen görselin metin komutuyla ne kadar uyumlu olduğunu kontrol etmek için kullanılır. Daha yüksek bir `guidance_scale` değeri, üretilen görselin komutla daha uyumlu olduğu anlamına gelirken, daha düşük bir `guidance_scale` değeri, üretilen görselin komuttan sapması için daha fazla esnekliğe sahip olduğu anlamına gelir.

`guidance_scale` parametresini `strength` parametresiyle birleştirerek modelin ne kadar ifade edici olacağı üzerinde daha da hassas bir kontrol sağlayabilirsiniz. Örneğin, maksimum yaratıcılık için yüksek `strength + guidance_scale` değerlerini birleştirebilir veya başlangıçtaki görseli andıran ancak isteme (prompt) o kadar sıkı bağlı olmayan bir görsel üretmek için düşük `strength` ve düşük `guidance_scale` değerlerinin bir kombinasyonunu kullanabilirsiniz.

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

### Negatif istem

Negatif bir prompt, modelin bir görselde belirli öğeleri *barındırmamasını* koşullandırır ve görsel kalitesini iyileştirmek veya bir görseli değiştirmek için kullanılabilir. Örneğin, "poor details" veya "blurry" gibi negatif promptlar ekleyerek modelin daha yüksek kalitede bir görsel üretmesini teşvik edebilir ve böylece görsel kalitesini artırabilirsiniz. Ya da bir görselden hariç tutulacak öğeleri belirleyerek görseli değiştirebilirsiniz.

```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 = "çirkin, deforme, sakat, kötü detaylar, kötü anatomi"
  
  
    
    negative_prompt = "jungle"
  

## Zincirleme görüntüden görüntüye boru hatları

Görselden görsel hattını yalnızca bir görsel üretmek için değil (ki bu da oldukça etkileyici), başka ilginç şekillerde de kullanabilirsiniz. Bir adım daha ileri gidip onu diğer hatlarla zincirleyebilirsiniz.

### Metinden görüntüye görüntü

Bir metinden görüntüye ve görüntüden görüntüye hattını zincirleme olarak kullanmak, metinden bir görüntü oluşturmanızı ve oluşturulan görüntüyü görüntüden görüntüye hattı için başlangıç görüntüsü olarak kullanmanızı sağlar. Bu, bir görüntüyü tamamen sıfırdan oluşturmak istediğinizde faydalıdır. Örneğin, bir Stable Diffusion ve bir Kandinsky modelini zincirleyelim.

Metinden görüntüye hattını kullanarak bir görüntü oluşturarak başlayın:

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

Şimdi bu oluşturulan görüntüyü görüntüden-görüntüye hattına iletebilirsiniz:

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

### Görselden görselle görsel

Birden fazla görüntüden-görüntüye hattını birbiri ardına bağlayarak daha ilgi çekici görüntüler oluşturabilirsiniz. Bu, bir görüntü üzerinde yinelemeli olarak stil aktarımı yapmak, kısa GIF'ler üretmek, bir görüntüye renk geri yüklemek veya bir görüntünün eksik alanlarını onarmak için faydalı olabilir.

Bir görüntü oluşturarak başlayın:

```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]
> 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 belirtmesi önemlidir. Bu, zincirlenmiş hatların aynı VAE'yi kullanması durumunda çalışır.

Bu hattın gizli çıktısını bir sonraki hatta ileterek [çizgi roman sanatı tarzında](https://huggingface.co/ogkalu/Comic-Diffusion) bir görüntü oluşturun:

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

Son görseli [pixel art stilinde](https://huggingface.co/kohbanye/pixel-art-style) oluşturmak için bir kez daha tekrarlayın:

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

### Görselden yükselticiden süper çözünürlüğe

Görselden görseli (image-to-image) hattınızı bir upscaler ve süper çözünürlük (super-resolution) hattıyla birleştirerek görseldeki detay seviyesini gerçekten artırabilirsiniz.

Bir görüntüden görüntüye hattıyla başlayın:

```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]
> Hattın gereksiz bir çözümlüme-kodlama adımından kaçınmak için tüm çıktıları *latent* uzayda tutmak için `output_type="latent"` parametresini belirtmek önemlidir. Bu, zincirlenmiş hatların aynı VAE'yi kullanması durumunda çalışır.

Görüntü çözünürlüğünü artırmak için bir upscaler hattına bağlayın:

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

Son olarak, çözünürlüğü daha da artırmak için bunu süper çözünürlük hattına bağlayın:

```py
from diffusers import StableDiffusionUpscalePipeline

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

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

## Görsel üretimini kontrol et

Tam olarak istediğiniz gibi görünen bir görüntü üretmeye çalışmak zor olabilir; bu nedenle kontrollü üretim teknikleri ve modelleri son derece faydalıdır. `negative_prompt` ile görüntü üretimini kısmen kontrol edebilirsiniz ancak prompt ağırlıklandırma ve ControlNets gibi daha sağlam yöntemler de mevcuttur.

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

Prompt ağırlıklandırma, bir prompttaki her bir kavramın temsilini ölçeklemenizi sağlar. Örneğin, "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" gibi bir promptta, "astronaut" ve "jungle" gömme değerlerini (embeddings) artırabilir veya azaltabilirsiniz. [Compel](https://github.com/damian0815/compel) kütüphanesi, prompt ağırlıklarını ayarlamak ve gömme değerlerini oluşturmak için basit bir sözdizimi sunar. Gömme değerlerinin nasıl oluşturulacağını [Prompt ağırlıklandırma](weighted_prompts) kılavuzunda öğrenebilirsiniz.

[AutoPipelineForImage2Image](/docs/diffusers/main/tr/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image), `prompt` parametresinin yerini alan gömme değerlerini geçebileceğiniz bir `prompt_embeds` (negatif prompt kullanıyorsanız `negative_prompt_embeds`) parametresine sahiptir.

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

ControlNet'ler, ek bir koşullandırma görüntüsü kullanabilmeniz sayesinde görüntü üretimini kontrol etmenin daha esnek ve doğru bir yolunu sunar. Koşullandırma görüntüsü bir canny görüntüsü, derinlik haritası, görüntü segmentasyonu ve hatta karalamalar olabilir! Hangi tür koşullandırma görüntüsü seçerseniz seçin, ControlNet içindeki bilgileri koruyan bir görüntü üretir.

Örneğin, görüntüdeki uzamsal bilgileri korumak için bir görüntüyü derinlik haritasıyla koşullandıralım.

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

Derinlik haritalarına koşullu bir ControlNet modeli ve [AutoPipelineForImage2Image](/docs/diffusers/main/tr/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image)'i yükleyin:

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

Şimdi derinlik haritasına, başlangıç görüntüsüne ve isteme göre koşullandırılmış yeni bir görüntü oluşturun:

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

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

ControlNet'ten üretilen görseli bir görselden görseli (image-to-image) hattıyla zincirleyerek yeni bir [stil](https://huggingface.co/nitrosocke/elden-ring-diffusion) uygulayalım:

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

  

## Optimize et

Difüzyon modellerini çalıştırmak hesaplama açısından pahalı ve yoğun bir süreçtir; ancak birkaç optimizasyon püf noktasıyla bunları tüketici ve ücretsiz katman GPU'larında çalıştırmak tamamen mümkündür. Örneğin, PyTorch 2.0'ın [scaled-dot product attention](../optimization/fp16#scaled-dot-product-attention) veya [xFormers](../optimization/attention_backends) gibi daha bellek verimli bir dikkat biçimi kullanabilirsiniz (bunlardan birini veya diğerini kullanabilirsiniz, ancak her ikisini birden kullanmanıza gerek yoktur). Ayrıca, diğer pipeline bileşenleri CPU'da beklerken modeli GPU'ya aktarabilirsiniz.

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

[`torch.compile`](../optimization/fp16#torchcompile) ile UNet'inizi bununla sarmalayarak çıkarım hızınızı daha da artırabilirsiniz:

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

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