Buckets:

mishig's picture
|
download
raw
15.5 kB
#
# Licenciado sob a Apache License, Versão 2.0 (a "Licença");
# você não pode usar este arquivo, exceto em conformidade com a Licença.
# Você pode obter uma cópia da Licença em
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# A menos que exigido pela lei aplicável ou acordado por escrito, o software
# distribuído sob a Licença é distribuído em uma base "COMO ESTÁ",
# SEM GARANTIAS OU CONDIÇÕES DE QUALQUER TIPO, expressas ou implícitas.
# Consulte a Licença para o idioma específico que rege as permissões e
# limitações sob a Licença. -->
# Lumina2
[Lumina Image 2.0: A Unified and Efficient Image Generative Model](https://huggingface.co/Alpha-VLLM/Lumina-Image-2.0) é um transformer de difusão baseado em fluxo com 2 bilhões de parâmetros, capaz de gerar imagens diversas a partir de descrições em texto.
O resumo do artigo é:
*Apresentamos o Lumina-Image 2.0, um modelo avançado de texto para imagem que supera os métodos state-of-the-art anteriores em múltiplos benchmarks, ao mesmo tempo em que destaca seu potencial para evoluir para um modelo de inteligência visual generalista. O Lumina-Image 2.0 exibe três propriedades-chave: (1) Unificação – adota uma arquitetura unificada que trata tokens de texto e imagem como uma sequência conjunta, permitindo interações cross-modais naturais e facilitando a expansão de tarefas. Além disso, como captioners de alta qualidade podem fornecer pares de treinamento texto-imagem semanticamente mais alinhados, introduzimos um sistema de legendagem unificado, o UniCaptioner, que gera legendas abrangentes e precisas para o modelo. Isso não apenas acelera a convergência do modelo, mas também melhora a aderência ao prompt, o tratamento de prompts de comprimento variável e a generalização de tarefas por meio de templates de prompt. (2) Eficiência – para melhorar a eficiência da arquitetura unificada, desenvolvemos um conjunto de técnicas de otimização que aprimoram a aprendizagem semântica e a geração de texturas de alto detalhe durante o treinamento, ao mesmo tempo em que incorporam estratégias de aceleração no tempo de inferência sem comprometer a qualidade da imagem. (3) Transparência – disponibilizamos em código aberto todos os detalhes de treinamento, o código e os modelos para garantir reprodutibilidade total, com o objetivo de reduzir a lacuna entre equipes de pesquisa fechadas com muitos recursos e desenvolvedores independentes.*
> [!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.
## Usando carregamento de arquivo único com Lumina Image 2.0
O carregamento em arquivo único para Lumina Image 2.0 está disponível para o `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")
```
## Usando checkpoints quantizados GGUF com Lumina Image 2.0
Os checkpoints quantizados em GGUF para o `Lumina2Transformer2DModel` podem ser carregados via `from_single_file` com o `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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/lumina2/pipeline_lumina2.py#L136)
**Parâmetros:**
vae ([AutoencoderKL](/docs/diffusers/main/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 (`Gemma2PreTrainedModel`) : Codificador de texto Gemma2 congelado.
tokenizer (`GemmaTokenizer` ou `GemmaTokenizerFast`) : Tokenizador Gemma.
transformer ([Transformer2DModel](/docs/diffusers/main/pt/api/models/transformer2d#diffusers.Transformer2DModel)) : Um `Transformer2DModel` condicionado por texto para desruidar os latentes da imagem codificada.
scheduler ([SchedulerMixin](/docs/diffusers/main/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/main/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.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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/lumina2/pipeline_lumina2.py#L470)
**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.
attention_kwargs : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` definido em `self.processor` em [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
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.
system_prompt (`str`, *opcional*) : O prompt de sistema a ser usado para a geração de imagem.
cfg_trunc_ratio (`float`, *opcional*, padrão `1.0`) : A proporção do intervalo de timestep para aplicar a escala de orientação baseada em normalização.
cfg_normalization (`bool`, *opcional*, padrão `True`) : Se deve aplicar a escala de orientação baseada em normalização.
max_sequence_length (`int`, padrão `256`) : Comprimento máximo da sequência a ser usado com o `prompt`.
**Retorna:** [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple`
Se `return_dict` for `True`, [ImagePipelineOutput](/docs/diffusers/main/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 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/lumina2/pipeline_lumina2.py#L237)
**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 "".
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.

Xet Storage Details

Size:
15.5 kB
·
Xet hash:
71ce975e30d958be10c96225dca1fd2dbbf0c50682b457910f1f58cd137a0dab

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.