# Lumina-T2X
![concepts](https://github.com/Alpha-VLLM/Lumina-T2X/assets/54879512/9f52eabb-07dc-4881-8257-6d8a5f2a0a5a)

[Lumina-Next: Making Lumina-T2X Stronger and Faster with Next-DiT](https://huggingface.co/papers/2406.18583) de Alpha-VLLM, OpenGVLab, Shanghai AI Laboratory.

El resumen del artículo es:

*Lumina-T2X es una familia incipiente de grandes difusores transformers basados en flujos (Flag-DiT) que establece un marco unificado para transformar ruido en diversas modalidades, como imágenes y videos, condicionado por instrucciones de texto. A pesar de sus capacidades prometedoras, Lumina-T2X aún enfrenta desafíos como la inestabilidad del entrenamiento, la inferencia lenta y los artefactos de extrapolación. En este artículo, presentamos Lumina-Next, una versión mejorada de Lumina-T2X, que muestra un rendimiento de generación más fuerte con una mayor eficiencia en el entrenamiento y la inferencia. Comenzamos con un análisis exhaustivo de la arquitectura Flag-DiT e identificamos varios componentes subóptimos, a los que abordamos introduciendo la arquitectura Next-DiT con 3D RoPE y normalizaciones sándwich. Para habilitar una mejor extrapolación de resolución, comparamos a fondo diferentes métodos de extrapolación de contexto aplicados a la generación de texto a imagen con 3D RoPE, y proponemos Frequency- and Time-Aware Scaled RoPE adaptado para difusores transformers. Además, introducimos un programa de discretización de tiempo sigmoide para reducir los pasos de muestreo en la resolución de la EDO de flujo y el método Context Drop para fusionar tokens visuales redundantes para una evaluación de red más rápida, mejorando efectivamente la velocidad general de muestreo. Gracias a estas mejoras, Lumina-Next no solo mejora la calidad y la eficiencia de la generación básica de texto a imagen, sino que también demuestra capacidades superiores de extrapolación de resolución y generación multilingüe utilizando LLMs basados en decodificadores como codificador de texto, todo de manera zero-shot. Para validar aún más Lumina-Next como un marco generativo versátil, lo instanciamos en diversas tareas, incluida la reconocimiento visual, multi-vista, audio, música y generación de nubes de puntos, mostrando un rendimiento sólido en estos dominios. Al liberar todos los códigos y pesos del modelo en https://github.com/Alpha-VLLM/Lumina-T2X, buscamos avanzar en el desarrollo de la IA generativa de próxima generación capaz de modelado universal.*

**Aspectos destacados**: Lumina-Next es un Diffusion Transformer de próxima generación que mejora significativamente la generación de texto a imagen, la generación multilingüe y el rendimiento multitarea mediante la introducción de la arquitectura Next-DiT, 3D RoPE y RoPE consciente de la frecuencia y el tiempo, entre otras mejoras.

Lumina-Next tiene los siguientes componentes:
* Mejora la eficiencia de muestreo con menos y más rápidos pasos.
* Utiliza un Next-DiT como columna vertebral de transformador con Sandwichnorm 3D RoPE y Grouped-Query Attention.
* Utiliza un RoPE escalado consciente de la frecuencia y el tiempo.

---

[Lumina-T2X: Transformando texto en cualquier modalidad, resolución y duración mediante grandes transformadores de difusión basados en flujo](https://huggingface.co/papers/2405.05945) de Alpha-VLLM, OpenGVLab, Shanghai AI Laboratory.

El resumen del artículo es:

*Sora revela el potencial de escalar Diffusion Transformer para generar imágenes y videos fotorrealistas en resoluciones, relaciones de aspecto y duraciones arbitrarias, aunque aún carece de detalles de implementación suficientes. En este informe técnico, presentamos la familia Lumina-T2X, una serie de grandes Diffusion Transformers basados en flujo (Flag-DiT) equipados con atención inicializada en cero, como un marco unificado diseñado para transformar ruido en imágenes, videos, objetos 3D multivista y clips de audio condicionados por instrucciones de texto. Al tokenizar el espacio espacial-temporal latente e incorporar marcadores de posición aprendibles como los tokens [nextline] y [nextframe], Lumina-T2X unifica sin fisuras las representaciones de diferentes modalidades a través de diversas resoluciones espaciales-temporales. Este enfoque unificado permite el entrenamiento dentro de un único marco para diferentes modalidades y posibilita la generación flexible de datos multimodales en cualquier resolución, relación de aspecto y longitud durante la inferencia. Técnicas avanzadas como RoPE, RMSNorm y flow matching mejoran la estabilidad, flexibilidad y escalabilidad de Flag-DiT, lo que permite que los modelos de Lumina-T2X escalen hasta 7 mil millones de parámetros y extiendan la ventana de contexto a 128K tokens. Esto es particularmente beneficioso para crear imágenes de ultra alta definición con nuestro modelo Lumina-T2I y videos largos en 720p con nuestro modelo Lumina-T2V. Notablemente, Lumina-T2I, impulsado por un Flag-DiT de 5 mil millones de parámetros, requiere solo el 35% de los costos computacionales de entrenamiento de un DiT ingenuo de 600 millones de parámetros. Nuestro análisis exhaustivo posterior subraya la capacidad preliminar de Lumina-T2X en la extrapolación de resolución, la edición de alta resolución, la generación de vistas 3D consistentes y la síntesis de videos con transiciones fluidas. Esperamos que la publicación abierta de Lumina-T2X fomente aún más la creatividad, la transparencia y la diversidad en la comunidad de IA generativa.*

Puedes encontrar el código original en [Alpha-VLLM](https://github.com/Alpha-VLLM/Lumina-T2X) y todos los checkpoints disponibles en [Alpha-VLLM Lumina Family](https://huggingface.co/collections/Alpha-VLLM/lumina-family-66423205bedb81171fd0644b).

**Aspectos destacados**: Lumina-T2X admite cualquier modalidad, resolución y duración.

Lumina-T2X tiene los siguientes componentes:
* Utiliza un Large Diffusion Transformer basado en Flow como columna vertebral
* Admite diferentes modalidades con un único backbone y el codificador y decodificador correspondientes.

Este pipeline fue aportado por [PommesPeter](https://github.com/PommesPeter). La base de código original se puede encontrar [aquí](https://github.com/Alpha-VLLM/Lumina-T2X). Los pesos originales se pueden encontrar en [hf.co/Alpha-VLLM](https://huggingface.co/Alpha-VLLM).

> [!TIP]
> Asegúrate de consultar la [guía de Schedulers](../../using-diffusers/schedulers) para aprender a explorar el equilibrio entre la velocidad y la calidad del scheduler, y consulta la sección [reutilizar componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a cargar eficientemente los mismos componentes en múltiples pipelines.

### Inference (Texto a imagen)

Use [`torch.compile`](../../optimization/fp16#torchcompile) para reducir la latencia de inferencia.

Primero, carga el 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"
```

Luego, cambia el diseño de memoria de los componentes `transformer` y `vae` de los pipelines a `torch.channels-last`:

```python
pipeline.transformer.to(memory_format=torch.channels_last)
pipeline.vae.to(memory_format=torch.channels_last)
```

Por último, compile los componentes y ejecute la inferencia:

```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]
```

## 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](../../quantization/overview) 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 [LuminaPipeline](/docs/diffusers/main/es/api/pipelines/lumina#diffusers.LuminaPipeline) cuantizado para inferencia con 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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/lumina/pipeline_lumina.py#L135)

**Parámetros:**

vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder (`GemmaPreTrainedModel`) : Codificador de texto Gemma congelado.

tokenizer (`GemmaTokenizer` o `GemmaTokenizerFast`) : Tokenizador de Gemma.

transformer ([Transformer2DModel](/docs/diffusers/main/es/api/models/transformer2d#diffusers.Transformer2DModel)) : Un `Transformer2DModel` condicionado por texto para desruidar los latentes de imagen codificados.

scheduler ([SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

Pipeline para la generación de imágenes a partir de texto usando Lumina-T2I.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la ejecución en un 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'])
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/lumina/pipeline_lumina.py#L631)

**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 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`).

num_inference_steps (`int`, *opcional*, valor predeterminado 30) : 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.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento `sigmas` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`.

guidance_scale (`float`, *opcional*, valor predeterminado 4.0) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de orientación se habilita estableciendo `guidance_scale > 1`. Una escala de orientación 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_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación.

height (`int`, *opcional*, valor predeterminado: self.unet.config.sample_size) : La altura en píxeles de la imagen generada.

width (`int`, *opcional*, predeterminado a self.unet.config.sample_size) : El ancho en píxeles de la imagen generada.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) 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.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Para Lumina-T2I, 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.Tensor`, *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](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.

return_dict (`bool`, *opcional*, por defecto `True`) : Si se devuelve un `~pipelines.stable_diffusion.IFPipelineOutput` en lugar de una tupla simple.

clean_caption (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe limpiar la descripción antes de crear los embeddings. Requiere que `beautifulsoup4` y `ftfy` estén instalados. Si las dependencias no están instaladas, los embeddings se crearán a partir del prompt sin procesar.

max_sequence_length (`int` por defecto 120) : Longitud máxima de la secuencia a utilizar con el `prompt`.

scaling_watershed (`float`, *opcional*, valor predeterminado 1.0) : Umbral de escalado de resolución utilizado por Lumina para cambiar entre la atención de contexto estándar y la de contexto extendido.

proportional_attn (`bool`, *opcional*, predeterminado en True) : Si se debe escalar la atención proporcionalmente para la generación de alta resolución.

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.

**Devuelve:** [ImagePipelineOutput](/docs/diffusers/main/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) o `tuple`

Si `return_dict` es `True`, se devuelve [ImagePipelineOutput](/docs/diffusers/main/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput); 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:
```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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/lumina/pipeline_lumina.py#L261)

**Parámetros:**

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

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt que no debe 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`). Para Lumina-T2I, esto debería ser "".

do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : si se debe usar classifier free guidance o no

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : número de imágenes que deben generarse por indicación

device : (`torch.device`, *opcional*): 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 negativo pregenerados. Para Lumina-T2I, deben ser los embeddings de la cadena "".

clean_caption (`bool`, por defecto `False`) : Si `True`, la función preprocesará y limpiará la descripción proporcionada antes de codificarla.

max_sequence_length (`int`, por defecto 256) : Longitud máxima de la secuencia a utilizar para el prompt.

Codifica el prompt en estados ocultos del codificador de texto.