# AutoencoderKLCogVideoX

[CogVideoX](https://github.com/THUDM/CogVideo)'de kullanılan KL kaybına sahip 3D varyasyonel otoenkoder (VAE) modeli, Tsinghua Üniversitesi & ZhipuAI tarafından [CogVideoX: Text-to-Video Diffusion Models with An Expert Transformer](https://huggingface.co/papers/2408.06072) makalesinde tanıtılmıştır.

Model, aşağıdaki kod parçasıyla yüklenebilir.

```python
from diffusers import AutoencoderKLCogVideoX

vae = AutoencoderKLCogVideoX.from_pretrained("THUDM/CogVideoX-2b", subfolder="vae", dtype=torch.float16).to("cuda")  # or "mps", "xpu", "cpu"
```

## AutoencoderKLCogVideoX[[diffusers.AutoencoderKLCogVideoX]]

#### diffusers.AutoencoderKLCogVideoX[[diffusers.AutoencoderKLCogVideoX]]

```python
diffusers.AutoencoderKLCogVideoX(in_channels: int = 3, out_channels: int = 3, down_block_types: tuple = ('CogVideoXDownBlock3D', 'CogVideoXDownBlock3D', 'CogVideoXDownBlock3D', 'CogVideoXDownBlock3D'), up_block_types: tuple = ('CogVideoXUpBlock3D', 'CogVideoXUpBlock3D', 'CogVideoXUpBlock3D', 'CogVideoXUpBlock3D'), block_out_channels: tuple = (128, 256, 256, 512), latent_channels: int = 16, layers_per_block: int = 3, act_fn: str = 'silu', norm_eps: float = 1e-06, norm_num_groups: int = 32, temporal_compression_ratio: float = 4, sample_height: int = 480, sample_width: int = 720, scaling_factor: float = 1.15258426, shift_factor: float | None = None, latents_mean: tuple[float] | None = None, latents_std: tuple[float] | None = None, force_upcast: float = True, use_quant_conv: bool = False, use_post_quant_conv: bool = False, invert_scale_latents: bool = False)
```

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

**Parametreler:**

in_channels (int, *isteğe bağlı*, varsayılan 3) : Girdi görüntüsündeki kanal sayısı.

out_channels (int, *isteğe bağlı*, varsayılan 3) : Çıktıdaki kanal sayısı.

down_block_types (`tuple[str]`, *isteğe bağlı*, varsayılan `("DownEncoderBlock2D",)`) : aşağı örneklem bloğu türlerinin tuple'ı.

up_block_types (`tuple[str]`, *isteğe bağlı*, varsayılan `("UpDecoderBlock2D",)`) : örnekleme bloğu türlerinin tuple'ı.

block_out_channels (`tuple[int]`, *isteğe bağlı*, varsayılan `(64,)`) : blok çıktı kanalları tuple'ı.

act_fn (`str`, *isteğe bağlı*, varsayılan `"silu"`) : Kullanılacak aktivasyon fonksiyonu.

sample_size (`int`, *isteğe bağlı*, varsayılan `32`) : Örnek giriş boyutu.

scaling_factor (`float`, *isteğe bağlı*, varsayılan `1.15258426`) : Eğitim setinin ilk partisi kullanılarak hesaplanan, eğitilmiş gizli uzayın bileşen bazlı standart sapması. Bu değer, difüzyon modelinin eğitimi sırasında gizli uzayın birim varyansa ölçeklenmesi için kullanılır. Gizli değişkenler, difüzyon modeline aktarılmadan önce `z = z * scaling_factor` formülüyle ölçeklenir. Kod çözme sırasında ise gizli değişkenler, orijinal ölçeğe şu formülle geri ölçeklenir: `z = 1 / scaling_factor * z`. Daha fazla ayrıntı için [High-Resolution Image Synthesis with Latent Diffusion Models](https://huggingface.co/papers/2112.10752) makalesinin 4.3.2 ve D.1 bölümlerine bakınız.

force_upcast (`bool`, *isteğe bağlı*, varsayılan `True`) : Etkinleştirilirse, SD-XL gibi yüksek görüntü çözünürlüğü boru hatlarında VAE'nin float32'de çalışmasını zorlar. VAE, çok fazla hassasiyet kaybı olmadan daha düşük bir aralığa ince ayarlanabilir / eğitilebilir; bu durumda `force_upcast` `False` olarak ayarlanabilir - bkz: https://huggingface.co/madebyollin/sdxl-vae-fp16-fix

Görselleri latentlere kodlamak ve latent temsilleri görsellere çözmek için KL kaybı kullanan bir VAE modeli. [CogVideoX](https://github.com/THUDM/CogVideo) içinde kullanılır.

Bu model [ModelMixin](/docs/diffusers/main/tr/api/models/overview#diffusers.ModelMixin) sınıfından devralır. Tüm modeller için uygulanan genel yöntemlerini (indirme veya kaydetme gibi) görmek için üst sınıfın belgelendirmesine bakın.

#### decode[[diffusers.AutoencoderKLCogVideoX.decode]]

```python
decode(z: Tensor, return_dict: bool = True)
```

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

**Parametreler:**

z (`torch.Tensor`) : Gizil vektörlerin giriş partisi.

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

**Dönüş:** `~models.vae.DecoderOutput` veya `tuple`

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

Bir görüntü grubunu çözümlen.

#### encode[[diffusers.AutoencoderKLCogVideoX.encode]]

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

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

**Parametreler:**

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

return_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Düz bir tuple yerine `~models.autoencoder_kl.AutoencoderKLOutput` döndürülüp döndürülmediğini belirtir.

**Dönüş:**

Kodlanmış videoların gizil (latent) temsilleri. `return_dict` True ise bir `~models.autoencoder_kl.AutoencoderKLOutput` döndürülür, aksi halde düz bir `tuple` döndürülür.

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

#### enable_tiling[[diffusers.AutoencoderKLCogVideoX.enable_tiling]]

```python
enable_tiling(tile_sample_min_height: int | None = None, tile_sample_min_width: int | None = None, tile_overlap_factor_height: float | None = None, tile_overlap_factor_width: float | None = None)
```

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

**Parametreler:**

tile_sample_min_height (`int`, *isteğe bağlı*) : Bir örneğin yükseklik boyutu boyunca karolalara ayrılabilmesi için gereken minimum yükseklik.

tile_sample_min_width (`int`, *isteğe bağlı*) : Bir örneğin genişlik boyutu boyunca karolalara ayrılabilmesi için gereken minimum genişlik.

tile_overlap_factor_height (`int`, *isteğe bağlı*) : İki ardışık dikey karoyu arasındaki minimum örtüşme miktarı. Bu, yükseklik boyutu boyunca karo artefaktlarının oluşmamasını sağlamak içindir. 0 ile 1 arasında olmalıdır. Daha yüksek bir değer ayarlamak, daha fazla karonun işlenmesine neden olarak çözümleme sürecini yavaşlatabilir.

tile_overlap_factor_width (`int`, *isteğe bağlı*) : İki ardışık yatay karoyu arasındaki minimum örtüşme miktarı. Bu, genişlik boyutu boyunca karo artefaktlarının oluşmamasını sağlamak içindir. 0 ile 1 arasında olmalıdır. Daha yüksek bir değer ayarlamak, daha fazla karonun işlenmesine neden olarak çözümleme sürecini yavaşlatabilir.

Döşemeli VAE çözümlemesini etkinleştirir. Bu seçenek etkinleştirildiğinde, VAE girdi tensörünü çözümleme ve kodlamayı birden fazla adımda hesaplamak üzere döşemelere böler. Bu, büyük miktarda bellek tasarrufu sağlamak ve daha büyük görüntülerin işlenmesine izin vermek için kullanışlıdır.

#### forward[[diffusers.AutoencoderKLCogVideoX.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/autoencoder_kl_cogvideox.py#L1405)

**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ı*) : Örnekleme işlemini deterministik hale getirmek için kullanılan bir [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html).

**Dönüş:** `~models.vae.DecoderOutput` veya `tuple`

`return_dict` True ise, `~models.vae.DecoderOutput` döndürülür; aksi halde düz bir `tuple` döndürülür.

#### tiled_decode[[diffusers.AutoencoderKLCogVideoX.tiled_decode]]

```python
tiled_decode(z: Tensor, return_dict: bool = True)
```

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

**Parametreler:**

z (`torch.Tensor`) : Gizil vektörlerin giriş partisi.

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

**Dönüş:** `~models.vae.DecoderOutput` veya `tuple`

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

Bir görüntü grubunu karolarlı bir çözücü kullanarak çözümlen.

#### tiled_encode[[diffusers.AutoencoderKLCogVideoX.tiled_encode]]

```python
tiled_encode(x: Tensor)
```

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

**Parametreler:**

x (`torch.Tensor`) : Girdi video partisi.

**Dönüş:** `torch.Tensor`

Kodlanmış videoların gizil (latent) temsili.

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.

## AutoencoderKLOutput[[diffusers.models.modeling_outputs.AutoencoderKLOutput]]

#### diffusers.models.modeling_outputs.AutoencoderKLOutput[[diffusers.models.modeling_outputs.AutoencoderKLOutput]]

```python
diffusers.models.modeling_outputs.AutoencoderKLOutput(latent_dist: DiagonalGaussianDistribution)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_outputs.py#L7)

**Parametreler:**

latent_dist (`DiagonalGaussianDistribution`) : `Encoder`'ın `DiagonalGaussianDistribution` ortalama ve logvar olarak temsil edilen kodlanmış çıktıları. `DiagonalGaussianDistribution`, dağılımdan latent örneklemeye olanak tanır.

AutoencoderKL kodlama yönteminin çıktısı.

## DecoderOutput[[diffusers.models.autoencoders.vae.DecoderOutput]]

#### diffusers.models.autoencoders.vae.DecoderOutput[[diffusers.models.autoencoders.vae.DecoderOutput]]

```python
diffusers.models.autoencoders.vae.DecoderOutput(sample: Tensor, commit_loss: typing.Optional[torch.FloatTensor] = None)
```

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

**Parametreler:**

sample (`torch.Tensor`, şekli `(batch_size, num_channels, height, width)`) : Modelin son katmanından çözümlenmiş çıktı örneği.

Çözümleme yönteminin çıktısı.