# Lumina-T2X ![concepts](https://github.com/Alpha-VLLM/Lumina-T2X/assets/54879512/9f52eabb-07dc-4881-8257-6d8a5f2a0a5a) [Lumina-Next: Tornando o Lumina-T2X mais forte e rápido com o Next-DiT](https://huggingface.co/papers/2406.18583) da Alpha-VLLM, OpenGVLab, Shanghai AI Laboratory. O resumo do artigo é: *O Lumina-T2X é uma família nascente de Grandes Transformers de Difusão baseados em Fluxo (Flag-DiT) que estabelece um framework unificado para transformar ruído em diversas modalidades, como imagens e vídeos, condicionado a instruções de texto. Apesar de suas capacidades promissoras, o Lumina-T2X ainda enfrenta desafios, incluindo instabilidade no treinamento, inferência lenta e artefatos de extrapolação. Neste artigo, apresentamos o Lumina-Next, uma versão aprimorada do Lumina-T2X, que exibe um desempenho de geração mais forte com maior eficiência de treinamento e inferência. Começamos com uma análise abrangente da arquitetura Flag-DiT e identificamos vários componentes subótimos, que abordamos introduzindo a arquitetura Next-DiT com 3D RoPE e normalizações em sanduíche. Para permitir uma melhor extrapolação de resolução, comparamos minuciosamente diferentes métodos de extrapolação de contexto aplicados à geração de texto para imagem com 3D RoPE e propomos o Frequency- and Time-Aware Scaled RoPE adaptado para transformers de difusão. Além disso, introduzimos um agendamento de discretização de tempo sigmoide para reduzir as etapas de amostragem na resolução da ODE de Fluxo e o método Context Drop para mesclar tokens visuais redundantes para uma avaliação de rede mais rápida, aumentando efetivamente a velocidade geral de amostragem. Graças a essas melhorias, o Lumina-Next não apenas melhora a qualidade e a eficiência da geração básica de texto para imagem, mas também demonstra capacidades superiores de extrapolação de resolução e geração multilíngue usando LLMs baseados em decodificadores como codificador de texto, tudo de forma zero-shot. Para validar ainda mais o Lumina-Next como um framework generativo versátil, o instanciamos em diversas tarefas, incluindo reconhecimento visual, multi-view, áudio, música e geração de nuvens de pontos, demonstrando um desempenho forte em todos esses domínios. Ao liberar todos os códigos e pesos do modelo em https://github.com/Alpha-VLLM/Lumina-T2X, visamos avançar o desenvolvimento de IA generativa de próxima geração capaz de modelagem universal.* **Destaques**: Lumina-Next é um Diffusion Transformer de próxima geração que aprimora significativamente a geração de texto para imagem, a geração multilíngue e o desempenho multitarefa, ao introduzir a arquitetura Next-DiT, 3D RoPE e RoPE consciente de frequência e tempo, entre outras melhorias. O Lumina-Next possui os seguintes componentes: * Melhora a eficiência da amostragem com menos e mais rápidos Steps. * Ele usa um Next-DiT como backbone de transformer com Sandwichnorm 3D RoPE e Grouped-Query Attention. * Ele usa um RoPE Escalado Consciente de Frequência e Tempo. --- [Lumina-T2X: Transformando texto em qualquer modalidade, resolução e duração por meio de grandes difusão transformers baseados em fluxo](https://huggingface.co/papers/2405.05945) da Alpha-VLLM, OpenGVLab, Shanghai AI Laboratory. O resumo do artigo é: *O Sora revela o potencial de escalar o Diffusion Transformer para gerar imagens e vídeos fotorrealistas em resoluções, proporções e durações arbitrárias, mas ainda carece de detalhes de implementação suficientes. Neste relatório técnico, apresentamos a família Lumina-T2X - uma série de Grandes Diffusion Transformers baseados em Fluxo (Flag-DiT) equipados com atenção inicializada em zero, como um framework unificado projetado para transformar ruído em imagens, vídeos, objetos 3D multiview e clipes de áudio condicionados em instruções de texto. Ao tokenizar o espaço latente espaço-temporal e incorporar placeholders aprendíveis, como os tokens [nextline] e [nextframe], o Lumina-T2X unifica sem emendas as representações de diferentes modalidades em várias resoluções espaço-temporais. Essa abordagem unificada permite o treinamento dentro de um único framework para diferentes modalidades e possibilita a geração flexível de dados multimodais em qualquer resolução, proporção e comprimento durante a inferência. Técnicas avançadas, como RoPE, RMSNorm e flow matching, aprimoram a estabilidade, a flexibilidade e a escalabilidade do Flag-DiT, permitindo que os modelos do Lumina-T2X escalem até 7 bilhões de parâmetros e estendam a janela de contexto para 128K tokens. Isso é particularmente benéfico para a criação de imagens em ultra-alta definição com nosso modelo Lumina-T2I e vídeos longos em 720p com nosso modelo Lumina-T2V. Notavelmente, o Lumina-T2I, impulsionado por um Flag-DiT de 5 bilhões de parâmetros, requer apenas 35% dos custos computacionais de treinamento de um DiT ingênuo de 600 milhões de parâmetros. Nossa análise abrangente adicional destaca a capacidade preliminar do Lumina-T2X em extrapolação de resolução, edição em alta resolução, geração de visões 3D consistentes e síntese de vídeos com transições sem emendas. Esperamos que a disponibilização em código aberto do Lumina-T2X fomente ainda mais a criatividade, a transparência e a diversidade na comunidade de IA generativa.* Você pode encontrar a base de código original em [Alpha-VLLM](https://github.com/Alpha-VLLM/Lumina-T2X) e todos os checkpoints disponíveis em [Alpha-VLLM Lumina Family](https://huggingface.co/collections/Alpha-VLLM/lumina-family-66423205bedb81171fd0644b). **Destaques**: Lumina-T2X suporta qualquer modalidade, resolução e duração. O Lumina-T2X possui os seguintes componentes: * Ele usa um Flow-based Large Diffusion Transformer como backbone * Ele suporta diferentes modalidades com um único backbone e o codificador e decodificador correspondentes. Este pipeline foi contribuído por [PommesPeter](https://github.com/PommesPeter). A base de código original pode ser encontrada [aqui](https://github.com/Alpha-VLLM/Lumina-T2X). Os pesos originais podem ser encontrados em [hf.co/Alpha-VLLM](https://huggingface.co/Alpha-VLLM). > [!TIP] > Certifique-se de consultar o [guia](../../using-diffusers/schedulers) 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](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a carregar eficientemente os mesmos componentes em vários pipelines. ### Inference (Texto-para-Imagem) Use [`torch.compile`](https://huggingface.co/docs/diffusers/main/en/tutorials/fast_diffusion#torchcompile) para reduzir a latência de inferência. Primeiro, carregue o pipeline: ```python from diffusers import LuminaPipeline import torch pipeline = LuminaPipeline.from_pretrained( "Alpha-VLLM/Lumina-Next-SFT-diffusers", dtype=torch.bfloat16 ).to("cuda") # or "mps", "xpu", "cpu" ``` Em seguida, altere o layout de memória dos componentes `transformer` e `vae` dos pipelines para `torch.channels-last`: ```python pipeline.transformer.to(memory_format=torch.channels_last) pipeline.vae.to(memory_format=torch.channels_last) ``` Por fim, compile os componentes e execute a inferência: ```python pipeline.transformer = torch.compile(pipeline.transformer, mode="max-autotune", fullgraph=True) pipeline.vae.decode = torch.compile(pipeline.vae.decode, mode="max-autotune", fullgraph=True) image = pipeline(prompt="Upper body of a young woman in a Victorian-era outfit with brass goggles and leather straps. Background shows an industrial revolution cityscape with smoky skies and tall, metal structures").images[0] ``` ## 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](../../quantization/overview) 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 [LuminaPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/lumina#diffusers.LuminaPipeline) quantizado para inferência com bitsandbytes. ```py import torch from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, Transformer2DModel, LuminaPipeline from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel quant_config = BitsAndBytesConfig(load_in_8bit=True) text_encoder_8bit = T5EncoderModel.from_pretrained( "Alpha-VLLM/Lumina-Next-SFT-diffusers", subfolder="text_encoder", quantization_config=quant_config, dtype=torch.float16, ) quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True) transformer_8bit = Transformer2DModel.from_pretrained( "Alpha-VLLM/Lumina-Next-SFT-diffusers", subfolder="transformer", quantization_config=quant_config, dtype=torch.float16, ) pipeline = LuminaPipeline.from_pretrained( "Alpha-VLLM/Lumina-Next-SFT-diffusers", text_encoder=text_encoder_8bit, transformer=transformer_8bit, dtype=torch.float16, device_map="balanced", ) prompt = "a tiny astronaut hatching from an egg on the moon" image = pipeline(prompt).images[0] image.save("lumina.png") ``` ## LuminaPipeline[[diffusers.LuminaPipeline]] #### diffusers.LuminaPipeline[[diffusers.LuminaPipeline]] ```python diffusers.LuminaPipeline(transformer: LuminaNextDiT2DModel, scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: GemmaPreTrainedModel, tokenizer: GemmaTokenizer) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/lumina/pipeline_lumina.py#L135) **Parâmetros:** vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes. text_encoder (`GemmaPreTrainedModel`) : Codificador de texto Gemma congelado. tokenizer (`GemmaTokenizer` ou `GemmaTokenizerFast`) : Tokenizador Gemma. transformer ([Transformer2DModel](/docs/diffusers/v0.43.0/pt/api/models/transformer2d#diffusers.Transformer2DModel)) : Um `Transformer2DModel` condicionado por texto para desruidar os latentes da imagem codificada. scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/pt/api/schedulers/overview#diffusers.SchedulerMixin)) : Um scheduler para ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. Pipeline para geração de texto para imagem usando Lumina-T2I. Este modelo herda de [DiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.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.LuminaPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, width: int | None = None, height: int | None = None, num_inference_steps: int = 30, guidance_scale: float = 4.0, negative_prompt: str | list[str] = None, sigmas: list[float] = None, num_images_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, 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, output_type: str | None = 'pil', return_dict: bool = True, clean_caption: bool = True, max_sequence_length: int = 256, scaling_watershed: float | None = 1.0, proportional_attn: bool | None = 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']) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/lumina/pipeline_lumina.py#L631) **Parâmetros:** prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. 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 da imagem. 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 30) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta. sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar no processo de desruidamento com agendadores que suportam um argumento `sigmas` em seu método `set_timesteps`. Se não definido, o comportamento padrão quando `num_inference_steps` é passado será usado. guidance_scale (`float`, *opcional*, padrão 4.0) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem. num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt. height (`int`, *opcional*, padrão é self.unet.config.sample_size) : A altura em pixels da imagem gerada. width (`int`, *opcional*, padrão é self.unet.config.sample_size) : A largura em pixels da imagem gerada. generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um ou uma lista de [geradores do torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes 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 Lumina-T2I, 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 da imagem gerada. Escolha entre [PIL](https://pillow.readthedocs.io/en/stable/): `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. 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 é 120) : Comprimento máximo da sequência a ser usado com o `prompt`. scaling_watershed (`float`, *opcional*, padrão 1.0) : Limiar de escala de resolução usado pelo Lumina para alternar entre a atenção de contexto padrão e a de contexto estendido. proportional_attn (`bool`, *opcional*, padrão True) : Se deve escalar a atenção proporcionalmente para geração em alta resolução. 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. **Retorna:** [ImagePipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple` Se `return_dict` for `True`, [ImagePipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas Função invocada ao chamar o pipeline para geração. Exemplos: ```py >>> import torch >>> from diffusers import LuminaPipeline >>> pipe = LuminaPipeline.from_pretrained("Alpha-VLLM/Lumina-Next-SFT-diffusers", torch_dtype=torch.bfloat16) >>> # Enable memory optimizations. >>> pipe.enable_model_cpu_offload() >>> prompt = "Upper body of a young woman in a Victorian-era outfit with brass goggles and leather straps. Background shows an industrial revolution cityscape with smoky skies and tall, metal structures" >>> image = pipe(prompt).images[0] ``` #### encode_prompt[[diffusers.LuminaPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, negative_prompt: str | list[str] = None, num_images_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, **kwargs) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/lumina/pipeline_lumina.py#L261) **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` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`). Para o Lumina-T2I, isso deve ser "". do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : se deve ou não usar classifier free guidance num_images_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*) : Embeddings de texto negativo pré-gerados. Para o Lumina-T2I, deve ser os embeddings 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 256) : Comprimento máximo da sequência a ser usado para o prompt. Codifica o prompt em estados ocultos do codificador de texto.