Mochi 1 Pratinjau

Saat ini, hanya pratinjau riset dari bobot model yang tersedia.

Mochi 1 adalah model generasi video dari Genmo dengan fokus kuat pada kepatuhan terhadap prompt dan kualitas gerakan. Model ini memiliki arsitektur Asmmetric Diffusion Transformer (AsymmDiT) dengan 10B parameter, dan menggunakan lapisan proyeksi QKV serta output yang tidak persegi untuk mengurangi kebutuhan memori saat inferensi. Satu model T5-XXL digunakan untuk mengkodekan prompt.

Mochi 1 preview adalah model generasi video open state-of-the-art dengan gerakan berkeandalan tinggi dan kepatuhan prompt yang kuat dalam evaluasi awal. Model ini secara drastis menyempitkan kesenjangan antara sistem generasi video tertutup dan terbuka. Model ini dirilis di bawah lisensi Apache 2.0 yang permisif.

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.

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 MochiPipeline terkuantisasi untuk inferensi dengan bitsandbytes.

import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, MochiTransformer3DModel, MochiPipeline
from diffusers.utils import export_to_video
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel

quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = T5EncoderModel.from_pretrained(
    "genmo/mochi-1-preview",
    subfolder="text_encoder",
    quantization_config=quant_config,
    dtype=torch.float16,
)

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = MochiTransformer3DModel.from_pretrained(
    "genmo/mochi-1-preview",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.float16,
)

pipeline = MochiPipeline.from_pretrained(
    "genmo/mochi-1-preview",
    text_encoder=text_encoder_8bit,
    transformer=transformer_8bit,
    dtype=torch.float16,
    device_map="balanced",
)

video = pipeline(
  "Close-up of a cats eye, with the galaxy reflected in the cats eye. Ultra high resolution 4k.",
  num_inference_steps=28,
  guidance_scale=3.5
).frames[0]
export_to_video(video, "cat.mp4")

Membuat video dengan Mochi-1 Preview

Contoh berikut akan mengunduh bobot mochi-1-preview presisi penuh dan menghasilkan hasil dengan kualitas tertinggi, tetapi membutuhkan setidaknya 42GB VRAM untuk dijalankan.

import torch
from diffusers import MochiPipeline
from diffusers.utils import export_to_video

pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview")

# Enable memory savings
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

prompt = "Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k."

with torch.autocast("cuda", torch.bfloat16, cache_enabled=False):
      frames = pipe(prompt, num_frames=85).frames[0]

export_to_video(frames, "mochi.mp4", fps=30)

Menggunakan varian presisi yang lebih rendah untuk menghemat memori

Contoh berikut akan menggunakan varian bfloat16 dari model dan membutuhkan 22GB VRAM untuk dijalankan. Akibatnya, terdapat sedikit penurunan kualitas video yang dihasilkan.

import torch
from diffusers import MochiPipeline
from diffusers.utils import export_to_video

pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview", variant="bf16", dtype=torch.bfloat16)

# Enable memory savings
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

prompt = "Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k."
frames = pipe(prompt, num_frames=85).frames[0]

export_to_video(frames, "mochi.mp4", fps=30)

Mereproduksi hasil dari repo Genmo Mochi

Implementasi Genmo Mochi menggunakan nilai presisi yang berbeda untuk setiap tahap dalam proses inferensi. Text encoder dan VAE menggunakan torch.float32, sedangkan DiT menggunakan torch.bfloat16 dengan attention kernel yang diatur ke EFFICIENT_ATTENTION. Pipeline Diffusers saat ini tidak mendukung pengaturan dtypes yang berbeda untuk tahap pipeline yang berbeda. Untuk menjalankan inferensi dengan cara yang sama seperti implementasi asli, silakan merujuk pada contoh berikut.

Implementasi Mochi asli menolkan prompt kosong. Namun, mengaktifkan opsi ini dan menempatkan seluruh pipeline di bawah autocast dapat menyebabkan overflow numerik pada text encoder T5.

Saat mengaktifkan force_zeros_for_empty_prompt, disarankan untuk menjalankan langkah pengkodean teks di luar konteks autocast dalam presisi penuh.

Mendekodekan latens dalam presisi penuh sangat intensif terhadap memori. Anda membutuhkan setidaknya 70GB VRAM untuk menghasilkan 163 frame dalam contoh ini. Untuk mengurangi memori, kurangi jumlah frame atau jalankan langkah dekoding dalam torch.bfloat16.

