diffusers/main/pt/api/pipelines/allegro.md

Allegro

Allegro: Abrindo a caixa-preta do modelo de geração de vídeo de nível comercial da RhymesAI, por Yuan Zhou, Qiuyue Wang, Yuxuan Cai, Huan Yang.

O resumo do artigo é:

Avanços significativos foram realizados no campo de geração de vídeo, com a comunidade de código aberto contribuindo com uma riqueza de artigos de pesquisa e ferramentas para treinar modelos de alta qualidade. No entanto, apesar desses esforços, as informações e recursos disponíveis permanecem insuficientes para alcançar um desempenho de nível comercial. Neste relatório, abrimos a caixa-preta e apresentamos o Allegro, um modelo avançado de geração de vídeo que se destaca tanto em qualidade quanto em consistência temporal. Também destacamos as limitações atuais do campo e apresentamos uma metodologia abrangente para treinar modelos de geração de vídeo de alto desempenho e nível comercial, abordando aspectos-chave como dados, arquitetura do modelo, pipeline de treinamento e avaliação. Nosso estudo com usuários mostra que o Allegro supera os modelos de código aberto existentes e a maioria dos modelos comerciais, ficando apenas atrás do Hailuo e do Kling. Código: https://github.com/rhymes-ai/Allegro , Modelo: https://huggingface.co/rhymes-ai/Allegro , Galeria: https://rhymes.ai/allegro_gallery .

Certifique-se de consultar o guia de Schedulers para aprender a explorar o compromisso entre a velocidade e a qualidade do scheduler, e veja a seção reutilização de componentes entre pipelines para aprender a carregar eficientemente os mesmos componentes em vários pipelines.

Quantização

A quantização ajuda a reduzir os requisitos de memória de modelos muito grandes armazenando os pesos do modelo em um tipo de dados de menor precisão. No entanto, a quantização pode ter um impacto variável na qualidade do vídeo, dependendo do modelo de vídeo.

Consulte a visão geral de Quantization para saber mais sobre os backends de quantização suportados e sobre como selecionar um backend de quantização que atenda ao seu caso de uso. O exemplo abaixo demonstra como carregar um AllegroPipeline quantizado para inferência com bitsandbytes.

import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, AllegroTransformer3DModel, AllegroPipeline
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(
    "rhymes-ai/Allegro",
    subfolder="text_encoder",
    quantization_config=quant_config,
    dtype=torch.float16,
)

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = AllegroTransformer3DModel.from_pretrained(
    "rhymes-ai/Allegro",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.float16,
)

pipeline = AllegroPipeline.from_pretrained(
    "rhymes-ai/Allegro",
    text_encoder=text_encoder_8bit,
    transformer=transformer_8bit,
    dtype=torch.float16,
    device_map="balanced",
)

prompt = (
    "A seaside harbor with bright sunlight and sparkling seawater, with many boats in the water. From an aerial view, "
    "the boats vary in size and color, some moving and some stationary. Fishing boats in the water suggest that this "
    "location might be a popular spot for docking fishing boats."
)
video = pipeline(prompt, guidance_scale=7.5, max_sequence_length=512).frames[0]
export_to_video(video, "harbor.mp4", fps=15)

AllegroPipeline[[diffusers.AllegroPipeline]]

diffusers.AllegroPipeline[[diffusers.AllegroPipeline]]

diffusers.AllegroPipeline(tokenizer: T5Tokenizer, text_encoder: T5EncoderModel, vae: AutoencoderKLAllegro, transformer: AllegroTransformer3DModel, scheduler: KarrasDiffusionSchedulers)

Fonte

Parâmetros:

vae (AllegroAutoEncoderKL3D) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos a partir de e para representações latentes.

text_encoder (T5EncoderModel) : Codificador de texto congelado. O PixArt-Alpha usa T5, especificamente a variante t5-v1_1-xxl.

tokenizer (T5Tokenizer) : Tokenizer da classe T5Tokenizer.

transformer (AllegroTransformer3DModel) : Um AllegroTransformer3DModel condicionado por texto para desruidar os latentes de vídeo codificados.

scheduler (SchedulerMixin) : Um scheduler para ser usado em combinação com transformer para desruidar os latentes de vídeo codificados.

