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

Bajo licencia Apache License, versión 2.0 (la "Licencia");

no puede usar este archivo excepto en cumplimiento de la Licencia.

Puede obtener una copia de la Licencia en

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

A menos que la ley aplicable lo exija o se haya acordado por escrito, el software

distribuido bajo la Licencia se distribuye en una base "TAL CUAL",

SIN GARANTÍAS NI CONDICIONES DE NINGÚN TIPO, ya sea expresa o implícita.

Consulte la Licencia para el lenguaje específico que rige los permisos y

limitaciones de la Licencia.

-->

Mochi 1 Preview

Por el momento, solo está disponible una vista previa de investigación de los pesos del modelo.

Mochi 1 es un modelo de generación de vídeo de Genmo con un fuerte enfoque en la adherencia al prompt y la calidad del movimiento. El modelo presenta una arquitectura de Asmmetric Diffusion Transformer (AsymmDiT) de 10B parámetros y utiliza capas de proyección QKV y de salida no cuadradas para reducir los requisitos de memoria de inferencia. Se utiliza un único modelo T5-XXL para codificar los prompts.

Mochi 1 preview es un modelo de generación de video de vanguardia y de código abierto, con movimiento de alta fidelidad y un fuerte seguimiento de los prompts en la evaluación preliminar. Este modelo reduce drásticamente la brecha entre los sistemas de generación de video cerrados y los abiertos. El modelo se publica bajo la licencia permisiva Apache 2.0.

Asegúrate de consultar la guía de Schedulers para aprender a explorar el equilibrio entre la velocidad y la calidad del scheduler, y consulta la sección reutilizar componentes entre pipelines para aprender a cargar eficientemente los mismos componentes en múltiples pipelines.

Cuantización

La cuantización ayuda a reducir los requisitos de memoria de los modelos muy grandes almacenando los pesos del modelo en un tipo de datos de menor precisión. Sin embargo, la cuantización puede tener un impacto variable en la calidad del vídeo dependiendo del modelo de vídeo.

Consulte el resumen de Quantization para obtener más información sobre los backends de cuantización admitidos y la selección de un backend de cuantización que admita su caso de uso. El siguiente ejemplo demuestra cómo cargar un MochiPipeline cuantizado para inferencia con 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")

Generación de videos con Mochi-1 Preview

El siguiente ejemplo descargará los pesos de precisión completa de mochi-1-preview y producirá resultados de la máxima calidad, pero requerirá al menos 42 GB de VRAM para ejecutarse.

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)

Usar una variante de menor precisión para ahorrar memoria

El siguiente ejemplo utilizará la variante bfloat16 del modelo y requiere 22 GB de VRAM para ejecutarse. Como resultado, hay una ligera disminución en la calidad del video generado.

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)

Reproduciendo los resultados del repositorio Genmo Mochi

La implementación de Genmo Mochi utiliza valores de precisión diferentes para cada etapa del proceso de inferencia. El codificador de texto y el VAE usan torch.float32, mientras que el DiT usa torch.bfloat16 con el kernel de atención establecido en EFFICIENT_ATTENTION. Los pipelines de Diffusers actualmente no admiten la configuración de diferentes dtypes para diferentes etapas del pipeline. Para ejecutar la inferencia de la misma manera que la implementación original, consulte el siguiente ejemplo.

La implementación original de Mochi pone a cero los prompts vacíos. Sin embargo, habilitar esta opción y colocar todo el pipeline bajo autocast puede provocar desbordes numéricos con el codificador de texto T5.

Al habilitar force_zeros_for_empty_prompt, se recomienda ejecutar el paso de codificación de texto fuera del contexto de autocast en precisión completa.

Decodificar los latentes en precisión completa consume mucha memoria. Se necesita al menos 70 GB de VRAM para generar los 163 fotogramas de este ejemplo. Para reducir la memoria, reduzca el número de fotogramas o ejecute el paso de decodificación en 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)

Ejecución de inferencia con varias GPU

Es posible dividir el gran transformer de Mochi entre varias GPU utilizando las opciones device_map y max_memory en from_pretrained. En el siguiente ejemplo, dividimos el modelo entre dos GPU, cada una con 24 GB de VRAM.

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)

Uso de la carga de un solo archivo con el Mochi Transformer

Puedes usar from_single_file para cargar el transformer de Mochi en su formato original.

Diffusers actualmente no admite el uso de las versiones escaladas en FP8 de los puntos de control de archivo único de 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[[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)

Fuente

Parámetros:

transformer (MochiTransformer3DModel) : Arquitectura de Transformer condicional para desruidar los latentes de video codificados.

scheduler (FlowMatchEulerDiscreteScheduler) : Un programador para usar en combinación con transformer para desruidar los latentes de imagen codificados.

vae (AutoencoderKLMochi) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar videos hacia y desde representaciones latentes.

text_encoder (T5EncoderModel) : T5, específicamente la variante google/t5-v1_1-xxl.

tokenizer (CLIPTokenizer) : Tokenizador de la clase CLIPTokenizer.

tokenizer (T5TokenizerFast) : Segundo Tokenizer de la clase T5TokenizerFast.

El pipeline mochi para la generación de texto a video.

Referencia: 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[int] = 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[str] = ['latents'], max_sequence_length: int = 256)

