Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /pt /api /pipelines /flux2.md
mishig
3 days ago
preview code
download
raw
24.4 kB
# Flux2

  
  

Flux.2 é a série recente de modelos de geração de imagens da Black Forest Labs, antecedido pela série [Flux.1](./flux). Trata-se de um modelo totalmente novo, com uma nova arquitetura e pré-treinamento realizado do zero!

Os checkpoints originais do modelo Flux podem ser encontrados [aqui](https://huggingface.co/black-forest-labs). O código de inferência original pode ser encontrado [aqui](https://github.com/black-forest-labs/flux2).

> [!TIP]
> Flux2 pode ser bastante caro de executar em dispositivos de hardware de consumo. No entanto, você pode realizar uma série de otimizações para executá-lo mais rápido e de uma forma mais amigável à memória. Consulte [esta seção](https://huggingface.co/blog/sd3#memory-optimizations-for-sd3) para mais detalhes. Além disso, o Flux pode se beneficiar da quantização para eficiência de memória, com um compromisso em relação à latência de inferência. Consulte [este post de blog](https://huggingface.co/blog/quanto-diffusers) para saber mais.
>
> [Caching](../../optimization/cache) também pode acelerar a inferência ao armazenar e reutilizar saídas intermediárias.

## Ampliação de resolução de legendas

Flux.2 pode potencialmente gerar saídas melhores com prompts melhores. Podemos "ampliar" um prompt de entrada definindo o argumento `caption_upsample_temperature` nos argumentos da chamada do pipeline. A [implementação oficial](https://github.com/black-forest-labs/flux2/blob/5a5d316b1b42f6b59a8c9194b77c8256be848432/src/flux2/text_encoder.py#L140) recomenda que esse valor seja 0,15.

## Flux2Pipeline[[diffusers.Flux2Pipeline]]

#### diffusers.Flux2Pipeline[[diffusers.Flux2Pipeline]]

```python
diffusers.Flux2Pipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLFlux2, text_encoder: Mistral3ForConditionalGeneration, tokenizer: AutoProcessor, transformer: Flux2Transformer2DModel)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux2/pipeline_flux2.py#L251)

**Parâmetros:**

transformer ([Flux2Transformer2DModel](/docs/diffusers/main/pt/api/models/flux2_transformer#diffusers.Flux2Transformer2DModel)) : Arquitetura de Transformer condicional (MMDiT) para desruidar os latentes da imagem codificada.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.

vae (`AutoencoderKLFlux2`) : Modelo de Autoencoder Variacional (VAE) para codificar e decodificar imagens para e a partir de representações latentes.

text_encoder (`Mistral3ForConditionalGeneration`) : [Mistral3ForConditionalGeneration](https://huggingface.co/docs/transformers/en/model_doc/mistral3#transformers.Mistral3ForConditionalGeneration)
tokenizer (`AutoProcessor`) : Tokenizador da classe [PixtralProcessor](https://huggingface.co/docs/transformers/en/model_doc/pixtral#transformers.PixtralProcessor).
O pipeline Flux2 para geração de imagens a partir de texto.
Referência: [https://bfl.ai/blog/flux-2](https://bfl.ai/blog/flux-2)
#### __call__[[diffusers.Flux2Pipeline.__call__]]
```python
__call__(image: PIL.Image.Image | list[PIL.Image.Image] | None = None, prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float | None = 4.0, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: 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'], max_sequence_length: int = 512, text_encoder_out_layers: tuple[int] = (10, 20, 30), caption_upsample_temperature: float = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux2/pipeline_flux2.py#L746)
**Parâmetros:**
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image`, array numpy ou tensor representando um lote de imagens a ser usado como ponto de partida. Para arrays numpy e tensors pytorch, o intervalo de valores esperado é entre `[0, 1]` Se for um tensor ou uma lista de tensors, a forma esperada deve ser `(B, C, H, W)` ou `(C, H, W)`. Se for um array numpy ou uma lista de arrays, a forma esperada deve ser `(B, H, W, C)` ou `(H, W, C)` Também pode aceitar latentes de imagem como `image`, mas, se latentes forem passados diretamente, eles não são codificados novamente.
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.
guidance_scale (`float`, *opcional*, padrão 1.0) : A escala de orientação incorporada é ativada ao definir `guidance_scale` > 1. Um `guidance_scale` maior incentiva o modelo a gerar imagens mais alinhadas com o `prompt`, em detrimento de uma menor qualidade de imagem. Modelos destilados por orientação aproximam a verdadeira orientação sem classificador para `guidance_scale` > 1. Consulte o [artigo](https://huggingface.co/papers/2210.03142) para saber mais.
height (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A altura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados.
width (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A largura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados.
num_inference_steps (`int`, *opcional*, padrão 50) : O número de etapas de desruidamento. Mais etapas de desruidamento geralmente resultam em uma imagem de maior qualidade, em detrimento 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.
num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt.
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`.
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.qwenimage.QwenImagePipelineOutput` em vez de uma tupla simples.
attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme 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.
max_sequence_length (`int` padrão é 512) : Comprimento máximo da sequência a ser usado com o `prompt`.
text_encoder_out_layers (`tuple[int]`) : Índices das camadas a serem usadas no `text_encoder` para derivar os embeddings finais do prompt.
caption_upsample_temperature (`float`) : Quando especificado, tentaremos realizar o upsampling de legendas para possíveis melhorias nas saídas. Recomendamos definir o valor como 0.15 caso o upsampling de legendas seja realizado.
**Retorna:** `~pipelines.flux2.Flux2PipelineOutput` ou `tuple`
`~pipelines.flux2.Flux2PipelineOutput` se `return_dict` for True, caso contrário, uma `tuple`. Ao retornar uma tupla, 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 Flux2Pipeline

>>> pipe = Flux2Pipeline.from_pretrained("black-forest-labs/FLUX.2-dev", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "A cat holding a sign that says hello world"
>>> # Depending on the variant being used, the pipeline call will slightly vary.
>>> # Refer to the pipeline documentation for more details.
>>> image = pipe(prompt, num_inference_steps=50, guidance_scale=2.5).images[0]
>>> image.save("flux.png")
```
## Flux2KleinPipeline[[diffusers.Flux2KleinPipeline]]
#### diffusers.Flux2KleinPipeline[[diffusers.Flux2KleinPipeline]]
```python
diffusers.Flux2KleinPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLFlux2, text_encoder: Qwen3ForCausalLM, tokenizer: Qwen2Tokenizer, transformer: Flux2Transformer2DModel, is_distilled: bool = False)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux2/pipeline_flux2_klein.py#L155)
**Parâmetros:**
transformer ([Flux2Transformer2DModel](/docs/diffusers/main/pt/api/models/flux2_transformer#diffusers.Flux2Transformer2DModel)) : Arquitetura de Transformer condicional (MMDiT) para desruidar os latentes da imagem codificada.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.
vae (`AutoencoderKLFlux2`) : Modelo de Autoencoder Variacional (VAE) para codificar e decodificar imagens para e a partir de representações latentes.
text_encoder (`Qwen3ForCausalLM`) : [Qwen3ForCausalLM](https://huggingface.co/docs/transformers/en/model_doc/qwen3#transformers.Qwen3ForCausalLM)

tokenizer (`Qwen2TokenizerFast`) : Tokenizer da classe [Qwen2TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2TokenizerFast).

O pipeline Flux2 Klein para geração de imagens a partir de texto.

Referência: [https://bfl.ai/blog/flux2-klein-towards-interactive-visual-intelligence](https://bfl.ai/blog/flux2-klein-towards-interactive-visual-intelligence)

#### __call__[[diffusers.Flux2KleinPipeline.__call__]]

```python
__call__(image: list[PIL.Image.Image] | PIL.Image.Image | None = None, prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float = 4.0, num_images_per_prompt: int = 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: str | list[str] | None = None, output_type: str = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int, dict], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, text_encoder_out_layers: tuple[int] = (9, 18, 27))
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux2/pipeline_flux2_klein.py#L614)

**Parâmetros:**

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `List[torch.Tensor]`, `List[PIL.Image.Image]` ou `List[np.ndarray]`) : `Image`, array numpy ou tensor representando um lote de imagens a ser usado como ponto de partida. Para arrays numpy e tensors pytorch, o intervalo de valores esperado é entre `[0, 1]` Se for um tensor ou uma lista de tensors, a forma esperada deve ser `(B, C, H, W)` ou `(C, H, W)`. Se for um array numpy ou uma lista de arrays, a forma esperada deve ser `(B, H, W, C)` ou `(H, W, C)` Também pode aceitar latentes de imagem como `image`, mas, se latentes forem passados diretamente, eles não são codificados novamente.

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.

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. Para modelos destilados passo a passo, `guidance_scale` é ignorado.

height (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A altura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados.
width (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A largura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados.

num_inference_steps (`int`, *opcional*, padrão 50) : O número de etapas de desruidamento. Mais etapas de desruidamento geralmente resultam em uma imagem de maior qualidade, em detrimento 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.

num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt.
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`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Observe que "" é usado como o prompt negativo neste pipeline. Se não for fornecido, será gerado a partir de "".

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.qwenimage.QwenImagePipelineOutput` em vez de uma tupla simples.

attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme 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.

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

text_encoder_out_layers (`tuple[int]`) : Índices das camadas a serem usadas no `text_encoder` para derivar os embeddings finais do prompt.

**Retorna:** `~pipelines.flux2.Flux2PipelineOutput` ou `tuple`

`~pipelines.flux2.Flux2PipelineOutput` se `return_dict` for True, caso contrário, uma `tuple`. Ao retornar uma tupla, 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 Flux2KleinPipeline
>>> pipe = Flux2KleinPipeline.from_pretrained(
...     "black-forest-labs/FLUX.2-klein-base-9B", torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")
>>> prompt = "A cat holding a sign that says hello world"
>>> # Depending on the variant being used, the pipeline call will slightly vary.
>>> # Refer to the pipeline documentation for more details.
>>> image = pipe(prompt, num_inference_steps=50, guidance_scale=4.0).images[0]
>>> image.save("flux2_output.png")
```

## Flux2KleinKVPipeline[[diffusers.Flux2KleinKVPipeline]]

#### diffusers.Flux2KleinKVPipeline[[diffusers.Flux2KleinKVPipeline]]

```python
diffusers.Flux2KleinKVPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLFlux2, text_encoder: Qwen3ForCausalLM, tokenizer: Qwen2Tokenizer, transformer: Flux2Transformer2DModel, is_distilled: bool = True)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux2/pipeline_flux2_klein_kv.py#L155)

**Parâmetros:**

transformer ([Flux2Transformer2DModel](/docs/diffusers/main/pt/api/models/flux2_transformer#diffusers.Flux2Transformer2DModel)) : Arquitetura de Transformer condicional (MMDiT) para desruidar os latentes da imagem codificada.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.

vae (`AutoencoderKLFlux2`) : Modelo de Autoencoder Variacional (VAE) para codificar e decodificar imagens para e a partir de representações latentes.

text_encoder (`Qwen3ForCausalLM`) : [Qwen3ForCausalLM](https://huggingface.co/docs/transformers/en/model_doc/qwen3#transformers.Qwen3ForCausalLM)
tokenizer (`Qwen2TokenizerFast`) : Tokenizer da classe [Qwen2TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2TokenizerFast).
O pipeline Flux2 Klein KV para geração de texto para imagem com condicionamento de imagem de referência com cache de KV.
No primeiro passo de remoção de ruído, os tokens da imagem de referência são incluídos no passo de propagação direta e as projeções K/V de atenção deles são armazenadas em cache. Nos passos subsequentes, o cache K/V é reutilizado sem recálculo, proporcionando inferência mais rápida ao usar imagens de referência.
Referência: [https://bfl.ai/blog/flux2-klein-towards-interactive-visual-intelligence](https://bfl.ai/blog/flux2-klein-towards-interactive-visual-intelligence)
#### __call__[[diffusers.Flux2KleinKVPipeline.__call__]]
```python
__call__(image: list[PIL.Image.Image] | PIL.Image.Image | None = None, prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 4, sigmas: list[float] | None = None, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int, dict], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, text_encoder_out_layers: tuple[int] = (9, 18, 27))
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux2/pipeline_flux2_klein_kv.py#L610)
**Parâmetros:**
image (`PIL.Image.Image` ou `List[PIL.Image.Image]`, *opcional*) : Imagem(ns) de referência para condicionamento. No primeiro passo de desruidamento, os tokens de referência são incluídos no passo de frente e seus K/V de atenção são armazenados em cache. Nos passos subsequentes, os K/V em cache são reutilizados sem recálculo.
prompt (`str` ou `List[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem.
height (`int`, *opcional*) : A altura em pixels da imagem gerada.
width (`int`, *opcional*) : A largura em pixels da imagem gerada.
num_inference_steps (`int`, *opcional*, padrão 4) : O número de etapas de desruidamento.
sigmas (`List[float]`, *opcional*) : Sigmas personalizados para o agendamento de desruidamento.
num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt.

generator (`torch.Generator` ou `List[torch.Generator]`, *opcional*) : Gerador(es) para geração determinística.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados.
output_type (`str`, *opcional*, padrão `"pil"`) : Formato de saída: `"pil"` ou `"np"`.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve retornar um `Flux2PipelineOutput` ou uma tupla simples.
attention_kwargs (`dict`, *opcional*) : Kwargs extras passados aos processadores de atenção.

callback_on_step_end (`Callable`, *opcional*) : Função de callback chamada no final de cada etapa de desruidamento.
callback_on_step_end_tensor_inputs (`List`, *opcional*) : Entradas de Tensor para a função de callback.

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

text_encoder_out_layers (`tuple[int]`) : Índices de camadas para extração do estado oculto do codificador de texto.
**Retorna:**
`~pipelines.flux2.Flux2PipelineOutput` ou `tuple`.
Função invocada ao chamar o pipeline para geração.
Exemplos:
```py
>>> import torch
>>> from PIL import Image
>>> from diffusers import Flux2KleinKVPipeline
>>> pipe = Flux2KleinKVPipeline.from_pretrained(
...     "black-forest-labs/FLUX.2-klein-9b-kv", torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")
>>> ref_image = Image.open("reference.png")
>>> image = pipe("A cat dressed like a wizard", image=ref_image, num_inference_steps=4).images[0]
>>> image.save("flux2_kv_output.png")
```
Xet Storage Details

Size:: 24.4 kB
Xet hash:: bbe2ca0e6f015b18f68828f53a5a51275d5856223cd62cce1c89e78a7a6cf662
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.