# Latent büyütücü

Stable Diffusion latent upscaler modeli, [Katherine Crowson](https://github.com/crowsonkb/k-diffusion) tarafından [Stability AI](https://stability.ai/) ile iş birliği içinde oluşturulmuştur. Çıktı görüntüsünün çözünürlüğünü 2 katına çıkarmak için kullanılır (orijinal uygulamanın bir gösterimi için bu demo [notebook](https://colab.research.google.com/drive/1o1qYJcFeywzCIdkfKJy7cTpgZTCM2EI4)'a bakın).

> [!TIP]
> Scheduler hızı ve kalitesi arasındaki ödünleşimi nasıl keşfedebileceğinizi ve pipeline bileşenlerini nasıl verimli bir şekilde yeniden kullanabileceğinizi öğrenmek için Stable Diffusion [İpuçları](overview#tips) bölümünü mutlaka inceleyin!
>
> Bir görev için resmi kontrol noktalarından birini kullanmakla ilgileniyorsanız, [CompVis](https://huggingface.co/CompVis) ve [Stability AI](https://huggingface.co/stabilityai) Hub kuruluşlarını keşfedin!

## StableDiffusionLatentUpscalePipeline[[diffusers.StableDiffusionLatentUpscalePipeline]]

#### diffusers.StableDiffusionLatentUpscalePipeline[[diffusers.StableDiffusionLatentUpscalePipeline]]

```python
diffusers.StableDiffusionLatentUpscalePipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: EulerDiscreteScheduler)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_latent_upscale.py#L84)

**Parametreler:**

vae ([AutoencoderKL](/docs/diffusers/main/tr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Görüntüleri latent temsillere kodlamak ve bu temsillerden görüntülere çözmek için kullanılan Varyasyonel Oto-Kodlayıcı (VAE) modeli.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : Donmuş metin kodlayıcı ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Metni belirteçleştirmek için bir `CLIPTokenizer`.

unet ([UNet2DConditionModel](/docs/diffusers/main/tr/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Kodlanmış görüntü latentlerini gürültüden arındırmak için kullanılan bir `UNet2DConditionModel`.

scheduler ([SchedulerMixin](/docs/diffusers/main/tr/api/schedulers/overview#diffusers.SchedulerMixin)) : Kodlanmış görüntü latentlerini gürültüden arındırmak için `unet` ile birlikte kullanılacak bir [EulerDiscreteScheduler](/docs/diffusers/main/tr/api/schedulers/euler#diffusers.EulerDiscreteScheduler).

Stable Diffusion çıktı görüntüsü çözünürlüğünü 2 katına çıkarmak için kullanılan Pipeline.

Bu model [DiffusionPipeline](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline) sınıfından devralınmıştır. Tüm pipeline'lar için uygulanan genel yöntemlerin (indirme, kaydetme, belirli bir cihazda çalıştırma vb.) belgelerini üst sınıfın dokümantasyonunda bulabilirsiniz.

Pipeline ayrıca aşağıdaki yükleme yöntemlerini devralır:
- `.ckpt` dosyalarını yüklemek için [from_single_file()](/docs/diffusers/main/tr/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file)

#### __call__[[diffusers.StableDiffusionLatentUpscalePipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, num_inference_steps: int = 75, guidance_scale: float = 9.0, negative_prompt: str | list[str] | None = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_latent_upscale.py#L396)

**Parametreler:**

prompt (`str` veya `list[str]`) : Görsel büyütme işlemini yönlendirmek için istem veya istemler.

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` veya `list[np.ndarray]`) : `Image` veya ölçeklendirilecek bir görüntü partisini temsil eden tensör. Tensör ise, bir Stable Diffusion modelinden gelen latent çıktı veya `[-1, 1]` aralığında bir görüntü tensörü olabilir. `image.shape[1]` değeri `4` ise `latent` olarak kabul edilir; aksi takdirde bir görüntü temsili olarak kabul edilir ve bu hattın `vae` kodlayıcısı kullanılarak kodlanır.

num_inference_steps (`int`, *isteğe bağlı*, varsayılan 50) : Gürültü azaltma adım sayısı. Daha fazla gürültü azaltma adımı genellikle daha yavaş çıkarım pahasına daha yüksek kaliteli bir görüntüye yol açar.

guidance_scale (`float`, *opsiyonel*, varsayılan 7.5) : Daha yüksek bir guidance scale değeri, modelin `prompt` ile yakından ilişkili görseller üretmesini teşvik eder; bunun bedeli ise daha düşük görsel kalitedir. Guidance scale, `guidance_scale > 1` olduğunda etkinleşir.

negative_prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimde nelerin dahil edilmeyeceğini yönlendirmek için istem veya istemler. Tanımlanmadıysa bunun yerine `negative_prompt_embeds` parametresini geçmeniz gerekir. Yönlendirme kullanılmadığında (`guidance_scale < 1`) yok sayılır.

generator (`torch.Generator` veya `list[torch.Generator]`, *isteğe bağlı*) : Üretimi deterministik hale getirmek için bir [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html).

latents (`torch.Tensor`, *isteğe bağlı*) : Görsel üretimi için girdi olarak kullanılacak, Gauss dağılımından örneklenen önceden oluşturulmuş gürültülü latensler. Farklı istemlerle aynı üretimi ayarlamak için kullanılabilir. Sağlanmazsa, sağlanan rastgele `generator` kullanılarak örneklem yoluyla bir latens tensörü oluşturulur.

prompt_embeds (`torch.Tensor`, *isteğe bağlı*) : Önceden oluşturulmuş metin gömme değerleri. Metin girdilerini (istek ağırlıklandırması) kolayca ayarlamak için kullanılabilir. Sağlanmazsa, metin gömme değerleri `prompt` girdi argümanından üretilir.

negative_prompt_embeds (`torch.Tensor`, *isteğe bağlı*) : Ön oluşturulmuş negatif metin gömme değerleri. Metin girdilerini (istek ağırlıklandırması) kolayca ayarlamak için kullanılabilir. Sağlanmazsa, `negative_prompt_embeds`, `negative_prompt` girdi argümanından üretilir.

pooled_prompt_embeds (`torch.Tensor`, *isteğe bağlı*) : Önceden oluşturulmuş havuzlanmış metin gömme değerleri. Metin girdilerini (istek ağırlıklandırması) kolayca ayarlamak için kullanılabilir. Sağlanmazsa, havuzlanmış metin gömme değerleri `prompt` girdi argümanından üretilir.

negative_pooled_prompt_embeds (`torch.Tensor`, *isteğe bağlı*) : Ön oluşturulmuş negatif havuzlanmış metin gömme değerleri. Metin girdilerini (istek ağırlıklandırması) kolayca ayarlamak için kullanılabilir. Sağlanmazsa, havuzlanmış `negative_prompt_embeds`, `negative_prompt` girdi argümanından oluşturulur.

output_type (`str`, *isteğe bağlı*, varsayılan `"pil"`) : Üretilen görüntünün çıktı biçimi. `PIL.Image` veya `np.array` arasında seçim yapın.

return_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Düz bir tuple yerine [StableDiffusionPipelineOutput](/docs/diffusers/main/tr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) döndürülüp döndürülmemesi.

callback (`Callable`, *isteğe bağlı*) : Çıkarım sırasında her `callback_steps` adımda çağrılan bir işlev. İşlev aşağıdaki argümanlarla çağrılır: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *isteğe bağlı*, varsayılan 1) : `callback` fonksiyonunun çağrılma sıklığı. Belirtilmezse, callback her adımda çağrılır.

**Dönüş:** [StableDiffusionPipelineOutput](/docs/diffusers/main/tr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) veya `tuple`

`return_dict` `True` ise [StableDiffusionPipelineOutput](/docs/diffusers/main/tr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) döndürülür, aksi halde ilk öğesi üretilen görüntülerin listesini içeren bir `tuple` döndürülür.

Üretim için pipeline'ın çağrı fonksiyonu.

Örnekler:
```py
>>> from diffusers import StableDiffusionLatentUpscalePipeline, StableDiffusionPipeline
>>> import torch

>>> pipeline = StableDiffusionPipeline.from_pretrained(
...     "CompVis/stable-diffusion-v1-4", torch_dtype=torch.float16
... )
>>> pipeline.to("cuda")

>>> model_id = "stabilityai/sd-x2-latent-upscaler"
>>> upscaler = StableDiffusionLatentUpscalePipeline.from_pretrained(model_id, torch_dtype=torch.float16)
>>> upscaler.to("cuda")

>>> prompt = "a photo of an astronaut high resolution, unreal engine, ultra realistic"
>>> generator = torch.manual_seed(33)

>>> low_res_latents = pipeline(prompt, generator=generator, output_type="latent").images

>>> with torch.no_grad():
...     image = pipeline.decode_latents(low_res_latents)
>>> image = pipeline.numpy_to_pil(image)[0]

>>> image.save("../images/a1.png")

>>> upscaled_image = upscaler(
...     prompt=prompt,
...     image=low_res_latents,
...     num_inference_steps=20,
...     guidance_scale=0,
...     generator=generator,
... ).images[0]

>>> upscaled_image.save("../images/a2.png")
```

#### enable_sequential_cpu_offload[[diffusers.StableDiffusionLatentUpscalePipeline.enable_sequential_cpu_offload]]

```python
enable_sequential_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = None)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L1293)

**Parametreler:**

gpu_id (`int`, *opsiyonel*) : Çıkarımda kullanılacak hızlandırıcının kimliği. Belirtilmezse, varsayılan olarak 0 kullanılır.

device (`torch.Device` veya `str`, *isteğe bağlı*, varsayılanı None) : Çıkarımda kullanılacak hızlandırıcının PyTorch cihaz türü. Belirtilmezse, kullanılabilir hızlandırıcı otomatik olarak algılanır ve kullanılır.

🤗 Accelerate kullanılarak tüm modeller CPU'ya aktarılır ve bellek kullanımı önemli ölçüde azaltılır. Çağrıldığında, `self._exclude_from_cpu_offload` içindekiler hariç olmak üzere tüm `torch.nn.Module` bileşenlerinin durum sözlükleri (state dicts) CPU'ya kaydedilir, ardından `torch.device('meta')` konumuna taşınır ve yalnızca ilgili alt modülün `forward` metodu çağrıldığında hızlandırıcıya (accelerator) yüklenir. Aktarma işlemi alt modül bazında gerçekleşir. Bellek tasarrufu `enable_model_cpu_offload` ile karşılaştırıldığında daha yüksektir, ancak performans daha düşüktür.

#### enable_attention_slicing[[diffusers.StableDiffusionLatentUpscalePipeline.enable_attention_slicing]]

```python
enable_attention_slicing(slice_size: str | int = 'auto')
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2048)

