diffusers/main/tr/api/pipelines/mochi.md

Apache Lisansı, 2.0 Sürümü ("Lisans") altında lisanslanmıştır;

bu dosyayı, Lisansa uygun olarak kullanabilirsiniz.

Lisansın bir kopyasını şu adresten edinebilirsiniz

http://www.apache.org/licenses/LICENSE-2.0

Uygulanabilir yasa gerektirmedikçe veya yazılı olarak anlaşılmadıkça, yazılım

Lisans kapsamında dağıtılan, "OLDUĞU GİBİ" esasına göre dağıtılır,

HİÇBİR TÜR AÇIK VEYA ZIMMİ GARANTİ VEYA ŞART İÇERMEZ.

İzinleri ve

Lisans kapsamındaki kısıtlamalar.

-->

Mochi 1 Önizleme

Şu anda yalnızca model ağırlıklarının bir araştırma önizlemesi mevcuttur.

Mochi 1, Genmo tarafından geliştirilen, prompt uyumu ve hareket kalitesine güçlü bir odaklanma sunan bir video üretim modelidir. Model, 10B parametreli Asmmetric Diffusion Transformer (AsymmDiT) mimarisine sahiptir ve çıkarım bellek gereksinimlerini azaltmak için kare olmayan QKV ve çıktı projeksiyon katmanları kullanır. Prompt'ları kodlamak için tek bir T5-XXL modeli kullanılır.

Mochi 1 önizleme, ön değerlendirme sonuçlarına göre yüksek sadakatli hareket ve güçlü istem uyumu sunan, açık kaynaklı ve en ileri düzey video üretim modelidir. Bu model, kapalı ve açık video üretim sistemleri arasındaki farkı büyük ölçüde kapatmaktadır. Model, esnek bir Apache 2.0 lisansı altında yayımlanmıştır.

Scheduler'lar kılavuzunu inceleyerek scheduler hızı ve kalitesi arasındaki ödünleşimi nasıl keşfedebileceğinizi öğrenin ve aynı bileşenleri birden fazla pipeline'a nasıl verimli bir şekilde yükleyebileceğinizi öğrenmek için pipeline'lar arasında bileşenleri yeniden kullanma bölümüne göz atın.

Kantizasyon

Kantizasyon, model ağırlıklarını daha düşük hassasiyetli bir veri türünde saklayarak çok büyük modellerin bellek gereksinimlerini azaltmaya yardımcı olur. Ancak kantizasyonun video kalitesi üzerindeki etkisi, video modeline göre değişebilir.

Desteklenen kuantizasyon arka uçları ve kullanım durumunu destekleyen bir kuantizasyon arka ucunu seçme hakkında daha fazla bilgi edinmek için Quantization genel bakışına başvurun. Aşağıdaki örnek, bitsandbytes ile çıkarım için kuantize edilmiş bir MochiPipeline yüklemenin nasıl yapılacağını göstermektedir.

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

Mochi-1 Preview ile video oluşturma

Aşağıdaki örnek, tam hassasiyetli mochi-1-preview ağırlıklarını indirir ve en yüksek kalitede sonuçları üretir ancak çalıştırılması için en az 42GB VRAM gerektirir.

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)

Bellek tasarrufu için daha düşük hassasiyetli bir varyant kullanma

Aşağıdaki örnek, modelin bfloat16 varyantını kullanır ve çalıştırılması için 22 GB VRAM gerektirir. Sonuç olarak üretilen videonun kalitesinde hafif bir düşüş yaşanır.

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)

Genmo Mochi deposundaki sonuçları yeniden üretme

Genmo Mochi uygulaması, çıkarım sürecindeki her aşama için farklı hassasiyet değerleri kullanır. Metin kodlayıcı ve VAE torch.float32 kullanırken, DiT, dikkat çekirdeğinin EFFICIENT_ATTENTION olarak ayarlandığı torch.bfloat16 ile çalışır. Diffusers hatları, şu anda hattın farklı aşamaları için farklı dtypes ayarlamayı desteklememektedir. Çıkarımı orijinal uygulama ile aynı şekilde çalıştırmak için lütfen aşağıdaki örneğe bakın.

Orijinal Mochi uygulaması boş istekleri sıfırlar. Ancak bu seçeneği etkinleştirmek ve tüm hattı autocast altına almak, T5 metin kodlayıcısıyla sayısal taşmalara yol açabilir.

force_zeros_for_empty_prompt etkinleştirildiğinde, metin kodlama adımının tam hassasiyetle, autocast bağlamının dışında çalıştırılması önerilir.

Tam hassasiyette latentleri çözmek çok fazla bellek gerektirir. Bu örnekteki 163 kareyi üretmek için en az 70GB VRAM'e ihtiyacınız olacaktır. Belleği azaltmak için kare sayısını azaltın veya çözümleme adımını torch.bfloat16 ile çalıştırın.

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)