import torch
from torch.nn.attention import SDPBackend, sdpa_kernel

from diffusers import MochiPipeline
from diffusers.utils import export_to_video
from diffusers.video_processor import VideoProcessor

pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview", force_zeros_for_empty_prompt=True)
pipe.vae.enable_tiling()
pipe.enable_model_cpu_offload()

prompt =  "An aerial shot of a parade of elephants walking across the African savannah. The camera showcases the herd and the surrounding landscape."

with torch.no_grad():
    prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask = (
        pipe.encode_prompt(prompt=prompt)
    )

with torch.autocast("cuda", torch.bfloat16):
    with sdpa_kernel(SDPBackend.EFFICIENT_ATTENTION):
        frames = pipe(
            prompt_embeds=prompt_embeds,
            prompt_attention_mask=prompt_attention_mask,
            negative_prompt_embeds=negative_prompt_embeds,
            negative_prompt_attention_mask=negative_prompt_attention_mask,
            guidance_scale=4.5,
            num_inference_steps=64,
            height=480,
            width=848,
            num_frames=163,
            generator=torch.Generator("cuda").manual_seed(0),
            output_type="latent",
            return_dict=False,
        )[0]

video_processor = VideoProcessor(vae_scale_factor=8)
has_latents_mean = hasattr(pipe.vae.config, "latents_mean") and pipe.vae.config.latents_mean is not None
has_latents_std = hasattr(pipe.vae.config, "latents_std") and pipe.vae.config.latents_std is not None
if has_latents_mean and has_latents_std:
    latents_mean = (
        torch.tensor(pipe.vae.config.latents_mean).view(1, 12, 1, 1, 1).to(frames.device, frames.dtype)
    )
    latents_std = (
        torch.tensor(pipe.vae.config.latents_std).view(1, 12, 1, 1, 1).to(frames.device, frames.dtype)
    )
    frames = frames * latents_std / pipe.vae.config.scaling_factor + latents_mean
else:
    frames = frames / pipe.vae.config.scaling_factor

with torch.no_grad():
    video = pipe.vae.decode(frames.to(pipe.vae.dtype), return_dict=False)[0]

video = video_processor.postprocess_video(video)[0]
export_to_video(video, "mochi.mp4", fps=30)

Menjalankan inferensi dengan beberapa GPU

Memungkinkan untuk membagi transformer Mochi yang besar ke beberapa GPU menggunakan opsi device_map dan max_memory di from_pretrained. Pada contoh berikut, model dibagi ke dua GPU, masing-masing dengan VRAM 24GB.

import torch
from diffusers import MochiPipeline, MochiTransformer3DModel
from diffusers.utils import export_to_video

model_id = "genmo/mochi-1-preview"
transformer = MochiTransformer3DModel.from_pretrained(
    model_id,
    subfolder="transformer",
    device_map="auto",
    max_memory={0: "24GB", 1: "24GB"}
)

pipe = MochiPipeline.from_pretrained(model_id,  transformer=transformer)
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

with torch.autocast(device_type="cuda", dtype=torch.bfloat16, cache_enabled=False):
    frames = pipe(
        prompt="Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k.",
        negative_prompt="",
        height=480,
        width=848,
        num_frames=85,
        num_inference_steps=50,
        guidance_scale=4.5,
        num_videos_per_prompt=1,
        generator=torch.Generator(device="cuda").manual_seed(0),  # or "mps", "xpu", "cpu"
        max_sequence_length=256,
        output_type="pil",
    ).frames[0]

export_to_video(frames, "output.mp4", fps=30)

Menggunakan pemuatan file tunggal dengan Mochi Transformer

Anda dapat menggunakan from_single_file untuk memuat transformer Mochi dalam format aslinya.

Diffusers saat ini tidak mendukung penggunaan versi FP8 berskala dari checkpoint file tunggal Mochi.

import torch
from diffusers import MochiPipeline, MochiTransformer3DModel
from diffusers.utils import export_to_video

model_id = "genmo/mochi-1-preview"

ckpt_path = "https://huggingface.co/Comfy-Org/mochi_preview_repackaged/blob/main/split_files/diffusion_models/mochi_preview_bf16.safetensors"

transformer = MochiTransformer3DModel.from_pretrained(ckpt_path, dtype=torch.bfloat16)

pipe = MochiPipeline.from_pretrained(model_id,  transformer=transformer)
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

