# Flux2

  
  

Flux.2 es la serie reciente de modelos de generación de imágenes de Black Forest Labs, precedida por la serie [Flux.1](./flux). Es un modelo completamente nuevo con una nueva arquitectura y un preentrenamiento realizado desde cero.

Los puntos de control originales del modelo Flux se pueden encontrar [aquí](https://huggingface.co/black-forest-labs). El código de inferencia original se puede encontrar [aquí](https://github.com/black-forest-labs/flux2).

> [!TIP]
> Flux2 puede resultar bastante costoso de ejecutar en dispositivos de hardware de consumo. Sin embargo, puedes aplicar una serie de optimizaciones para ejecutarlo más rápido y de una manera más eficiente en memoria. Consulta [esta sección](https://huggingface.co/blog/sd3#memory-optimizations-for-sd3) para obtener más detalles. Además, Flux puede beneficiarse de la cuantización para mejorar la eficiencia de memoria, a cambio de un aumento en la latencia de inferencia. Consulta [esta publicación de blog](https://huggingface.co/blog/quanto-diffusers) para saber más.
>
> [La caché](../../optimization/cache) también puede acelerar la inferencia almacenando y reutilizando salidas intermedias.

## Ampliación de la resolución de las descripciones

Flux.2 puede generar salidas de mejor calidad con mejores prompts. Podemos "ampliar" un prompt de entrada estableciendo el argumento `caption_upsample_temperature` en los argumentos de la llamada a la pipeline. La [implementación oficial](https://github.com/black-forest-labs/flux2/blob/5a5d316b1b42f6b59a8c9194b77c8256be848432/src/flux2/text_encoder.py#L140) recomienda que este valor sea 0.15.

## Flux2Pipeline[[diffusers.Flux2Pipeline]]

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

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

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

**Parámetros:**

transformer ([Flux2Transformer2DModel](/docs/diffusers/v0.43.0/es/api/models/flux2_transformer#diffusers.Flux2Transformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

vae (`AutoencoderKLFlux2`) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar imágenes a partir de y hacia representaciones latentes.

text_encoder (`Mistral3ForConditionalGeneration`) : [Mistral3ForConditionalGeneration](https://huggingface.co/docs/transformers/en/model_doc/mistral3#transformers.Mistral3ForConditionalGeneration)

tokenizer (`AutoProcessor`) : Tokenizador de la clase [PixtralProcessor](https://huggingface.co/docs/transformers/en/model_doc/pixtral#transformers.PixtralProcessor).

El pipeline Flux2 para la generación de imágenes a partir de texto.

Referencia: [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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/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]` o `list[np.ndarray]`) : `Image`, array de numpy o tensor que representa un lote de imágenes para usarse como punto de partida. Tanto para arrays de numpy como para tensors de PyTorch, el rango de valores esperado está entre `[0, 1]`. Si es un tensor o una lista de tensors, la forma esperada debe ser `(B, C, H, W)` o `(C, H, W)`. Si es un array de numpy o una lista de arrays, la forma esperada debe ser `(B, H, W, C)` o `(H, W, C)`. También puede aceptar latentes de imagen como `image`, pero si se pasan latentes directamente, no se vuelven a codificar.

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.

guidance_scale (`float`, *opcional*, valor predeterminado 1.0) : La escala de guianza integrada se habilita estableciendo `guidance_scale` > 1. Un `guidance_scale` más alto anima al modelo a generar imágenes más alineadas con `prompt` a costa de una menor calidad de imagen. Los modelos destilados de guianza aproximan la verdadera guianza libre de clasificador para `guidance_scale` > 1. Consulte el [artículo](https://huggingface.co/papers/2210.03142) para obtener más información.

height (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : La altura en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.

width (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.

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

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación.

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

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*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.qwenimage.QwenImagePipelineOutput` en lugar de una tupla simple.

attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define 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.

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

text_encoder_out_layers (`tuple[int]`) : Índices de capas a utilizar en el `text_encoder` para derivar las incrustaciones finales del prompt.

caption_upsample_temperature (`float`) : Cuando se especifica, intentaremos realizar un aumento de muestreo de la descripción para obtener posibles mejoras en las salidas. Recomendamos establecerlo en 0.15 si se va a realizar un aumento de muestreo de la descripción.

**Devuelve:** `~pipelines.flux2.Flux2PipelineOutput` o `tuple`

`~pipelines.flux2.Flux2PipelineOutput` si `return_dict` es True, de lo contrario una `tuple`. Al devolver una tupla, el 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 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)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/flux2/pipeline_flux2_klein.py#L155)

**Parámetros:**

transformer ([Flux2Transformer2DModel](/docs/diffusers/v0.43.0/es/api/models/flux2_transformer#diffusers.Flux2Transformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

vae (`AutoencoderKLFlux2`) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar imágenes a partir de y hacia representaciones latentes.

text_encoder (`Qwen3ForCausalLM`) : [Qwen3ForCausalLM](https://huggingface.co/docs/transformers/en/model_doc/qwen3#transformers.Qwen3ForCausalLM)

tokenizer (`Qwen2TokenizerFast`) : Tokenizador de la clase [Qwen2TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2TokenizerFast).

El pipeline Flux2 Klein para la generación de imágenes a partir de texto.

Referencia: [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))
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/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]` o `List[np.ndarray]`) : `Image`, array de numpy o tensor que representa un lote de imágenes para usarse como punto de partida. Tanto para arrays de numpy como para tensors de PyTorch, el rango de valores esperado está entre `[0, 1]`. Si es un tensor o una lista de tensors, la forma esperada debe ser `(B, C, H, W)` o `(C, H, W)`. Si es un array de numpy o una lista de arrays, la forma esperada debe ser `(B, H, W, C)` o `(H, W, C)`. También puede aceptar latentes de imagen como `image`, pero si se pasan latentes directamente, no se vuelven a codificar.

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.

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. Para los modelos destilados paso a paso, `guidance_scale` se ignora.

height (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : La altura en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.

width (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.

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

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación.

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

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pregenerados. Tenga en cuenta que "" se utiliza como el prompt negativo en este pipeline. Si no se proporciona, se generará a partir de "".

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*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.qwenimage.QwenImagePipelineOutput` en lugar de una tupla simple.

attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define 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.

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

text_encoder_out_layers (`tuple[int]`) : Índices de capas a utilizar en el `text_encoder` para derivar las incrustaciones finales del prompt.

**Devuelve:** `~pipelines.flux2.Flux2PipelineOutput` o `tuple`

`~pipelines.flux2.Flux2PipelineOutput` si `return_dict` es True, de lo contrario una `tuple`. Al devolver una tupla, el 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 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)
```

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

**Parámetros:**

transformer ([Flux2Transformer2DModel](/docs/diffusers/v0.43.0/es/api/models/flux2_transformer#diffusers.Flux2Transformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

vae (`AutoencoderKLFlux2`) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar imágenes a partir de y hacia representaciones latentes.

text_encoder (`Qwen3ForCausalLM`) : [Qwen3ForCausalLM](https://huggingface.co/docs/transformers/en/model_doc/qwen3#transformers.Qwen3ForCausalLM)

tokenizer (`Qwen2TokenizerFast`) : Tokenizador de la clase [Qwen2TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2TokenizerFast).

El pipeline Flux2 Klein KV para la generación de imágenes a partir de texto con condicionamiento de imagen de referencia mediante caché de KV.

En el primer paso de desruido, los tokens de la imagen de referencia se incluyen en la pasada hacia adelante y sus proyecciones K/V de atención se almacenan en caché. En los pasos posteriores, las K/V en caché se reutilizan sin recalcular, lo que proporciona una inferencia más rápida al usar imágenes de referencia.

Referencia: [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))
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/flux2/pipeline_flux2_klein_kv.py#L610)

**Parámetros:**

image (`PIL.Image.Image` o `List[PIL.Image.Image]`, *opcional*) : Imagen(es) de referencia para el condicionamiento. En el primer paso de desruido, los tokens de referencia se incluyen en el paso hacia adelante y sus K/V de atención se almacenan en caché. En los pasos posteriores, los K/V en caché se reutilizan sin recalcularlos.

prompt (`str` o `List[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen.

height (`int`, *opcional*) : La altura en píxeles de la imagen generada.

width (`int`, *opcional*) : El ancho en píxeles de la imagen generada.

num_inference_steps (`int`, *opcional*, valor predeterminado 4) : El número de pasos de desruido.

sigmas (`List[float]`, *opcional*) : Sigmas personalizados para el programa de desruido.

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación.

generator (`torch.Generator` o `List[torch.Generator]`, *opcional*) : Generador(es) para la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados.

output_type (`str`, *opcional*, por defecto `"pil"`) : Formato de salida: `"pil"` o `"np"`.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Si se debe devolver un `Flux2PipelineOutput` o una tupla simple.

attention_kwargs (`dict`, *opcional*) : Kwargs adicionales pasados a los procesadores de atención.

callback_on_step_end (`Callable`, *opcional*) : Función de devolución de llamada que se ejecuta al final de cada paso de desruido.

callback_on_step_end_tensor_inputs (`List`, *opcional*) : Entradas de Tensor para la función de callback.

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

text_encoder_out_layers (`tuple[int]`) : Índices de capas para la extracción del estado oculto del codificador de texto.

**Devuelve:**

`~pipelines.flux2.Flux2PipelineOutput` o `tuple`.

Función invocada al llamar a la pipeline para la generación.

Ejemplos:
```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")
```