Çoklu GPU ile çıkarım çalıştırma

Büyük Mochi transformer'ı, from_pretrained içindeki device_map ve max_memory seçeneklerini kullanarak birden fazla GPU arasında bölmek mümkündür. Aşağıdaki örnekte model, her biri 24GB VRAM'e sahip iki GPU arasında bölünmektedir.

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)

Mochi Transformer ile tek dosya yükleme kullanımı

Mochi dönüştürücüsünü orijinal biçiminde yüklemek için from_single_file kullanabilirsiniz.

Diffusers şu anda Mochi tek dosya checkpoint'lerinin FP8 ölçekli sürümlerini kullanmayı desteklemiyor.

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[[diffusers.MochiPipeline]]

diffusers.MochiPipeline[[diffusers.MochiPipeline]]

diffusers.MochiPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLMochi, text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: MochiTransformer3DModel, force_zeros_for_empty_prompt: bool = False)

Kaynak

Parametreler:

transformer (MochiTransformer3DModel) : Kodlanmış video latentlerini gürültüden arındırmak için kullanılan koşullu Transformer mimarisi.

scheduler (FlowMatchEulerDiscreteScheduler) : Kodlanmış görüntü latentlerini gürültüden arındırmak için transformer ile birlikte kullanılacak bir zamanlayıcı.

vae (AutoencoderKLMochi) : Video'ları latent temsillere kodlamak ve latent temsillerden video'lara çözmek için kullanılan Varyasyonel Oto-Kodlayıcı (VAE) Modeli.

text_encoder (T5EncoderModel) : T5, özellikle google/t5-v1_1-xxl varyantı.

tokenizer (CLIPTokenizer) : CLIPTokenizer sınıfının tokenizer'ı.

tokenizer (T5TokenizerFast) : T5TokenizerFast sınıfının ikinci Tokenizer'ı.

Metinden video üretimi için mochi hattı.

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

call[[diffusers.MochiPipeline.call]]

__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_frames: int = 19, num_inference_steps: int = 64, timesteps: list = None, guidance_scale: float = 4.5, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list = ['latents'], max_sequence_length: int = 256)

Kaynak

Parametreler:

prompt (str veya list[str], isteğe bağlı) : Görsel üretimi yönlendirmek için istem veya istemler. Tanımlanmamışsa, bunun yerine prompt_embeds geçirilmelidir.

negative_prompt (str veya list[str], isteğe bağlı) : Görsel üretimi yönlendirmemek için kullanılan istem veya istemler. Tanımlanmamışsa bunun yerine negative_prompt_embeds parametresinin geçirilmesi gerekir. Yönlendirme kullanılmadığında (guidance_scale < 1) yok sayılır.

height (int, isteğe bağlı, varsayılan self.default_height) : Üretilen görüntünün piksel cinsinden yüksekliği. En iyi sonuçlar için varsayılan olarak 480 olarak ayarlanır.

width (int, isteğe bağlı, varsayılan self.default_width) : Üretilen görüntünün piksel cinsinden genişliği. En iyi sonuçlar için varsayılan olarak 848 olarak ayarlanır.

num_frames (int, varsayılan 19) : Üretilecek video kare sayısı

num_inference_steps (int, isteğe bağlı, varsayılan 50) : Gürültü azaltma adım sayısı. Daha fazla gürültü azaltma adımı genellikle daha yavaş çıkarım pahasına daha yüksek kaliteli bir görüntüye yol açar.

timesteps (list[int], isteğe bağlı) : set_timesteps metodunda timesteps argümanını destekleyen zamanlayıcılarla gürültü azaltma süreci için kullanılacak özel zaman adımları. Tanımlanmamışsa, num_inference_steps geçirildiğinde varsayılan davranış kullanılacaktır. Azalan sırada olmalıdır.

guidance_scale (float, varsayılan 4.5) : Classifier-Free Diffusion Guidance'de tanımlanan yönlendirme ölçeği. guidance_scale, Imagen Paper'deki 2. denklemindeki w olarak tanımlanır. Yönlendirme ölçeği, guidance_scale > 1 olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, genellikle daha düşük görüntü kalitesi pahasına, prompt ile yakından ilişkili görüntülerin üretilmesini teşvik eder.

num_videos_per_prompt (int, isteğe bağlı, varsayılan 1) : Her istem için üretilecek video sayısı.

generator (torch.Generator veya list[torch.Generator], isteğe bağlı) : Üretimi deterministik hale getirmek için bir veya torch üreteci(leri) listesi.

latents (torch.Tensor, isteğe bağlı) : Görsel üretimi için girdi olarak kullanılacak, Gauss dağılımından örneklenen önceden oluşturulmuş gürültülü latentler. Farklı istemlerle aynı üretimi ayarlamak için kullanılabilir. Sağlanmazsa, sağlanan rastgele generator kullanılarak örneklem yoluyla bir latent tensörü oluşturulur.