**Parametreler:**

slice_size (`str` veya `int`, *isteğe bağlı*, varsayılan `"auto"`) : `"auto"` olduğunda, dikkat başlarına giden girdiyi ikiye böler, böylece dikkat iki adımda hesaplanır. `"max"` ise, her seferinde yalnızca bir dilim çalıştırılarak maksimum miktarda bellek tasarrufu sağlanır. Bir sayı sağlanırsa, `attention_head_dim // slice_size` kadar dilim kullanılır. Bu durumda `attention_head_dim`, `slice_size`'ın katı olmalıdır.

Dilimlenmiş dikkat (attention) hesaplamasını etkinleştirir. Bu seçenek etkinleştirildiğinde, dikkat modülü dikkat hesaplamasını birkaç adımda gerçekleştirmek için girdi tensörünü dilimlere böler. Birden fazla dikkat başlığı (attention head) varsa, hesaplama her başlık üzerinde sırayla yapılır. Bu, küçük bir hız kaybı karşılığında bellek tasarrufu sağlamak için faydalıdır.

> [!WARNING] > ⚠️ Zaten `scaled_dot_product_attention` (SDPA) kullanıyorsanız dikkat dilimlemeyi etkinleştirmeyin
from PyTorch > 2.0 or xFormers. Bu dikkat hesaplamaları zaten çok bellek verimlidir, bu yüzden bu işlevi etkinleştirmenize gerek yoktur. SDPA veya xFormers ile dikkat dilimlemeyi etkinleştirirseniz, ciddi yavaşlamalara yol açabilir!

