#
# 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. -->

# Lumina2

  

[Lumina Image 2.0: A Unified and Efficient Image Generative Model](https://huggingface.co/Alpha-VLLM/Lumina-Image-2.0) es un transformer de difusión basado en flujos con 2 mil millones de parámetros capaz de generar imágenes diversas a partir de descripciones de texto.

El resumen del artículo es:

*Presentamos Lumina-Image 2.0, un modelo avanzado de texto a imagen que supera a los métodos de vanguardia anteriores en múltiples benchmarks, al tiempo que arroja luz sobre su potencial para evolucionar hacia un modelo de inteligencia visual generalista. Lumina-Image 2.0 exhibe tres propiedades clave: (1) Unificación – adopta una arquitectura unificada que trata los tokens de texto e imagen como una secuencia conjunta, lo que permite interacciones naturales entre modalidades y facilita la expansión de tareas. Además, dado que los captioners de alta calidad pueden proporcionar pares de entrenamiento texto-imagen con una alineación semántica superior, introducimos un sistema de captioning unificado, UniCaptioner, que genera descripciones completas y precisas para el modelo. Esto no solo acelera la convergencia del modelo, sino que también mejora la adherencia al prompt, el manejo de prompts de longitud variable y la generalización de tareas mediante plantillas de prompt. (2) Eficiencia – para mejorar la eficiencia de la arquitectura unificada, desarrollamos un conjunto de técnicas de optimización que mejoran el aprendizaje semántico y la generación de texturas de grano fino durante el entrenamiento, al tiempo que incorporamos estrategias de aceleración en tiempo de inferencia sin comprometer la calidad de la imagen. (3) Transparencia – publicamos en código abierto todos los detalles de entrenamiento, el código y los modelos para garantizar una reproducibilidad total, con el objetivo de cerrar la brecha entre los equipos de investigación con recursos abundantes y de código cerrado y los desarrolladores independientes.*

> [!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.

## Uso de la carga de archivo único con Lumina Image 2.0

La carga de un solo archivo para Lumina Image 2.0 está disponible para `Lumina2Transformer2DModel`

```python
import torch
from diffusers import Lumina2Transformer2DModel, Lumina2Pipeline

ckpt_path = "https://huggingface.co/Alpha-VLLM/Lumina-Image-2.0/blob/main/consolidated.00-of-01.pth"
transformer = Lumina2Transformer2DModel.from_single_file(
    ckpt_path, dtype=torch.bfloat16
)

pipe = Lumina2Pipeline.from_pretrained(
    "Alpha-VLLM/Lumina-Image-2.0", transformer=transformer, dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()
image = pipe(
    "a cat holding a sign that says hello",
    generator=torch.Generator("cpu").manual_seed(0),
).images[0]
image.save("lumina-single-file.png")

```

## Uso de puntos de control cuantizados GGUF con Lumina Image 2.0

Los puntos de control cuantizados en GGUF para el `Lumina2Transformer2DModel` se pueden cargar mediante `from_single_file` con la `GGUFQuantizationConfig`

```python
from diffusers import Lumina2Transformer2DModel, Lumina2Pipeline, GGUFQuantizationConfig 

ckpt_path = "https://huggingface.co/calcuis/lumina-gguf/blob/main/lumina2-q4_0.gguf"
transformer = Lumina2Transformer2DModel.from_single_file(
    ckpt_path,
    quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
    dtype=torch.bfloat16,
)

pipe = Lumina2Pipeline.from_pretrained(
    "Alpha-VLLM/Lumina-Image-2.0", transformer=transformer, dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()
image = pipe(
    "a cat holding a sign that says hello",
    generator=torch.Generator("cpu").manual_seed(0),
).images[0]
image.save("lumina-gguf.png")
```

## Lumina2Pipeline[[diffusers.Lumina2Pipeline]]

#### diffusers.Lumina2Pipeline[[diffusers.Lumina2Pipeline]]

```python
diffusers.Lumina2Pipeline(transformer: Lumina2Transformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: Gemma2PreTrainedModel, tokenizer: GemmaTokenizer)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/lumina2/pipeline_lumina2.py#L136)

**Parámetros:**

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/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 (`Gemma2PreTrainedModel`) : Codificador de texto Gemma2 congelado.

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

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

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/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/v0.43.0/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.Lumina2Pipeline.__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, 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'], system_prompt: str | None = None, cfg_trunc_ratio: float = 1.0, cfg_normalization: bool = True, max_sequence_length: int = 256)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/lumina2/pipeline_lumina2.py#L470)

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

attention_kwargs : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` definido bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

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.

system_prompt (`str`, *opcional*) : El prompt de sistema a utilizar para la generación de imágenes.

cfg_trunc_ratio (`float`, *opcional*, valor predeterminado `1.0`) : La proporción del intervalo de paso de tiempo para aplicar la escala de guía basada en normalización.

cfg_normalization (`bool`, *opcional*, valor predeterminado `True`) : Si se aplica la escala de orientación basada en normalización.

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

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

Si `return_dict` es `True`, se devuelve [ImagePipelineOutput](/docs/diffusers/v0.43.0/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 Lumina2Pipeline

>>> pipe = Lumina2Pipeline.from_pretrained("Alpha-VLLM/Lumina-Image-2.0", 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.Lumina2Pipeline.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, system_prompt: str | None = None, max_sequence_length: int = 256)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/lumina2/pipeline_lumina2.py#L237)

**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 "".

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.