Pipeline para geração de texto para vídeo usando Allegro.

Este modelo herda de DiffusionPipeline. Consulte a documentação da superclasse para os métodos genéricos que a biblioteca implementa para todos os pipelines (como download ou salvamento, execução em um dispositivo específico, etc.)

call[[diffusers.AllegroPipeline.call]]

__call__(prompt: str | list[str] = None, negative_prompt: str = '', num_inference_steps: int = 100, timesteps: list[int] = None, guidance_scale: float = 7.5, num_frames: int | None = None, height: int | None = None, width: int | None = None, num_videos_per_prompt: int = 1, eta: float = 0.0, 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, 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, max_sequence_length: int = 512)

Fonte

Parâmetros:

prompt (str ou list[str], opcional) : O prompt ou os prompts para orientar a geração do vídeo. Se não definido, é necessário passar prompt_embeds em vez disso.

negative_prompt (str ou list[str], opcional) : O prompt ou os prompts que não devem orientar a geração do vídeo. Se não definido, é necessário passar negative_prompt_embeds em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se guidance_scale for menor que 1).

num_inference_steps (int, opcional, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em um vídeo de maior qualidade, em detrimento de uma inferência mais lenta.

timesteps (list[int], opcional) : Passos de tempo personalizados para usar no processo de remoção de ruído. Se não definido, são usados passos de tempo igualmente espaçados de num_inference_steps. Devem estar em ordem decrescente.

guidance_scale (float, opcional, padrão 7.5) : Escala de orientação definida em Classifier-Free Diffusion Guidance. guidance_scale é definido como w da equação 2. do Imagen Paper. A escala de orientação é ativada ao definir guidance_scale > 1. Uma escala de orientação maior incentiva a geração de vídeos que estão intimamente ligados ao prompt de texto, geralmente em detrimento de uma menor qualidade do vídeo.

num_videos_per_prompt (int, opcional, padrão 1) : O número de vídeos a serem gerados por prompt.

num_frames : (int, opcional, padrão 88): O número controla os quadros do vídeo gerado.

height (int, opcional, padrão é self.unet.config.sample_size) : A altura em pixels do vídeo gerado.

width (int, opcional, padrão é self.unet.config.sample_size) : A largura em pixels do vídeo gerado.

eta (float, opcional, padrão 0.0) : Corresponde ao parâmetro eta (η) no paper DDIM: https://huggingface.co/papers/2010.02502. Aplica-se apenas a schedulers.DDIMScheduler, será ignorado para os demais.

generator (torch.Generator ou list[torch.Generator], opcional) : Um ou uma lista de geradores do torch para tornar a geração determinística.

latents (torch.Tensor, opcional) : geração. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes pré-gerados, latentes ruidosos amostrados de uma distribuição gaussiana, a ser usado como entradas para vídeo, será gerado por amostragem usando o generator aleatório fornecido.

prompt_embeds (torch.Tensor, opcional) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada prompt.

prompt_attention_mask (torch.Tensor, opcional) : Máscara de atenção pré-gerada para embeddings de texto.

negative_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto negativo pré-gerados. Para o PixArt-Sigma, este prompt negativo deve ser "". Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entrada negative_prompt.

negative_prompt_attention_mask (torch.Tensor, opcional) : Máscara de atenção pré-gerada para embeddings de texto negativo.

output_type (str, opcional, padrão "pil") : O formato de saída do vídeo gerado. Escolha entre PIL: PIL.Image.Image ou np.array.

return_dict (bool, opcional, padrão True) : Se deve ou não retornar um ~pipelines.stable_diffusion.IFPipelineOutput em vez de uma tupla simples.

callback_on_step_end (Callable, opcional) : Uma função que é chamada no final de cada etapa de desruidamento durante a inferência. A função é chamada com os seguintes argumentos: callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict). callback_kwargs incluirá uma lista de todos os tensores, conforme especificado por callback_on_step_end_tensor_inputs.

callback_on_step_end_tensor_inputs (List, opcional) : A lista de entradas de tensor para a função callback_on_step_end. Os tensores especificados na lista serão passados como argumento callback_kwargs. Você só poderá incluir variáveis listadas no atributo ._callback_tensor_inputs da sua classe de pipeline.

