# Tutarlılık Çözücü

Consistency decoder, [StableDiffusionPipeline](/docs/diffusers/main/tr/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) içindeki denoising UNet'ten latentleri çözmek için kullanılabilir. Bu decoder, [DALL-E 3 teknik raporu](https://openai.com/dall-e-3)nda tanıtılmıştır.

Orijinal kod tabanı [openai/consistencydecoder](https://github.com/openai/consistencydecoder) adresinde bulunabilir.

> [!WARNING]
> Şu anda çıkarım yalnızca 2 yineleme için desteklenmektedir.

Bu pipeline, [bu sorundan](https://github.com/openai/consistencydecoder/issues/1) [madebyollin](https://github.com/madebyollin) ve [mrsteyk](https://github.com/mrsteyk)'in yardımı olmadan katkı olarak sunulamazdı.

## ConsistencyDecoderVAE[[diffusers.ConsistencyDecoderVAE]]

#### diffusers.ConsistencyDecoderVAE[[diffusers.ConsistencyDecoderVAE]]

```python
diffusers.ConsistencyDecoderVAE(scaling_factor: float = 0.18215, latent_channels: int = 4, sample_size: int = 32, encoder_act_fn: str = 'silu', encoder_block_out_channels: tuple = (128, 256, 512, 512), encoder_double_z: bool = True, encoder_down_block_types: tuple = ('DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D'), encoder_in_channels: int = 3, encoder_layers_per_block: int = 2, encoder_norm_num_groups: int = 32, encoder_out_channels: int = 4, decoder_add_attention: bool = False, decoder_block_out_channels: tuple = (320, 640, 1024, 1024), decoder_down_block_types: tuple = ('ResnetDownsampleBlock2D', 'ResnetDownsampleBlock2D', 'ResnetDownsampleBlock2D', 'ResnetDownsampleBlock2D'), decoder_downsample_padding: int = 1, decoder_in_channels: int = 7, decoder_layers_per_block: int = 3, decoder_norm_eps: float = 1e-05, decoder_norm_num_groups: int = 32, decoder_num_train_timesteps: int = 1024, decoder_out_channels: int = 6, decoder_resnet_time_scale_shift: str = 'scale_shift', decoder_time_embedding_type: str = 'learned', decoder_up_block_types: tuple = ('ResnetUpsampleBlock2D', 'ResnetUpsampleBlock2D', 'ResnetUpsampleBlock2D', 'ResnetUpsampleBlock2D'))
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/consistency_decoder_vae.py#L51)

DALL-E 3 ile kullanılan tutarlılık çözücü.

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

>>> vae = ConsistencyDecoderVAE.from_pretrained("openai/consistency-decoder", torch_dtype=torch.float16)
>>> pipe = StableDiffusionPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5", vae=vae, torch_dtype=torch.float16
... ).to("cuda")

>>> image = pipe("horse", generator=torch.manual_seed(0)).images[0]
>>> image
```

#### decode[[diffusers.ConsistencyDecoderVAE.decode]]

```python
decode(z: Tensor, generator: typing.Optional[torch.Generator] = None, return_dict: bool = True, num_inference_steps: int = 2)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/consistency_decoder_vae.py#L220)

**Parametreler:**

z (torch.Tensor) : Girdi gizli vektörü.

generator (torch.Generator | None) : Rastgele sayı üreteci. Varsayılan değeri None'dir.

return_dict (bool) : Çıktının sözlük olarak döndürülüp döndürülmeyeceğini belirtir. Varsayılan değer True'dur.

num_inference_steps (int) : Çıkarım adım sayısı. Varsayılan değer 2'dir.

**Dönüş:** DecoderOutput | tuple[torch.Tensor]

Çözümlenmiş çıktı.

Girdi gizil vektörü `z`'yi tutarlılık çözücü VAE modeli kullanarak çözer.

#### encode[[diffusers.ConsistencyDecoderVAE.encode]]

```python
encode(x: Tensor, return_dict: bool = True)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/consistency_decoder_vae.py#L185)

**Parametreler:**

x (`torch.Tensor`) : Giriş görüntü partisi.

return_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Düz bir tuple yerine `ConsistencyDecoderVAEOutput` döndürülüp döndürülmemesi.

**Dönüş:**

Kodlanmış görüntülerin gizil (latent) temsilleri. `return_dict` True ise bir `ConsistencyDecoderVAEOutput` döndürülür, aksi halde düz bir `tuple` döndürülür.

Bir görüntü grubunu latentlere kodlayın.

#### forward[[diffusers.ConsistencyDecoderVAE.forward]]

```python
forward(sample: Tensor, sample_posterior: bool = False, return_dict: bool = True, generator: typing.Optional[torch.Generator] = None)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/consistency_decoder_vae.py#L336)

**Parametreler:**

sample (`torch.Tensor`) : Girdi örneği.

sample_posterior (`bool`, *isteğe bağlı*, varsayılan `False`) : Posterior'dan örneklemeye alınıp alınmayacağı.

return_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Düz bir tuple yerine `DecoderOutput` döndürülüp döndürülmemesi.

generator (`torch.Generator`, *isteğe bağlı*, varsayılan `None`) : Örnekleme için kullanılacak üreteç.

**Dönüş:** `DecoderOutput` veya `tuple`

return_dict True ise `DecoderOutput` döndürülür, aksi takdirde düz bir `tuple` döndürülür.

#### set_default_attn_processor[[diffusers.ConsistencyDecoderVAE.set_default_attn_processor]]

```python
set_default_attn_processor()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/consistency_decoder_vae.py#L170)

Özel dikkat işleyicilerini devre dışı bırakır ve varsayılan dikkat uygulamasını ayarlar.

#### tiled_encode[[diffusers.ConsistencyDecoderVAE.tiled_encode]]

```python
tiled_encode(x: Tensor, return_dict: bool = True)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/consistency_decoder_vae.py#L281)

**Parametreler:**

x (`torch.Tensor`) : Giriş görüntü partisi.

return_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Düz bir tuple yerine `ConsistencyDecoderVAEOutput` döndürülecek mi?

**Dönüş:** `ConsistencyDecoderVAEOutput` veya `tuple`

return_dict True ise `ConsistencyDecoderVAEOutput` döndürülür, aksi takdirde düz bir `tuple` döndürülür.

Bir görüntü grubunu, karolalı bir kodlayıcı kullanarak kodlayın.

Bu seçenek etkinleştirildiğinde, VAE, kodlamayı birden fazla adımda hesaplamak için girdi tensörünü karolara böler. Bu, bellek kullanımının görüntü boyutundan bağımsız olarak sabit kalmasını sağlamak için faydalıdır. Karolarla kodlamanın nihai sonucu, her karonun farklı bir kodlayıcı (encoder) kullanması nedeniyle karolasız kodlamadan farklıdır. Karola artefaktlarını önlemek için karolar üst üste biner ve pürüzsüz bir çıktı oluşturmak üzere birleştirilir. Çıktıda hâlâ karola boyutunda değişimler görebilirsiniz, ancak bunlar çok daha az belirgin olmalıdır.