#
# Berlisensi di bawah Apache License, Versi 2.0 ("Lisensi");
# Anda mungkin tidak dapat menggunakan file ini kecuali sesuai dengan Lisensi.
# Anda dapat memperoleh salinan Lisensi di
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Kecuali diwajibkan oleh hukum yang berlaku atau disepakati secara tertulis, perangkat lunak
# distribusikan di bawah Lisensi berdasarkan basis "SEBAGAIMANA ADANYA",
# TANPA JAMINAN ATAU SYARAT DALAM BENTUK APAPUN, baik yang dinyatakan maupun yang tersirat.
# Lihat Lisensi untuk bahasa tertentu yang mengatur izin dan
# batasan di bawah Lisensi. -->

# Latte

![latte text-to-video](https://github.com/Vchitect/Latte/blob/52bc0029899babbd6e9250384c83d8ed2670ff7a/visuals/latte.gif?raw=true)

[Latte: Latent Diffusion Transformer for Video Generation](https://huggingface.co/papers/2401.03048) dari Monash University, Shanghai AI Lab, Nanjing University, dan Nanyang Technological University.

Abstrak dari makalah tersebut adalah:

*Kami mengusulkan Latent Diffusion Transformer baru, yaitu Latte, untuk generasi video. Latte pertama-tama mengekstrak token spasio-temporal dari video input, kemudian mengadopsi serangkaian blok Transformer untuk memodelkan distribusi video di ruang laten. Untuk memodelkan sejumlah besar token yang diekstrak dari video, empat varian efisien diperkenalkan dari perspektif dekomposisi dimensi spasial dan temporal dari video input. Untuk meningkatkan kualitas video yang dihasilkan, kami menentukan praktik terbaik Latte melalui analisis eksperimental yang ketat, termasuk patch embedding klip video, varian model, injeksi informasi timestep-kelas, embedding posisi temporal, dan strategi pembelajaran. Evaluasi komprehensif kami menunjukkan bahwa Latte mencapai kinerja state-of-the-art di empat dataset generasi video standar, yaitu FaceForensics, SkyTimelapse, UCF101, dan Taichi-HD. Selain itu, kami memperluas Latte ke tugas generasi video dari teks (T2V), di mana Latte mencapai hasil yang sebanding dibandingkan dengan model T2V terbaru. Kami sangat yakin bahwa Latte memberikan wawasan berharga untuk penelitian masa depan tentang penggabungan Transformer ke dalam model difusi untuk generasi video.*

**Highlight**: Latte adalah latent diffusion transformer yang diusulkan sebagai backbone untuk pemodelan berbagai modalitas (di sini dilatih untuk generasi teks-ke-video). Model ini mencapai kinerja state-of-the-art di empat benchmark video standar - [FaceForensics](https://huggingface.co/papers/1803.09179), [SkyTimelapse](https://huggingface.co/papers/1709.07592), [UCF101](https://huggingface.co/papers/1212.0402), dan [Taichi-HD](https://huggingface.co/papers/2003.00196). Untuk menyiapkan dan mengunduh dataset untuk evaluasi, silakan merujuk ke [https URL ini](https://github.com/Vchitect/Latte/blob/main/docs/datasets_evaluation.md).

Pipeline ini disumbangkan oleh [maxin-cn](https://github.com/maxin-cn). Basis kode aslinya dapat ditemukan [di sini](https://github.com/Vchitect/Latte). Bobot aslinya dapat ditemukan di bawah [hf.co/maxin-cn](https://huggingface.co/maxin-cn).

> [!TIP]
> Pastikan untuk melihat [panduan](../../using-diffusers/schedulers) Schedulers untuk mempelajari cara mengeksplorasi tradeoff antara kecepatan dan kualitas scheduler, serta lihat bagian [reuse components across pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) untuk mempelajari cara memuat komponen yang sama secara efisien ke dalam beberapa pipeline.

### Inferensi

Gunakan [`torch.compile`](https://huggingface.co/docs/diffusers/main/en/tutorials/fast_diffusion#torchcompile) untuk mengurangi latensi inferensi.

Pertama, muat pipeline:

```python
import torch
from diffusers import LattePipeline

pipeline = LattePipeline.from_pretrained(
	"maxin-cn/Latte-1", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
```

Lalu ubah tata letak memori komponen `transformer` dan `vae` menjadi `torch.channels-last`:

```python
pipeline.transformer.to(memory_format=torch.channels_last)
pipeline.vae.to(memory_format=torch.channels_last)
```

Terakhir, kompilasi komponen dan jalankan inferensi:

```python
pipeline.transformer = torch.compile(pipeline.transformer)
pipeline.vae.decode = torch.compile(pipeline.vae.decode)

video = pipeline(prompt="A dog wearing sunglasses floating in space, surreal, nebulae in background").frames[0]
```

Hasil [benchmark](https://gist.github.com/a-r-r-o-w/4e1694ca46374793c0361d740a99ff19) pada mesin A100 80GB adalah:

```
Without torch.compile(): Average inference time: 16.246 seconds.
With torch.compile(): Average inference time: 14.573 seconds.
```

## Kuantisasi

Quantization membantu mengurangi kebutuhan memori untuk model yang sangat besar dengan menyimpan bobot model dalam tipe data presisi yang lebih rendah. Namun, quantization dapat memiliki dampak yang bervariasi terhadap kualitas video tergantung pada model video yang digunakan.

Lihat ringkasan [Kuantisasi](../../quantization/overview) untuk mempelajari lebih lanjut tentang backend kuantisasi yang didukung dan memilih backend kuantisasi yang mendukung kasus penggunaan Anda. Contoh di bawah ini menunjukkan cara memuat [LattePipeline](/docs/diffusers/v0.43.0/id/api/pipelines/latte#diffusers.LattePipeline) yang dikuantisasi untuk inferensi dengan bitsandbytes.

```py
import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, LatteTransformer3DModel, LattePipeline
from diffusers.utils import export_to_gif
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel

quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = T5EncoderModel.from_pretrained(
    "maxin-cn/Latte-1",
    subfolder="text_encoder",
    quantization_config=quant_config,
    dtype=torch.float16,
)

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = LatteTransformer3DModel.from_pretrained(
    "maxin-cn/Latte-1",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.float16,
)

pipeline = LattePipeline.from_pretrained(
    "maxin-cn/Latte-1",
    text_encoder=text_encoder_8bit,
    transformer=transformer_8bit,
    dtype=torch.float16,
    device_map="balanced",
)

prompt = "A small cactus with a happy face in the Sahara desert."
video = pipeline(prompt).frames[0]
export_to_gif(video, "latte.gif")
```

## LattePipeline[[diffusers.LattePipeline]]

#### diffusers.LattePipeline[[diffusers.LattePipeline]]

```python
diffusers.LattePipeline(tokenizer: T5Tokenizer, text_encoder: T5EncoderModel, vae: AutoencoderKL, transformer: LatteTransformer3DModel, scheduler: KarrasDiffusionSchedulers)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latte/pipeline_latte.py#L145)

**Parameter:**

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan video ke dan dari representasi laten.

text_encoder (`T5EncoderModel`) : Teks-encoder yang dibekukan. Latte menggunakan [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), khususnya varian [t5-v1_1-xxl](https://huggingface.co/PixArt-alpha/PixArt-alpha/tree/main/t5-v1_1-xxl).

tokenizer (`T5Tokenizer`) : Tokenizer dari kelas [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer).

transformer ([LatteTransformer3DModel](/docs/diffusers/v0.43.0/id/api/models/latte_transformer3d#diffusers.LatteTransformer3DModel)) : `LatteTransformer3DModel` yang dikondisikan teks untuk mendenois latens video yang telah dikodekan.

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/id/api/schedulers/overview#diffusers.SchedulerMixin)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise dari latens video yang telah dikodekan.

Pipeline untuk generasi teks-ke-video menggunakan Latte.

Model ini mewarisi dari [DiffusionPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/overview#diffusers.DiffusionPipeline). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua pipeline (seperti mengunduh atau menyimpan, menjalankan pada perangkat tertentu, dll.)

#### __call__[[diffusers.LattePipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str = '', num_inference_steps: int = 50, timesteps: list[int] | None = None, guidance_scale: float = 7.5, num_images_per_prompt: int = 1, video_length: int = 16, height: int = 512, width: int = 512, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str = 'pil', return_dict: bool = True, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], clean_caption: bool = True, mask_feature: bool = True, enable_temporal_attentions: bool = True, decode_chunk_size: int = 14)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latte/pipeline_latte.py#L613)

**Parameter:**

prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi video. Jika tidak didefinisikan, Anda harus meneruskan `prompt_embeds` sebagai gantinya.

negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi video. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `guidance_scale` kurang dari `1`).

num_inference_steps (`int`, *opsional*, default 100) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan video dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.

timesteps (`list[int]`, *opsional*) : Timesteps kustom untuk digunakan dalam proses denoising. Jika tidak didefinisikan, timesteps `num_inference_steps` yang berjarak sama akan digunakan. Harus dalam urutan menurun.

guidance_scale (`float`, *opsional*, default 7.0) : Skala panduan seperti yang didefinisikan dalam [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` didefinisikan sebagai `w` dari persamaan 2. pada [Imagen Paper](https://huggingface.co/papers/2205.11487). Skala panduan diaktifkan dengan mengatur `guidance_scale > 1`. Skala panduan yang lebih tinggi mendorong generasi video yang sangat terkait dengan `prompt` teks, biasanya dengan mengorbankan kualitas video yang lebih rendah.

video_length (`int`, *opsional*, default 16) : Jumlah bingkai video yang dihasilkan. Defaultnya adalah 16 bingkai yang pada 8 bingkai per detik

num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah video yang akan dihasilkan per prompt.

height (`int`, *opsional*, defaultnya self.unet.config.sample_size) : Tinggi video yang dihasilkan dalam piksel.

width (`int`, *opsional*, defaultnya self.unet.config.sample_size) : Lebar video yang dihasilkan dalam piksel.

eta (`float`, *opsional*, default 0.0) : Bersesuaian dengan parameter eta (η) dalam paper DDIM: https://huggingface.co/papers/2010.02502. Hanya berlaku untuk [schedulers.DDIMScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/ddim#diffusers.DDIMScheduler), akan diabaikan untuk yang lain.

generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Satu atau daftar [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik.

latents (`torch.FloatTensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi video. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan.

prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.

negative_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Untuk Latte, prompt negatif ini harus berupa "". Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`.

output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari generate video. Pilih antara [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` atau `np.array`.

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.stable_diffusion.IFPipelineOutput` alih-alih tuple biasa.

callback_on_step_end (`Callable[[int, int], None]`, `PipelineCallback`, `MultiPipelineCallbacks`, *opsional*) : Fungsi callback atau daftar fungsi callback yang akan dipanggil di akhir setiap langkah denoising.

callback_on_step_end_tensor_inputs (`list[str]`, *opsional*) : Daftar input tensor yang harus diteruskan ke fungsi callback. Jika tidak didefinisikan, semua input tensor akan diteruskan.

clean_caption (`bool`, *opsional*, defaultnya `True`) : Apakah caption akan dibersihkan sebelum membuat embeddings. Memerlukan `beautifulsoup4` dan `ftfy` terpasang. Jika dependensi tidak terpasang, embeddings akan dibuat dari prompt mentah.

mask_feature (`bool` defaultnya `True`) : Jika diatur ke `True`, embedding teks akan dimasker.

enable_temporal_attentions (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengaktifkan temporal attentions

decode_chunk_size (`int`, *opsional*) : Jumlah frame yang akan didekode sekaligus. Ukuran chunk yang lebih tinggi menghasilkan konsistensi temporal yang lebih baik dengan mengorbankan penggunaan memori yang lebih besar. Secara default, decoder akan mendeodekan semua frame sekaligus untuk kualitas maksimal. Untuk penggunaan memori yang lebih rendah, kurangi `decode_chunk_size`.

**Mengembalikan:** `LattePipelineOutput` atau `tuple`

Jika `return_dict` adalah `True`, `LattePipelineOutput` dikembalikan, selain itu sebuah `tuple` dikembalikan di mana elemen pertama adalah daftar dengan gambar yang dihasilkan

Fungsi yang dipanggil saat memanggil pipeline untuk generasi.

Contoh:
```py
>>> import torch
>>> from diffusers import LattePipeline
>>> from diffusers.utils import export_to_gif

>>> # You can replace the checkpoint id with "maxin-cn/Latte-1" too.
>>> pipe = LattePipeline.from_pretrained("maxin-cn/Latte-1", torch_dtype=torch.float16)
>>> # Enable memory optimizations.
>>> pipe.enable_model_cpu_offload()

>>> prompt = "A small cactus with a happy face in the Sahara desert."
>>> videos = pipe(prompt).frames[0]
>>> export_to_gif(videos, "latte.gif")
```

#### encode_prompt[[diffusers.LattePipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, negative_prompt: str = '', num_images_per_prompt: int = 1, device: typing.Optional[torch.device] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, clean_caption: bool = False, mask_feature: bool = True, dtype = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latte/pipeline_latte.py#L206)

**Parameter:**

prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod

negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt yang tidak akan memandu generasi video. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan panduan (yaitu, diabaikan jika `guidance_scale` kurang dari `1`). Untuk Latte, ini harus berupa "".

do_classifier_free_guidance (`bool`, *opsional*, defaultnya `True`) : apakah akan menggunakan classifier free guidance atau tidak

num_images_per_prompt (`int`, *opsional*, default 1) : jumlah video yang harus dihasilkan per prompt

device : (`torch.device`, *opsional*): perangkat torch untuk menempatkan embedding yang dihasilkan

prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.

negative_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Untuk Latte, ini seharusnya berupa embedding dari string "".

clean_caption (bool, defaultnya `False`) : Jika `True`, fungsi akan memproses pra dan membersihkan caption yang diberikan sebelum encoding.

mask_feature : (bool, defaultnya `True`): Jika `True`, fungsi akan mem-mask embedding teks.

Mengkodekan prompt menjadi hidden states dari text encoder.