# CogVideoXTransformer3DModel

Model Diffusion Transformer untuk data 3D dari [CogVideoX](https://github.com/THUDM/CogVideo) diperkenalkan dalam [CogVideoX: Text-to-Video Diffusion Models with An Expert Transformer](https://huggingface.co/papers/2408.06072) oleh Tsinghua University & ZhipuAI.

Model dapat dimuat dengan potongan kode berikut.

```python
from diffusers import CogVideoXTransformer3DModel

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

## CogVideoXTransformer3DModel[[diffusers.CogVideoXTransformer3DModel]]

#### diffusers.CogVideoXTransformer3DModel[[diffusers.CogVideoXTransformer3DModel]]

```python
diffusers.CogVideoXTransformer3DModel(num_attention_heads: int = 30, attention_head_dim: int = 64, in_channels: int = 16, out_channels: int | None = 16, flip_sin_to_cos: bool = True, freq_shift: int = 0, time_embed_dim: int = 512, ofs_embed_dim: int | None = None, text_embed_dim: int = 4096, num_layers: int = 30, dropout: float = 0.0, attention_bias: bool = True, sample_width: int = 90, sample_height: int = 60, sample_frames: int = 49, patch_size: int = 2, patch_size_t: int | None = None, temporal_compression_ratio: int = 4, max_text_seq_length: int = 226, activation_fn: str = 'gelu-approximate', timestep_activation_fn: str = 'silu', norm_elementwise_affine: bool = True, norm_eps: float = 1e-05, spatial_interpolation_scale: float = 1.875, temporal_interpolation_scale: float = 1.0, use_rotary_positional_embeddings: bool = False, use_learned_positional_embeddings: bool = False, patch_bias: bool = True)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/cogvideox_transformer_3d.py#L160)

**Parameter:**

num_attention_heads (`int`, defaultnya `30`) : Jumlah head yang digunakan untuk multi-head attention.

attention_head_dim (`int`, defaultnya `64`) : Jumlah channel di setiap head.

in_channels (`int`, defaultnya `16`) : Jumlah channel pada input.

out_channels (`int`, *opsional*, defaultnya `16`) : Jumlah channel pada output.

flip_sin_to_cos (`bool`, defaultnya `True`) : Apakah akan membalik sin menjadi cos dalam time embedding.

time_embed_dim (`int`, defaultnya `512`) : Dimensi output dari embedding timestep.

ofs_embed_dim (`int`, defaultnya `512`) : Dimensi output dari embedding "ofs" yang digunakan dalam CogVideoX-5b-I2B versi 1.5

text_embed_dim (`int`, defaultnya `4096`) : Dimensi input dari embedding teks yang berasal dari text encoder.

num_layers (`int`, defaultnya `30`) : Jumlah lapisan blok Transformer yang akan digunakan.

dropout (`float`, defaultnya `0.0`) : Probabilitas dropout yang digunakan.

attention_bias (`bool`, defaultnya `True`) : Apakah akan menggunakan bias pada lapisan proyeksi perhatian.

sample_width (`int`, defaultnya `90`) : Lebar dari latens input.

sample_height (`int`, defaultnya `60`) : Tinggi dari latens input.

sample_frames (`int`, defaultnya `49`) : Jumlah frame pada latens input. Perhatikan bahwa parameter ini diinisialisasi secara keliru ke 49 alih-alih 13 karena CogVideoX memproses 13 frame latens sekaligus pada pengaturan default dan yang direkomendasikannya, namun tidak dapat diubah ke nilai yang benar untuk memastikan kompatibilitas mundur. Untuk membuat transformer dengan K frame latens, nilai yang benar untuk dilewatkan di sini adalah: ((K - 1) * temporal_compression_ratio + 1).

patch_size (`int`, defaultnya `2`) : Ukuran patch yang akan digunakan di lapisan patch embedding.

temporal_compression_ratio (`int`, defaultnya `4`) : Rasio kompresi di sepanjang dimensi temporal. Lihat dokumentasi untuk `sample_frames`.

max_text_seq_length (`int`, defaultnya `226`) : Panjang maksimum urutan dari embedding teks input.

activation_fn (`str`, defaultnya `"gelu-approximate"`) : Fungsi aktivasi yang digunakan dalam feed-forward.

timestep_activation_fn (`str`, defaultnya `"silu"`) : Fungsi aktivasi yang digunakan saat menghasilkan embedding timestep.

norm_elementwise_affine (`bool`, defaultnya `True`) : Apakah akan menggunakan elementwise affine di lapisan normalisasi.

norm_eps (`float`, defaultnya `1e-5`) : Nilai epsilon yang digunakan dalam lapisan normalisasi.

spatial_interpolation_scale (`float`, defaultnya `1.875`) : Faktor skala yang diterapkan pada embedding posisional 3D di sepanjang dimensi spasial.

temporal_interpolation_scale (`float`, defaultnya `1.0`) : Faktor penskalaan yang diterapkan pada embedding posisi 3D di sepanjang dimensi temporal.

Model Transformer untuk data seperti video di [CogVideoX](https://github.com/THUDM/CogVideo).

#### forward[[diffusers.CogVideoXTransformer3DModel.forward]]

```python
forward(hidden_states: Tensor, encoder_hidden_states: Tensor, timestep: typing.Union[int, float, torch.LongTensor], timestep_cond: typing.Optional[torch.Tensor] = None, ofs: typing.Union[int, float, torch.LongTensor, NoneType] = None, image_rotary_emb: tuple[torch.Tensor, torch.Tensor] | None = None, attention_kwargs: dict[str, typing.Any] | None = None, return_dict: bool = True)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/cogvideox_transformer_3d.py#L366)

**Parameter:**

hidden_states (`torch.Tensor` dengan bentuk `(batch_size, num_frames, channels, height, width)`) : `hidden_states` masukan.

encoder_hidden_states (`torch.Tensor` dengan bentuk `(batch_size, sequence_len, embed_dims)`) : Embedding kondisional (embedding yang dihitung dari kondisi input seperti prompt) yang akan digunakan.

timestep (`torch.LongTensor`) : Digunakan untuk menunjukkan langkah denoising.

timestep_cond (`torch.Tensor`, *opsional*) : Embedding kondisional untuk timestep. Jika disediakan, embedding akan dijumlahkan dengan sampel yang melewati lapisan `self.time_embedding` untuk mendapatkan embedding timestep akhir.

ofs (`torch.Tensor`, *opsional*) : Offset embeddings yang digunakan dalam CogVideoX-5b-I2V.

image_rotary_emb (`tuple` dari `torch.Tensor`, *opsional*) : Embedding posisi rotasi yang telah dihitung sebelumnya.

attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~models.transformer_2d.Transformer2DModelOutput` alih-alih tuple biasa.

**Mengembalikan:**

Jika `return_dict` bernilai True, sebuah `~models.transformer_2d.Transformer2DModelOutput` akan dikembalikan, selain itu sebuah `tuple` di mana elemen pertama adalah tensor sampel.

Metode forward dari [CogVideoXTransformer3DModel](/docs/diffusers/v0.43.0/id/api/models/cogvideox_transformer3d#diffusers.CogVideoXTransformer3DModel).

#### fuse_qkv_projections[[diffusers.CogVideoXTransformer3DModel.fuse_qkv_projections]]

```python
fuse_qkv_projections()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/cogvideox_transformer_3d.py#L335)

Mengaktifkan proyeksi QKV yang digabungkan. Untuk modul self-attention, semua matriks proyeksi (yaitu, query, key, value) digabungkan. Untuk modul cross-attention, matriks proyeksi key dan value digabungkan.

> [!WARNING] > API ini 🧪 eksperimental.

#### unfuse_qkv_projections[[diffusers.CogVideoXTransformer3DModel.unfuse_qkv_projections]]

```python
unfuse_qkv_projections()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/cogvideox_transformer_3d.py#L357)

Menonaktifkan proyeksi QKV yang digabungkan jika diaktifkan.

> [!WARNING] > API ini 🧪 eksperimental.

## Transformer2DModelOutput[[diffusers.models.modeling_outputs.Transformer2DModelOutput]]

#### diffusers.models.modeling_outputs.Transformer2DModelOutput[[diffusers.models.modeling_outputs.Transformer2DModelOutput]]

```python
diffusers.models.modeling_outputs.Transformer2DModelOutput(sample: torch.Tensor)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_outputs.py#L21)

**Parameter:**

sample (`torch.Tensor` dengan bentuk `(batch_size, num_channels, height, width)` atau `(batch size, num_vector_embeds - 1, num_latent_pixels)` jika [Transformer2DModel](/docs/diffusers/v0.43.0/id/api/models/transformer2d#diffusers.Transformer2DModel) bersifat diskrit) : Output hidden states yang dikondisikan pada input `encoder_hidden_states`. Jika diskrit, mengembalikan distribusi probabilitas untuk piksel laten yang tidak berisik.

Output dari [Transformer2DModel](/docs/diffusers/v0.43.0/id/api/models/transformer2d#diffusers.Transformer2DModel).