with torch.autocast(device_type="cuda", dtype=torch.bfloat16, cache_enabled=False):
    frames = pipe(
        prompt="Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k.",
        negative_prompt="",
        height=480,
        width=848,
        num_frames=85,
        num_inference_steps=50,
        guidance_scale=4.5,
        num_videos_per_prompt=1,
        generator=torch.Generator(device="cuda").manual_seed(0),  # or "mps", "xpu", "cpu"
        max_sequence_length=256,
        output_type="pil",
    ).frames[0]

export_to_video(frames, "output.mp4", fps=30)

MochiPipeline

kelas diffusers.MochiPipeline

< source >

( scheduler: FlowMatchEulerDiscreteSchedulervae: AutoencoderKLMochitext_encoder: T5EncoderModeltokenizer: T5Tokenizertransformer: MochiTransformer3DModelforce_zeros_for_empty_prompt: bool = False )

Parameter

transformer (MochiTransformer3DModel) — Arsitektur Transformer bersyarat untuk mendenoise latens video yang telah dikodekan.
scheduler (FlowMatchEulerDiscreteScheduler) — Scheduler yang digunakan bersama transformer untuk menghilangkan noise pada latens gambar yang telah dikodekan.
vae (AutoencoderKLMochi) — Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan video ke dan dari representasi laten.
text_encoder (T5EncoderModel) — T5, khususnya varian google/t5-v1_1-xxl.
tokenizer (CLIPTokenizer) — Tokenizer dari kelas CLIPTokenizer.
tokenizer (T5TokenizerFast) — Tokenizer kedua dari kelas T5TokenizerFast.

Pipeline mochi untuk generasi teks-ke-video.

Referensi: https://github.com/genmoai/models

call

< source >

( prompt: str | list[str] = Nonenegative_prompt: str | list[str] | None = Noneheight: int | None = Nonewidth: int | None = Nonenum_frames: int = 19num_inference_steps: int = 64timesteps: list = Noneguidance_scale: float = 4.5num_videos_per_prompt: int | None = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Noneprompt_attention_mask: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_attention_mask: typing.Optional[torch.Tensor] = Noneoutput_type: str | None = 'pil'return_dict: bool = Trueattention_kwargs: dict[str, typing.Any] | None = Nonecallback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = Nonecallback_on_step_end_tensor_inputs: list = ['latents']max_sequence_length: int = 256 ) → ~pipelines.mochi.MochiPipelineOutput or tuple

Parameter

prompt (str atau list[str], opsional) — Prompt atau prompt-prompt untuk mengarahkan generasi gambar. 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 memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan negative_prompt_embeds sebagai gantinya. Diabaikan ketika tidak menggunakan guidance (guidance_scale < 1).
height (int, opsional, defaultnya self.default_height) — Tinggi gambar yang dihasilkan dalam piksel. Ini diatur ke 480 secara default untuk hasil terbaik.
width (int, opsional, defaultnya self.default_width) — Lebar gambar yang dihasilkan dalam piksel. Nilai defaultnya adalah 848 untuk hasil terbaik.
num_frames (int, defaultnya 19) — Jumlah bingkai video yang akan dihasilkan
num_inference_steps (int, opsional, default 50) — Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.
timesteps (list[int], opsional) — Timesteps kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen timesteps di metode set_timesteps mereka. Jika tidak didefinisikan, perilaku default saat num_inference_steps dilewatkan akan digunakan. Harus dalam urutan menurun.
guidance_scale (float, defaults to 4.5) — Guidance scale as defined in Classifier-Free Diffusion Guidance. guidance_scale is defined as w of equation 2. of Imagen Paper. Guidance scale is enabled by setting guidance_scale > 1. Higher guidance scale encourages to generate images that are closely linked to the text prompt, usually at the expense of lower image quality.
num_videos_per_prompt (int, opsional, default 1) — Jumlah video yang akan dihasilkan per prompt.
generator (torch.Generator atau list[torch.Generator], opsional) — Satu atau daftar generator torch untuk membuat proses generasi menjadi deterministik.
latents (torch.Tensor, opsional) — Latents berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. 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.Tensor, opsional) — Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, misalnya pembobotan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input prompt.
prompt_attention_mask (torch.Tensor, opsional) — Mask attention yang telah dibuat sebelumnya untuk embedding teks.
negative_prompt_embeds (torch.FloatTensor, opsional) — Embedding teks negatif yang telah dibuat sebelumnya. Untuk PixArt-Sigma, prompt negatif ini harus berupa "". Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input negative_prompt.
negative_prompt_attention_mask (torch.FloatTensor, opsional) — Attention mask yang telah dibuat sebelumnya untuk embedding teks negatif.
output_type (str, opsional, defaultnya "pil") — Format output dari generate image. Pilih antara PIL: PIL.Image.Image atau np.array.
return_dict (bool, opsional, default True) — Apakah akan mengembalikan ~pipelines.mochi.MochiPipelineOutput alih-alih tuple biasa.
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.
callback_on_step_end (Callable, opsional) — Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi. Fungsi ini dipanggil dengan argumen berikut: callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict). callback_kwargs akan berisi daftar semua tensor sesuai yang ditentukan oleh callback_on_step_end_tensor_inputs.
callback_on_step_end_tensor_inputs (list, opsional) — Daftar input tensor untuk fungsi callback_on_step_end. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen callback_kwargs. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut ._callback_tensor_inputs dari kelas pipeline Anda.
max_sequence_length (int defaultnya 256) — Panjang maksimum urutan yang digunakan dengan prompt.