Fuente

Parámetros:

prompt (str o list[str], opcional) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar prompt_embeds en su lugar.

negative_prompt (str o list[str], opcional) : El prompt o los prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar negative_prompt_embeds en su lugar. Se ignora cuando no se usa guía (guidance_scale < 1).

height (int, opcional, valor predeterminado self.default_height) : La altura en píxeles de la imagen generada. Por defecto, se establece en 480 para obtener los mejores resultados.

width (int, opcional, valor predeterminado self.default_width) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 848 para obtener los mejores resultados.

num_frames (int, por defecto 19) : El número de fotogramas de vídeo a generar

num_inference_steps (int, opcional, valor predeterminado 50) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

timesteps (list[int], opcional) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento timesteps en su método set_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pase num_inference_steps. Debe estar en orden descendente.

guidance_scale (float, por defecto 4.5) : Escala de guía definida en Classifier-Free Diffusion Guidance. guidance_scale se define como w de la ecuación 2. de Imagen Paper. La escala de guía se activa estableciendo guidance_scale > 1. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al prompt de texto, generalmente a costa de una menor calidad de imagen.

num_videos_per_prompt (int, opcional, valor predeterminado 1) : El número de videos a generar por indicación.

generator (torch.Generator o list[torch.Generator], opcional) : Uno o una lista de generadores de torch para hacer la generación determinista.

latents (torch.Tensor, opcional) : Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el generator aleatorio suministrado.

prompt_embeds (torch.Tensor, opcional) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada prompt.

prompt_attention_mask (torch.Tensor, opcional) : Máscara de atención pregenerada para los embeddings de texto.

negative_prompt_embeds (torch.FloatTensor, opcional) : Embeddings de texto negativos pregenerados. Para PixArt-Sigma, este prompt negativo debe ser "". Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entrada negative_prompt.

negative_prompt_attention_mask (torch.FloatTensor, opcional) : Máscara de atención pregenerada para los embeddings de texto negativos.

output_type (str, opcional, por defecto "pil") : El formato de salida de la imagen generada. Elija entre PIL: PIL.Image.Image o np.array.

return_dict (bool, opcional, valor predeterminado True) : Si se devuelve un ~pipelines.mochi.MochiPipelineOutput en lugar de una tupla simple.

attention_kwargs (dict, opcional) : Un diccionario de kwargs que, si se especifica, se pasa al AttentionProcessor tal como se define bajo self.processor en diffusers.models.attention_processor.

callback_on_step_end (Callable, opcional) : Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama con los siguientes argumentos: callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict). callback_kwargs incluirá una lista de todos los tensores especificados por callback_on_step_end_tensor_inputs.

callback_on_step_end_tensor_inputs (list, opcional) : La lista de entradas de tensor para la función callback_on_step_end. Los tensores especificados en la lista se pasarán como argumento callback_kwargs. Solo podrá incluir variables enumeradas en el atributo ._callback_tensor_inputs de su clase de pipeline.

max_sequence_length (int por defecto 256) : Longitud máxima de secuencia para usar con el prompt.

Devuelve: ~pipelines.mochi.MochiPipelineOutput o tuple

Si return_dict es True, se devuelve ~pipelines.mochi.MochiPipelineOutput; en caso contrario, se devuelve una tuple cuyo primer elemento es una lista con las imágenes generadas.

Función invocada al llamar a la pipeline para la generación.

Ejemplos:

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

Fuente

Parámetros:

prompt (str o list[str], opcional) : prompt a codificar

negative_prompt (str o list[str], opcional) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar negative_prompt_embeds en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si guidance_scale es menor que 1).

do_classifier_free_guidance (bool, opcional, por defecto True) : Si se debe usar o no la guía libre de clasificador.

num_videos_per_prompt (int, opcional, valor predeterminado 1) : Número de videos que deben generarse por indicación. Dispositivo de torch en el que colocar las incrustaciones resultantes

prompt_embeds (torch.Tensor, opcional) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada prompt.

negative_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, p. ej. el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada negative_prompt.

device : (torch.device, opcional): dispositivo de torch

dtype : (torch.dtype, opcional): dtype de torch

Codifica el prompt en estados ocultos del codificador de texto.

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)

Fuente

Parámetros:

frames (torch.Tensor, np.ndarray o list[list[PIL.Image.Image]]) : lista de salidas de video - Puede ser una lista anidada de longitud batch_size, donde cada sublista contiene secuencias de imágenes PIL desruidas de longitud num_frames. También puede ser un array de NumPy o un tensor de Torch de forma (batch_size, num_frames, channels, height, width).

Clase de salida para las tuberías de Mochi.