prompt_embeds (torch.Tensor, isteğe bağlı) : Ön oluşturulmuş metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, ör. istem ağırlıklandırması. Sağlanmazsa, metin gömme değerleri prompt girdi argümanından oluşturulur.

prompt_attention_mask (torch.Tensor, isteğe bağlı) : Metin gömme (embedding) için önceden oluşturulmuş dikkat maskesi (attention mask).

negative_prompt_embeds (torch.FloatTensor, isteğe bağlı) : Önceden oluşturulmuş negatif metin gömme değerleri. PixArt-Sigma için bu negatif istem "" olmalıdır. Sağlanmazsa, negative_prompt_embeds, negative_prompt girdi argümanından oluşturulur.

negative_prompt_attention_mask (torch.FloatTensor, isteğe bağlı) : Negatif metin gömme vektörleri için önceden oluşturulmuş dikkat maskesi.

output_type (str, isteğe bağlı, varsayılan "pil") : Üretilen görüntünün çıktı biçimi. PIL: PIL.Image.Image veya np.array arasında seçim yapın.

return_dict (bool, isteğe bağlı, varsayılan True) : Düz bir tuple yerine ~pipelines.mochi.MochiPipelineOutput döndürülecek mi?

attention_kwargs (dict, isteğe bağlı) : Belirtilirse, diffusers.models.attention_processor içinde self.processor altında tanımlanan AttentionProcessor'a iletilen bir kwargs sözlüğü.

callback_on_step_end (Callable, isteğe bağlı) : Çıkarım sırasında her gürültü azaltma adımının sonunda çağrılan bir işlev. İşlev aşağıdaki argümanlarla çağrılır: callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict). callback_kwargs, callback_on_step_end_tensor_inputs tarafından belirtilen tüm tensörlerin listesini içerir.

callback_on_step_end_tensor_inputs (list, isteğe bağlı) : callback_on_step_end işlevi için girdi tensörlerinin listesi. Listede belirtilen tensörler, callback_kwargs argümanı olarak geçirilir. Yalnızca pipeline sınıfınızın ._callback_tensor_inputs özniteliğinde listelenen değişkenleri dahil edebilirsiniz.

max_sequence_length (int varsayılan olarak 256'dır) : prompt ile kullanılacak maksimum dizi uzunluğu.

Dönüş: ~pipelines.mochi.MochiPipelineOutput veya tuple

return_dict True ise ~pipelines.mochi.MochiPipelineOutput döndürülür, aksi halde ilk öğesi üretilen görüntülerin listesini içeren bir tuple döndürülür.

Üretim için pipeline çağrıldığında tetiklenen işlev.

Örnekler:

>>> 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[[diffusers.MochiPipeline.encode_prompt]]

encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 256, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)

Kaynak

Parametreler:

prompt (str veya list[str], isteğe bağlı) : kodlanacak istem

negative_prompt (str veya list[str], isteğe bağlı) : Görsel üretimi yönlendirmemek için kullanılan istem veya istemler. Tanımlanmazsa, bunun yerine negative_prompt_embeds parametresinin geçirilmesi gerekir. Yönlendirme kullanılmadığında (yani guidance_scale değeri 1'den küçükse) yok sayılır.

do_classifier_free_guidance (bool, isteğe bağlı, varsayılan True) : Sınıflandırıcı serbest yönlendirmenin (classifier free guidance) kullanılıp kullanılmayacağı.

num_videos_per_prompt (int, opsiyonel, varsayılan 1) : Her istem için oluşturulması gereken video sayısı. Sonuç gömme vektörlerinin yerleştirileceği torch cihazı

prompt_embeds (torch.Tensor, isteğe bağlı) : Ön oluşturulmuş metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, ör. istem ağırlıklandırması. Sağlanmazsa, metin gömme değerleri prompt girdi argümanından oluşturulur.

negative_prompt_embeds (torch.Tensor, isteğe bağlı) : Ön oluşturulmuş negatif metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, ör. istem ağırlıklandırması. Sağlanmazsa, negative_prompt_embeds, negative_prompt girdi argümanından oluşturulur.

device : (torch.device, isteğe bağlı): torch cihazı

dtype : (torch.dtype, isteğe bağlı): torch dtype

İsteği metin kodlayıcı gizli durumlarına kodlar.

MochiPipelineOutput[[diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput]]

diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput[[diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput]]

diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput(frames: Tensor)

Kaynak

Parametreler:

frames (torch.Tensor, np.ndarray veya list[list[PIL.Image.Image]]) : video çıktıları listesi - batch_size, uzunluğunda iç içe geçmiş bir liste olabilir; her alt liste, num_frames. uzunluğunda gürültüsü azaltılmış PIL görüntü dizileri içerir. Ayrıca (batch_size, num_frames, channels, height, width) biçiminde bir NumPy dizi veya Torch tensörü de olabilir.

Mochi pipeline'leri için çıktı sınıfı.