Mengembalikan

~pipelines.mochi.MochiPipelineOutput atau tuple

Jika return_dict adalah True, maka ~pipelines.mochi.MochiPipelineOutput yang dikembalikan, selain itu sebuah tuple yang dikembalikan di mana elemen pertama adalah daftar berisi gambar yang dihasilkan.

Fungsi yang dipanggil saat memanggil pipeline untuk generasi.

Contoh:

>>> import torch
>>> from diffusers import MochiPipeline
>>> from diffusers.utils import export_to_video

>>> pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload()
>>> pipe.vae.enable_tiling()
>>> prompt = "Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k."
>>> frames = pipe(prompt, num_inference_steps=28, guidance_scale=3.5).frames[0]
>>> export_to_video(frames, "mochi.mp4")

encode_prompt

< source >

( prompt: str | list[str]negative_prompt: str | list[str] | None = Nonedo_classifier_free_guidance: bool = Truenum_videos_per_prompt: int = 1prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Noneprompt_attention_mask: typing.Optional[torch.Tensor] = Nonenegative_prompt_attention_mask: typing.Optional[torch.Tensor] = Nonemax_sequence_length: int = 256device: typing.Optional[torch.device] = Nonedtype: typing.Optional[torch.dtype] = None )

Parameter

prompt (str atau list[str], opsional) — prompt yang akan dienkod
negative_prompt (str atau list[str], opsional) — Prompt atau prompt-prompt yang tidak digunakan untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan negative_prompt_embeds sebagai gantinya. Diabaikan jika tidak menggunakan guidance (yaitu, diabaikan jika guidance_scale kurang dari 1).
do_classifier_free_guidance (bool, opsional, default True) — Apakah akan menggunakan classifier free guidance atau tidak.
num_videos_per_prompt (int, opsional, default 1) — Jumlah video yang harus dihasilkan per prompt. perangkat torch untuk menempatkan embedding yang dihasilkan
prompt_embeds (torch.Tensor, opsional) — Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, misalnya pembobotan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input prompt.
negative_prompt_embeds (torch.Tensor, opsional) — Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, misalnya penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input negative_prompt.
device — (torch.device, opsional): perangkat torch
dtype — (torch.dtype, opsional): torch dtype

Mengkodekan prompt menjadi hidden states dari text encoder.

MochiPipelineOutput

kelas diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput

< source >

( frames: Tensor )

Parameter

frames (torch.Tensor, np.ndarray, atau list[list[PIL.Image.Image]]) — daftar output video - Dapat berupa daftar bersarang dengan panjang batch_size, di mana setiap sub-daftar berisi urutan gambar PIL yang telah didenois dengan panjang num_frames. Dapat juga berupa array NumPy atau tensor Torch dengan bentuk (batch_size, num_frames, channels, height, width).

Kelas output untuk pipeline Mochi.

Update on GitHub

Diffusers

Mochi 1 Pratinjau

Kuantisasi

Membuat video dengan Mochi-1 Preview

Menggunakan varian presisi yang lebih rendah untuk menghemat memori

Mereproduksi hasil dari repo Genmo Mochi

Menjalankan inferensi dengan beberapa GPU

Menggunakan pemuatan file tunggal dengan Mochi Transformer

MochiPipeline

kelas diffusers.MochiPipeline

__call__

encode_prompt

MochiPipelineOutput

kelas diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput

call