Hugging Face's logo

Diffusers documentation

Latte

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Latte

latte text-to-video

Latte: Latent Diffusion Transformer for Video Generation 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, SkyTimelapse, UCF101, dan Taichi-HD. Untuk menyiapkan dan mengunduh dataset untuk evaluasi, silakan merujuk ke https URL ini.

Pipeline ini disumbangkan oleh maxin-cn. Basis kode aslinya dapat ditemukan di sini. Bobot aslinya dapat ditemukan di bawah hf.co/maxin-cn.

Pastikan untuk melihat panduan Schedulers untuk mempelajari cara mengeksplorasi tradeoff antara kecepatan dan kualitas scheduler, serta lihat bagian reuse components across pipelines untuk mempelajari cara memuat komponen yang sama secara efisien ke dalam beberapa pipeline.

Inferensi

Gunakan torch.compile untuk mengurangi latensi inferensi.

Pertama, muat pipeline:

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:

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

Terakhir, kompilasi komponen dan jalankan inferensi:

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 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 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 yang dikuantisasi untuk inferensi dengan bitsandbytes.

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

kelas diffusers.LattePipeline

< >

( tokenizer: T5Tokenizertext_encoder: T5EncoderModelvae: AutoencoderKLtransformer: LatteTransformer3DModelscheduler: KarrasDiffusionSchedulers )

Parameter

  • vae (AutoencoderKL) — Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan video ke dan dari representasi laten.
  • text_encoder (T5EncoderModel) — Text-encoder yang dibekukan. Latte menggunakan T5, khususnya varian t5-v1_1-xxl.
  • tokenizer (T5Tokenizer) — Tokenizer dari kelas T5Tokenizer.
  • transformer (LatteTransformer3DModel) — LatteTransformer3DModel yang dikondisikan teks untuk mendenoise latens video yang telah dikodekan.
  • scheduler (SchedulerMixin) — Scheduler yang digunakan bersama transformer untuk menghilangkan noise pada latens video yang telah dienkod.

Pipeline untuk generasi teks-ke-video menggunakan Latte.

Model ini mewarisi dari 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__

< >

( prompt: str | list[str] = Nonenegative_prompt: str = ''num_inference_steps: int = 50timesteps: list[int] | None = Noneguidance_scale: float = 7.5num_images_per_prompt: int = 1video_length: int = 16height: int = 512width: int = 512eta: float = 0.0generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.FloatTensor] = Noneprompt_embeds: typing.Optional[torch.FloatTensor] = Nonenegative_prompt_embeds: typing.Optional[torch.FloatTensor] = Noneoutput_type: str = 'pil'return_dict: bool = Truecallback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = Nonecallback_on_step_end_tensor_inputs: list[str] = ['latents']clean_caption: bool = Truemask_feature: bool = Trueenable_temporal_attentions: bool = Truedecode_chunk_size: int = 14 ) → LattePipelineOutput or tuple

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 digunakan untuk mengarahkan generasi video. Jika tidak didefinisikan, Anda harus meneruskan negative_prompt_embeds sebagai gantinya. Diabaikan jika 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, num_inference_steps timesteps dengan jarak yang sama akan digunakan. Harus dalam urutan menurun.
  • guidance_scale (float, opsional, default 7.0) — Skala panduan seperti yang didefinisikan dalam Classifier-Free Diffusion Guidance. guidance_scale didefinisikan sebagai w dari persamaan 2. dari Imagen Paper. 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, akan diabaikan untuk yang lain.
  • generator (torch.Generator atau list[torch.Generator], opsional) — Satu atau daftar generator torch untuk membuat proses generasi menjadi deterministik.
  • latents (torch.FloatTensor, opsional) — Latents 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 latents 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 pemberatan 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: PIL.Image.Image atau np.array.
  • return_dict (bool, opsional, default 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, default True) — Apakah caption akan dibersihkan sebelum membuat embeddings. Memerlukan beautifulsoup4 dan ftfy untuk diinstal. Jika dependensi tidak diinstal, embeddings akan dibuat dari prompt mentah.
  • mask_feature (bool defaultnya True) — Jika diset ke True, embedding teks akan dimasker.
  • enable_temporal_attentions (bool, opsional, default True) — Apakah akan mengaktifkan temporal attentions
  • decode_chunk_size (int, opsional) — Jumlah frame yang akan didekode sekaligus. Ukuran chunk yang lebih besar menghasilkan konsistensi temporal yang lebih baik dengan biaya penggunaan memori yang lebih tinggi. 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, sebaliknya sebuah tuple dikembalikan di mana elemen pertama adalah daftar dengan gambar yang dihasilkan

Fungsi yang dipanggil saat memanggil pipeline untuk generasi.

Contoh:

>>> 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

< >

( prompt: str | list[str]do_classifier_free_guidance: bool = Truenegative_prompt: str = ''num_images_per_prompt: int = 1device: typing.Optional[torch.device] = Noneprompt_embeds: typing.Optional[torch.FloatTensor] = Nonenegative_prompt_embeds: typing.Optional[torch.FloatTensor] = Noneclean_caption: bool = Falsemask_feature: bool = Truedtype = None )

Parameter

  • prompt (str atau list[str], opsional) — prompt yang akan dienkod
  • negative_prompt (str atau list[str], opsional) — Prompt yang tidak digunakan untuk mengarahkan generasi video. Jika tidak didefinisikan, Anda harus meneruskan negative_prompt_embeds sebagai gantinya. Diabaikan jika tidak menggunakan guidance (yaitu, diabaikan jika guidance_scale kurang dari 1). Untuk Latte, ini harus berupa "".
  • do_classifier_free_guidance (bool, opsional, default 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 hasil
  • prompt_embeds (torch.FloatTensor, opsional) — Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, misalnya pemberatan 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.

Update on GitHub

←Kandinsky S2V 1.0 LTX-2→