clean_caption (bool, opcional, padrão True) : Se deve ou não limpar a legenda antes de criar os embeddings. Exige que beautifulsoup4 e ftfy estejam instalados. Se as dependências não estiverem instaladas, os embeddings serão criados a partir do prompt bruto.

max_sequence_length (int padrão é 512) : Comprimento máximo da sequência a ser usado com o prompt.

Retorna: AllegroPipelineOutput ou tuple

Se return_dict for True, AllegroPipelineOutput é retornado; caso contrário, uma tuple é retornada, em que o primeiro elemento é uma lista com os vídeos gerados.

Função invocada ao chamar o pipeline para geração.

Exemplos:

>>> import torch
>>> from diffusers import AutoencoderKLAllegro, AllegroPipeline
>>> from diffusers.utils import export_to_video

>>> vae = AutoencoderKLAllegro.from_pretrained("rhymes-ai/Allegro", subfolder="vae", torch_dtype=torch.float32)
>>> pipe = AllegroPipeline.from_pretrained("rhymes-ai/Allegro", vae=vae, torch_dtype=torch.bfloat16).to("cuda")
>>> pipe.vae.enable_tiling()

>>> prompt = (
...     "A seaside harbor with bright sunlight and sparkling seawater, with many boats in the water. From an aerial view, "
...     "the boats vary in size and color, some moving and some stationary. Fishing boats in the water suggest that this "
...     "location might be a popular spot for docking fishing boats."
... )
>>> video = pipe(prompt, guidance_scale=7.5, max_sequence_length=512).frames[0]
>>> export_to_video(video, "output.mp4", fps=15)

encode_prompt[[diffusers.AllegroPipeline.encode_prompt]]

encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, negative_prompt: str = '', num_videos_per_prompt: int = 1, device: typing.Optional[torch.device] = None, 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, clean_caption: bool = False, max_sequence_length: int = 512, **kwargs)

Fonte

Parâmetros:

prompt (str ou list[str], opcional) : prompt a ser codificado

negative_prompt (str ou list[str], opcional) : O prompt para não orientar a geração da imagem. Se não for definido, é necessário passar negative_prompt_embeds no lugar. Ignorado quando não se usa orientação (ou seja, ignorado se guidance_scale for menor que 1). Para o PixArt-Alpha, isso deve ser "".

do_classifier_free_guidance (bool, opcional, padrão True) : se deve ou não usar classifier free guidance

num_videos_per_prompt (int, opcional, padrão 1) : número de imagens que devem ser geradas por prompt

device : (torch.device, opcional): dispositivo torch onde os embeddings resultantes serão colocados

prompt_embeds (torch.Tensor, opcional) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada prompt.

negative_prompt_embeds (torch.Tensor, opcional) : Embebidings de texto negativo pré-gerados. Para o PixArt-Alpha, deve ser os embebidings da string "".

clean_caption (bool, padrão False) : Se True, a função pré-processará e limpará a legenda fornecida antes da codificação.

max_sequence_length (int, padrão 512) : Comprimento máximo da sequência a ser usado para o prompt.

Codifica o prompt em estados ocultos do codificador de texto.

AllegroPipelineOutput[[diffusers.pipelines.allegro.pipeline_output.AllegroPipelineOutput]]

diffusers.pipelines.allegro.pipeline_output.AllegroPipelineOutput[[diffusers.pipelines.allegro.pipeline_output.AllegroPipelineOutput]]

diffusers.pipelines.allegro.pipeline_output.AllegroPipelineOutput(frames: typing.Union[torch.Tensor, numpy.ndarray, list[list[PIL.Image.Image]]])

Fonte

Parâmetros:

frames (torch.Tensor, np.ndarray ou list[list[PIL.Image.Image]]) : lista de saídas de vídeo - Pode ser uma lista aninhada de comprimento batch_size, em que cada sublista contém sequências de imagens PIL desruidas de comprimento num_frames. Também pode ser um array NumPy ou um tensor Torch de forma (batch_size, num_frames, channels, height, width).

Classe de saída para pipelines do Allegro.