Örnekler:

```py
>>> import torch
>>> from diffusers import StableDiffusionPipeline

>>> pipe = StableDiffusionPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5",
...     dtype=torch.float16,
...     use_safetensors=True,
... )

>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> pipe.enable_attention_slicing()
>>> image = pipe(prompt).images[0]
```

#### disable_attention_slicing[[diffusers.StableDiffusionLatentUpscalePipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2085)

Dilimlenmiş dikkat hesaplamasını devre dışı bırakır. `enable_attention_slicing` daha önce çağrıldıysa, dikkat tek adımda hesaplanır.

#### enable_xformers_memory_efficient_attention[[diffusers.StableDiffusionLatentUpscalePipeline.enable_xformers_memory_efficient_attention]]

```python
enable_xformers_memory_efficient_attention(attention_op: typing.Optional[typing.Callable] = None)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L1993)

**Parametreler:**

attention_op (`Callable`, *isteğe bağlı*) : xFormers'in [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) fonksiyonunda `op` argümanı olarak kullanılmak üzere varsayılan `None` operatörünü geçersiz kılar.

[xFormers](https://facebookresearch.github.io/xformers/) ile bellek verimli dikkati etkinleştirin. Bu seçenek etkinleştirildiğinde, GPU bellek kullanımının daha düşük olduğunu ve çıkarım sırasında olası bir hızlanmayı gözlemlemelisiniz. Eğitim sırasında hızlanma garanti edilmemektedir.

> [!WARNING] > ⚠️ Hem memory efficient attention hem de sliced attention etkinleştirildiğinde, memory efficient
attention, > önceliğine sahiptir.

Örnekler:

```py
>>> import torch
>>> from diffusers import DiffusionPipeline
>>> from xformers.ops import MemoryEfficientAttentionFlashAttentionOp

>>> pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1", dtype=torch.float16)
>>> pipe = pipe.to("cuda")
>>> pipe.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)
>>> # Workaround for not accepting attention shape using VAE for Flash Attention
>>> pipe.vae.enable_xformers_memory_efficient_attention(attention_op=None)
```

#### disable_xformers_memory_efficient_attention[[diffusers.StableDiffusionLatentUpscalePipeline.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2024)

[xFormers](https://facebookresearch.github.io/xformers/) için bellek verimli dikkati devre dışı bırakın.

#### encode_prompt[[diffusers.StableDiffusionLatentUpscalePipeline.encode_prompt]]

```python
encode_prompt(prompt, device, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_latent_upscale.py#L166)

**Parametreler:**

prompt (`str` veya `list(int)`) : kodlanacak prompt

device : (`torch.device`): torch cihazı

do_classifier_free_guidance (`bool`) : sınıflandırıcı serbest yönlendirmenin (classifier free guidance) kullanılıp kullanılmayacağı

negative_prompt (`str` veya `list[str]`) : Görsel üretimi yönlendirmemek için kullanılan istem veya istemler. Yönlendirme kullanılmadığında yok sayılır (yani `guidance_scale` `1`'den küçükse yok sayılır).

prompt_embeds (`torch.FloatTensor`, *isteğe bağlı*) : Ön oluşturulmuş metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, *ör.* istem ağırlıklandırması. Sağlanmazsa, metin gömme değerleri `prompt` girdi argümanından oluşturulur.

negative_prompt_embeds (`torch.FloatTensor`, *isteğe bağlı*) : Önceden oluşturulmuş negatif metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, *ör.* istem ağırlıklandırması. Sağlanmazsa, negative_prompt_embeds, `negative_prompt` girdi argümanından oluşturulur.

pooled_prompt_embeds (`torch.Tensor`, *isteğe bağlı*) : Önceden oluşturulmuş havuzlanmış metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, *ör.* istem ağırlıklandırması. Sağlanmazsa, havuzlanmış metin gömme değerleri `prompt` girdi argümanından oluşturulur.

negative_pooled_prompt_embeds (`torch.Tensor`, *isteğe bağlı*) : Ön oluşturulmuş negatif havuzlanmış metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, *ör.* istem ağırlıklandırması. Sağlanmazsa, havuzlanmış negative_prompt_embeds, `negative_prompt` girdi argümanından oluşturulacaktır.

İsteği metin kodlayıcı gizli durumlarına kodlar.

## StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]

#### diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]

```python
diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray, nsfw_content_detected: list[bool] | None)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_output.py#L10)

**Parametreler:**

images (`list[PIL.Image.Image]` veya `np.ndarray`) : `batch_size` uzunluğunda gürültüsü azaltılmış PIL görüntülerinin listesi veya `(batch_size, height, width, num_channels)` biçiminde NumPy dizisi.

nsfw_content_detected (`list[bool]`) : Üretilen ilgili görüntünün "iş yerinde uygun olmayan" (nsfw) içerik içerip içermediğini gösteren liste veya güvenlik kontrolü yapılamadıysa `None`.

Stable Diffusion hatları için çıktı sınıfı.