Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /es /api /pipelines /flux3.md
mishig
about 4 hours ago
preview code
download
raw
27.5 kB
#
# 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. -->

# FLUX 3 Image Klein

FLUX 3 Image Klein es un modelo de generación de imágenes de 5.6B de Black Forest Labs: un único transformador ([Flux3Transformer2DModel](/docs/diffusers/main/es/api/models/flux3_transformer#diffusers.Flux3Transformer2DModel)) genera imágenes a partir de un prompt de texto, solo o junto con una o más imágenes de referencia. La condicionación de texto proviene de Qwen3-VL, y las imágenes utilizan el autoencoder empaquetado de FLUX.2 (`AutoencoderKLFlux2`).

FLUX 3 Image Klein se distribuye como un [pipeline modular](../../modular_diffusers/overview). Comienza con una generación de imagen a partir de texto:

```python
import torch
from diffusers import ModularPipeline
pipe = ModularPipeline.from_pretrained("black-forest-labs/flux-3-image-klein-base")
pipe.load_components(dtype={"vae": torch.float32, "default": torch.bfloat16})
pipe.to("cuda")
image = pipe(
    prompt="A red fox in a snow-covered forest clearing at golden hour",
    generator=torch.Generator().manual_seed(0),
    output="images",
)[0]
image.save("fox.png")
```

`prompt` es la única entrada obligatoria: el pipeline aplica la configuración de muestreo recomendada (50 pasos, escala de guía 3.5, desplazamiento del programador 6.93) y genera imágenes de 1024 x 1024 píxeles de forma predeterminada. Acepta un solo prompt por llamada; use `num_images_per_prompt` para generar varias imágenes a partir del mismo prompt.

Como puede ver en el ejemplo anterior, la carga y la ejecución difieren un poco de un `DiffusionPipeline`. La carga es perezosa: [from_pretrained()](/docs/diffusers/main/es/api/modular_diffusers/pipeline#diffusers.ModularPipeline.from_pretrained) solo construye el pipeline, y llama a [load_components()](/docs/diffusers/main/es/api/modular_diffusers/pipeline#diffusers.ModularPipeline.load_components) para cargar los pesos. Una llamada devuelve el estado del pipeline, y solicita lo que necesita con `output`: `output="images"` aquí, o `output=["images", "prompt"]` para obtener también la descripción que escribió el amplificador de prompts.

> [!TIP]
> Si estás trabajando con `ModularPipeline` por primera vez, lee el [quickstart](../../modular_diffusers/quickstart) y [Coming from DiffusionPipeline](../../modular_diffusers/coming_from_diffusion_pipeline) si conoces las pipelines estándar. Además de la carga y las salidas, hay algunas otras diferencias: [guidance](#guidance-scale), [callbacks](#per-step-callbacks) y [offloading](#memory).

## Ampliación de prompts

Prompting matters: FLUX 3 Image Klein takes full scene captions that describe the subject, composition, lighting, and atmosphere, not short prompts; a request sent as typed gives generic output. That is why the pipeline runs the prompt upsampler first on every request, text-to-image and editing alike. It is a separate 9B model from Black Forest Labs ([black-forest-labs/flux-3-image-klein-pup](https://huggingface.co/black-forest-labs/flux-3-image-klein-pup)) that expands `prompt` into such a caption before the text encoder, and a short prompt is all it takes.

El amplificador de prompts convierte una solicitud breve, junto con las imágenes de referencia en caso de edición, en la descripción completa de la escena que recibe el modelo: medio y estilo, escena, iluminación y cámara, cada sujeto con sus colores, materiales y posición en el encuadre. Un solo modelo cubre texto a imagen, edición con imágenes de referencia y diseño con cajas. La descripción que genera se devuelve como salida de `prompt`. En el ejemplo anterior, solicítela junto con las imágenes para ver lo que recibió el modelo de imagen:

```python
out = pipe(
    prompt="A red fox in a snow-covered forest clearing at golden hour",
    generator=torch.Generator().manual_seed(0),
    output=["images", "prompt"],
)
print(out["prompt"])
```

```
Full-color outdoor wildlife photograph taken from a low eye-level perspective in a snow-covered forest clearing at golden hour. In the center foreground, a red fox stands in profile facing left, its body turned toward the viewer and its head raised as it looks across the clearing. The fox has dense rust-red winter fur, a white throat and chest, black lower legs, pointed ears with dark tips, and a long bushy tail ending in white. ...
```

La leyenda completa tiene aproximadamente 240 palabras; `max_new_tokens` limita su longitud (3584 por defecto).

Puedes imprimir el `doc` del paso para ver qué recibe y qué escribe:

```python
print(pipe.blocks.sub_blocks["prompt_upsampler"].doc)
```

```
  Inputs:
      prompt (`str`):
          The edit instruction to expand into the full caption (one per call).
      image (`Image | list`, *optional*):
          The reference image(s) of the edit, at most 10; the same ones the pipeline receives.
      boxes (`list`, *optional*):
          Layout boxes, each {'id', 'desc', 'from', 'src_bbox', 'tgt_bbox'} with the boxes as [y_min, x_min, y_max, x_max] in
          0-1: ...
      max_new_tokens (`int`, *optional*, defaults to 3584):
          The most tokens the upsampler may generate for the caption.
  Outputs:
      prompt (`str`):
          The full caption, replacing the request.
```

Como otros bloques de la pipeline, el bloque `prompt_upsampler` también se ejecuta de forma independiente. La forma recomendada es extraerlo de los bloques: el bloque extraído se convierte en un amplificador independiente, y los bloques restantes forman una pipeline que toma la descripción ampliada como `prompt`:

```python
blocks = ModularPipeline.from_pretrained("black-forest-labs/flux-3-image-klein-base").blocks
pup_block = blocks.sub_blocks.pop("prompt_upsampler")
pup = pup_block.init_pipeline("black-forest-labs/flux-3-image-klein-base")
pup.load_components(dtype=torch.bfloat16)
pup.to("cuda")
caption = pup(prompt="A red fox in a snow-covered forest clearing at golden hour", output="prompt")
pipe = blocks.init_pipeline("black-forest-labs/flux-3-image-klein-base")
pipe.load_components(dtype={"vae": torch.float32, "default": torch.bfloat16})
pipe.to("cuda")
image = pipe(prompt=caption, generator=torch.Generator().manual_seed(0), output="images")[0]
```

De esta forma, puede servirse como una etapa independiente, en su propia GPU o detrás de su propio endpoint, y una interfaz de usuario puede mostrar la descripción que escribió y permitir que el usuario la edite antes de generar. Cualquier otro LLM puede ocupar el lugar del amplificador, con los mismos prompts de sistema: proporciónale `system_prompts["t2i"]` del repositorio del amplificador (o `"i2i"`, con las referencias primero en el mensaje del usuario) como prompt de sistema y la solicitud como mensaje del usuario, y pasa la descripción que devuelve como `prompt` a `pipe`.

## Imagen a imagen

Pase una o más imágenes de referencia con `image`. Una sola referencia se mantiene íntegra: solo se reduce si supera los 4 megapíxeles, se rellena hasta la cuadrícula de 16 píxeles y la generación usa su tamaño por defecto, por lo que la edición se devuelve con el tamaño de la entrada. Varias referencias se ajustan cada una a menos de 1 megapíxel y se recortan a la cuadrícula, y la generación usa por defecto el tamaño de la primera. Un `height`/`width` dado anula el valor por defecto. Describa la imagen *objetivo* como una leyenda completa de la referencia con su edición integrada, en lugar de una instrucción de una línea, o deje que el [prompt upsampler](#prompt-upsampling) la escriba a partir de la instrucción y las referencias:

```python
night = pipe(
    prompt="the same scene at night under a full moon",
    image=image,
    generator=torch.Generator().manual_seed(0),
    output=["images", "prompt"],
)
```

Con varias referencias, refiérase a ellas como la primera imagen, la segunda imagen, ... en el orden en que se pasan a `image`; la descripción las denomina `<ref_image_0>`, `<ref_image_1>`, ... para el modelo de imagen:

```python
combined = pipe(
    prompt="the fox from the first image sitting on the wooden bench from the second image",
    image=[image, bench],
    height=768,
    width=1360,
    output="images",
)[0]
```

Pasa `height` y/o `width` para anular el tamaño derivado.

## Control de diseño

To place content explicitly, pass `boxes`: for each element an `id`, a short `desc`, and a `bbox` of `[y_min, x_min, y_max, x_max]` in 0-1 (origin top-left), so it is independent of the output size. The upsampler writes the caption around them, citing each element as `<id>`, and appends the table of boxes, yours kept exactly:

```python
boxes = [
    {"id": "balloon_1", "desc": "a red and yellow striped hot-air balloon", "bbox": [0.08, 0.06, 0.48, 0.38]},
    {"id": "balloon_2", "desc": "a small blue hot-air balloon", "bbox": [0.20, 0.62, 0.42, 0.80]},
]
out = pipe(prompt="hot-air balloons over a green valley at sunrise", boxes=boxes, output=["images", "prompt"])
```

Al editar, una caja indica su origen con `from`: `"target"` con un `tgt_bbox` añade un nuevo elemento allí, `"ref_image_0"` con un `src_bbox` y un `tgt_bbox` mueve un elemento de esa referencia (las cajas iguales lo mantienen en su lugar):

```python
boxes = [{"id": "cactus", "desc": "a small potted cactus", "from": "target", "src_bbox": None, "tgt_bbox": [0.55, 0.62, 0.85, 0.85]}]
out = pipe(prompt="add a small potted cactus in the marked spot", image=mug, boxes=boxes, output=["images", "prompt"])
boxes = [{"id": "knight", "desc": "the knight figure", "from": "ref_image_0", "src_bbox": [0.50, 0.15, 0.85, 0.35], "tgt_bbox": [0.19, 0.06, 0.54, 0.26]}]
out = pipe(prompt="move the knight up and to the left, keep the rest unchanged", image=knight, boxes=boxes, output=["images", "prompt"])
```

La leyenda que lee el modelo de imagen tiene los elementos etiquetados con `<id>` en el texto y la tabla añadida como JSON, con las cajas en un lienzo de 0 a 1000; imprime la salida de `prompt` para verla. Una leyenda escrita a mano en ese formato se envía a la pipeline sin ese paso, como en [Prompt upsampling](#prompt-upsampling).

## Escala de guía

El pipeline aplica la guía sin clasificador a través de su componente `guider` y no acepta un argumento `guidance_scale` en el momento de la llamada. El guider predeterminado es [ClassifierFreeGuidance](/docs/diffusers/main/es/api/modular_diffusers/guiders#diffusers.ClassifierFreeGuidance) con `guidance_scale=3.5`, la configuración recomendada para ambos flujos de trabajo. Para cambiarlo, cree una copia actualizada del guider:

```python
pipe.guider = pipe.guider.new(guidance_scale=5.0)
```

Consulte la [guía de guías](../../using-diffusers/guiders) para cambiar a un método de guía diferente.

## Modelo destilado por pasos

El checkpoint destilado por pasos genera en 16 pasos sin guía libre de clasificador. Su transformer es un mapa de flujo: en cada paso se le indica el paso temporal actual y el paso al que salta. Se carga como el modelo base (el `modular_model_index.json` del repositorio se resuelve en [Flux3DistilledModularPipeline](/docs/diffusers/main/es/api/pipelines/flux3#diffusers.Flux3DistilledModularPipeline) y [Flux3DistilledAutoBlocks](/docs/diffusers/main/es/api/pipelines/flux3#diffusers.Flux3DistilledAutoBlocks)); el pipeline no tiene `guider` y no acepta `negative_prompt`:

```python
pipe = ModularPipeline.from_pretrained("black-forest-labs/flux-3-image-klein")
pipe.load_components(dtype=torch.bfloat16)
pipe.to("cuda")
image = pipe(prompt=prompt, generator=torch.Generator().manual_seed(0), output="images")[0]
```

Sirve para los mismos dos flujos de trabajo que el modelo base. `num_inference_steps` tiene un valor predeterminado de 16; el modelo se entrena para 4 a 16 pasos.

## Generación reproducible

Un `generator` fija el ruido que extrae el pipeline (consulte [Reproducibilidad](../../using-diffusers/reusing_seeds)). Para reutilizar un ruido extraído en otro lugar, páselo como `latents` con forma `(batch_size, 128, height // 16, width // 16)`. Por ejemplo, la [implementación de BFL](https://github.com/black-forest-labs/flux-3-image-klein) extrae su ruido como tokens de imagen en la CPU y lo convierte a bf16; esto reproduce su muestra para una semilla dada:

```python
height, width = 1024, 1024
h, w = height // 16, width // 16
noise = torch.randn((h * w, 128), generator=torch.Generator().manual_seed(0)).to(torch.bfloat16)
latents = noise.T.reshape(1, 128, h, w)
image = pipe(prompt=prompt, latents=latents, height=height, width=width, output="images")[0]
```

## Flujos de trabajo

El pipeline atiende dos flujos de trabajo, `text2image` y `image_conditioned`; el que se ejecuta se elige según las entradas (`image` selecciona image-to-image). [from_pretrained()](/docs/diffusers/main/es/api/modular_diffusers/pipeline#diffusers.ModularPipeline.from_pretrained) también puede construir un pipeline para un solo flujo de trabajo con el argumento `workflow`, que entonces solo espera y carga los componentes que ese flujo de trabajo necesita:

```python
from diffusers.modular_pipelines import Flux3AutoBlocks
print(Flux3AutoBlocks().available_workflows)
# ["text2image", "image_conditioned"]
t2i = ModularPipeline.from_pretrained("black-forest-labs/flux-3-image-klein-base", workflow="text2image")
print(t2i.blocks.doc)
```

## Callbacks por paso

Para usar una función de callback existente, inserte un bloque en el bucle de desruido. La [guía de callbacks](../../using-diffusers/callback#modular-pipelines) tiene un ejemplo sencillo con el bloque `CallbackOnStepEnd` y el helper `walk_denoise_loops`:

```python
blocks = Flux3AutoBlocks()  # or Flux3DistilledAutoBlocks
for loop in walk_denoise_loops(blocks):
    loop.sub_blocks["callback"] = CallbackOnStepEnd()
pipe = blocks.init_pipeline("black-forest-labs/flux-3-image-klein-base")
image = pipe(prompt=caption, callback_on_step_end=my_callback, output="images")[0]
```

Para detener el proceso de forma anticipada, lanza una excepción desde el callback; no existe una bandera `interrupt`.

## Memoria

Cargar todo en bf16 requiere aproximadamente 39 GB de pesos: el transformer tiene 5.5B de parámetros, el codificador de texto Qwen3-VL-4B tiene 4B y el [prompt upsampler](#prompt-upsampling) tiene 9B (unos 19 GB por sí solo), con el VAE de imagen en fp32. Un pipeline construido sin el paso de upsampler (ver allí) carga aproximadamente 20 GB. Para GPUs con menos memoria, habilite el offloading de componentes; el gestor mueve los componentes entre la CPU y la GPU según lo que necesite cada paso, incluido el upsampler:

```python
from diffusers import ComponentsManager, ModularPipeline
manager = ComponentsManager()
pipe = ModularPipeline.from_pretrained("black-forest-labs/flux-3-image-klein-base", components_manager=manager)
pipe.load_components(dtype={"vae": torch.float32, "default": torch.bfloat16})
manager.enable_auto_cpu_offload(device="cuda")
```

## Carga de un solo archivo

[Flux3Transformer2DModel](/docs/diffusers/main/es/api/models/flux3_transformer#diffusers.Flux3Transformer2DModel) carga el transformer directamente desde un paquete de modelos de Black Forest Labs con [from_single_file()](/docs/diffusers/main/es/api/loaders/single_file#diffusers.loaders.FromOriginalModelMixin.from_single_file). El paquete `config.json` no se lee; pase la configuración de diffusers con `config` y `subfolder`.

```python
import torch
from diffusers import Flux3Transformer2DModel, ModularPipeline
transformer = Flux3Transformer2DModel.from_single_file(
    "https://huggingface.co/black-forest-labs/flux-3-image-klein-base/blob/main/model.safetensors",
    config="black-forest-labs/flux-3-image-klein-base",
    subfolder="transformer",
    dtype=torch.bfloat16,
)
pipe = ModularPipeline.from_pretrained("black-forest-labs/flux-3-image-klein-base")
pipe.load_components(dtype={"vae": torch.float32, "default": torch.bfloat16})
pipe.update_components(transformer=transformer)
pipe.to("cuda")
```

Cargue primero los demás componentes por nombre: [load_components()](/docs/diffusers/main/es/api/modular_diffusers/pipeline#diffusers.ModularPipeline.load_components) sin `names` también cargaría el transformer del repositorio de la pipeline.

La carga de los puntos de control de archivo único FP8r y NVFP4 también está admitida. Ambos se cargan mediante la misma llamada con una [BFLQuantizationConfig](/docs/diffusers/main/es/api/quantization#diffusers.BFLQuantizationConfig). Consulte la [guía de cuantización de BFL](../../quantization/bfl) para conocer los requisitos de kernel de cada esquema.

```python
from diffusers import BFLQuantizationConfig
transformer = Flux3Transformer2DModel.from_single_file(
    "https://huggingface.co/black-forest-labs/flux-3-image-klein-base/blob/main/variants/nvfp4/model.safetensors",
    config="black-forest-labs/flux-3-image-klein-base",
    subfolder="transformer",
    quantization_config=BFLQuantizationConfig(compute_dtype=torch.bfloat16),
    dtype=torch.bfloat16,
)
```

Al cargar los puntos de control destilados por pasos, necesitamos sus configuraciones (`flow_map=True`):

```python
transformer = Flux3Transformer2DModel.from_single_file(
    "https://huggingface.co/black-forest-labs/flux-3-image-klein/blob/main/variants/nvfp4/model.safetensors",
    config="black-forest-labs/flux-3-image-klein",
    subfolder="transformer",
    quantization_config=BFLQuantizationConfig(compute_dtype=torch.bfloat16),
    dtype=torch.bfloat16,
)
```

## Flux3ModularPipeline[[diffusers.Flux3ModularPipeline]]

#### diffusers.Flux3ModularPipeline[[diffusers.Flux3ModularPipeline]]

```python
diffusers.Flux3ModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/flux3/modular_pipeline.py#L24)

Un ModularPipeline para FLUX.3.

## Flux3AutoBlocks[[diffusers.Flux3AutoBlocks]]

#### diffusers.Flux3AutoBlocks[[diffusers.Flux3AutoBlocks]]

```python
diffusers.Flux3AutoBlocks()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/flux3/modular_blocks_flux3.py#L339)

Auto bloques que realizan la generación de texto a imagen y de imagen a imagen usando FLUX.3. `prompt` pasa primero por el amplificador de prompts; elimina el paso `prompt_upsampler` para codificarlo tal como se proporciona.

Flujos de trabajo admitidos:
- `text2image`: requiere `prompt`
- `image_conditioned`: requiere `prompt`, `image`

Componentes: prompt_upsampler (`Qwen3_5ForConditionalGeneration`): el amplificador de prompts. prompt_upsampler_processor (`AutoProcessor`): su procesador. text_encoder (`Qwen3VLForConditionalGeneration`) tokenizer (`AutoProcessor`) image_processor (`Flux3ImageProcessor`) vae (`AutoencoderKLFlux2`) transformer (`Flux3Transformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`) guider (`ClassifierFreeGuidance`)

Entradas: prompt (`str`): La instrucción de edición para expandir en la descripción completa (una por llamada). image (`Image | list`, *opcional*): La(s) imagen(es) de referencia de la edición, como máximo 10; las mismas que recibe el pipeline. boxes (`list`, *opcional*): Cajas de diseño, cada una {'id', 'desc', 'from', 'src_bbox', 'tgt_bbox'} con las cajas como [y_min, x_min, y_max, x_max] en 0-1: 'from': 'target' con `tgt_bbox` añade un elemento allí, 'from': 'ref_image_0', ... con `src_bbox` y `tgt_bbox` mueve uno desde una imagen de referencia. max_new_tokens (`int`, *opcional*, valor predeterminado 3584): El número máximo de tokens que el amplificador puede generar para la descripción. negative_prompt (`str`, *opcional*): El prompt que no debe guiar la generación max_sequence_length (`int`, *opcional*, valor predeterminado 8192): Número máximo de tokens del prompt; los prompts más largos se truncan. text_encoder_out_layers (`tuple`, *opcional*, valor predeterminado (4, 8, 12, 16, 20, 24, 28, 32)): Índices de las capas ocultas del codificador de texto cuyos estados se apilan para formar los embeddings de texto num_images_per_prompt (`int`, *opcional*, valor predeterminado 1): El número de imágenes a generar por prompt. image_cond_latents (`list`, *opcional*): Latentes empaquetados normalizados de las imágenes de referencia, un tensor de forma (B, C, height_i//16, width_i//16) por imagen height (`int`, *opcional*, valor predeterminado None o 1024, dependiendo del flujo de trabajo): La altura en píxeles de la imagen generada; por defecto, la altura propia de la primera imagen de referencia width (`int`, *opcional*, valor predeterminado None o 1024, dependiendo del flujo de trabajo): El ancho en píxeles de la imagen generada; por defecto, el ancho propio de la primera imagen de referencia reference_crop (`list | NoneType`, *opcional*): Por referencia, la caja de la referencia dentro de su lienzo relleno o None, del paso de preprocesado latents (`Tensor`): Latentes ruidosos pregenerados para la generación de imágenes. generator (`Generator`, *opcional*): Generador de Torch para generación determinista. num_inference_steps (`int`): El número de pasos de desruido. timesteps (`Tensor`): Pasos de tiempo para el proceso de desruido. (anula `num_inference_steps` cuando se proporciona) sigmas (`list`, *opcional*): Sigmas personalizados para el proceso de desruido. (anula `num_inference_steps` cuando se proporciona) **denoiser_input_fields (`None`, *opcional*): Entradas condicionales del modelo para el desruidador: p. ej. prompt_embeds, negative_prompt_embeds, etc. attention_kwargs (`dict`, *opcional*): Kwargs adicionales para los procesadores de atención. output_type (`str`, *opcional*, valor predeterminado pil): Formato de salida: 'pil', 'np', 'pt'.
Salidas: imágenes (`list`): Imágenes generadas. latents (`Tensor`): Latentes desruidados.
## Flux3DistilledAutoBlocks[[diffusers.Flux3DistilledAutoBlocks]]
#### diffusers.Flux3DistilledAutoBlocks[[diffusers.Flux3DistilledAutoBlocks]]
```python
diffusers.Flux3DistilledAutoBlocks()
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/flux3/modular_blocks_flux3_distilled.py#L258)
Auto bloques que realizan la generación de texto a imagen y de imagen a imagen utilizando el modelo FLUX.3 destilado por pasos (16 pasos, sin guía libre de clasificador). `prompt` pasa primero por el amplificador de prompts; elimina el paso `prompt_upsampler` para codificarlo tal como se proporciona.
Flujos de trabajo admitidos:
- `text2image`: requiere `prompt`
- `image_conditioned`: requiere `prompt`, `image`
Componentes: prompt_upsampler (`Qwen3_5ForConditionalGeneration`): el amplificador de prompts. prompt_upsampler_processor (`AutoProcessor`): su procesador. text_encoder (`Qwen3VLForConditionalGeneration`) tokenizer (`AutoProcessor`) image_processor (`Flux3ImageProcessor`) vae (`AutoencoderKLFlux2`) transformer (`Flux3Transformer2DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`)
Entradas: prompt (`str`): La instrucción de edición para expandir en la descripción completa (una por llamada). image (`Image | list`, *opcional*): La(s) imagen(es) de referencia de la edición, como máximo 10; las mismas que recibe el pipeline. boxes (`list`, *opcional*): Cajas de diseño, cada una {'id', 'desc', 'from', 'src_bbox', 'tgt_bbox'} con las cajas como [y_min, x_min, y_max, x_max] en 0-1: 'from': 'target' con `tgt_bbox` añade un elemento allí, 'from': 'ref_image_0', ... con `src_bbox` y `tgt_bbox` mueve uno desde una imagen de referencia. max_new_tokens (`int`, *opcional*, valor predeterminado 3584): El número máximo de tokens que el amplificador puede generar para la descripción. max_sequence_length (`int`, *opcional*, valor predeterminado 8192): Número máximo de tokens del prompt; los prompts más largos se truncan. text_encoder_out_layers (`tuple`, *opcional*, valor predeterminado (4, 8, 12, 16, 20, 24, 28, 32)): Índices de las capas ocultas del codificador de texto cuyos estados se apilan para formar las incrustaciones de texto num_images_per_prompt (`int`, *opcional*, valor predeterminado 1): El número de imágenes a generar por prompt. image_cond_latents (`list`, *opcional*): Latentes empaquetados normalizados de las imágenes de referencia, un tensor de forma (B, C, height_i//16, width_i//16) por imagen height (`int`, *opcional*, valor predeterminado None o 1024, dependiendo del flujo de trabajo): La altura en píxeles de la imagen generada; por defecto, la altura propia de la primera imagen de referencia width (`int`, *opcional*, valor predeterminado None o 1024, dependiendo del flujo de trabajo): El ancho en píxeles de la imagen generada; por defecto, el ancho propio de la primera imagen de referencia reference_crop (`list | NoneType`, *opcional*): Por referencia, la caja de la referencia dentro de su lienzo relleno o None, del paso de preprocesado latents (`Tensor`): Latentes ruidosos pregenerados para la generación de imágenes. generator (`Generator`, *opcional*): Generador de Torch para generación determinista. num_inference_steps (`int`): El número de pasos de desruido. timesteps (`Tensor`): Pasos de tiempo para el proceso de desruido. (anula `num_inference_steps` cuando se proporciona) sigmas (`list`, *opcional*): Sigmas personalizados para el proceso de desruido. (anula `num_inference_steps` cuando se proporciona) **denoiser_input_fields (`None`, *opcional*): entradas del modelo condicional para el desruidador: p. ej. prompt_embeds, negative_prompt_embeds, etc. output_type (`str`, *opcional*, valor predeterminado pil): Formato de salida: 'pil', 'np', 'pt'.
Salidas: imágenes (`list`): Imágenes generadas. latents (`Tensor`): Latentes desruidados.
## Flux3DistilledModularPipeline[[diffusers.Flux3DistilledModularPipeline]]
#### diffusers.Flux3DistilledModularPipeline[[diffusers.Flux3DistilledModularPipeline]]
```python
diffusers.Flux3DistilledModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/flux3/modular_pipeline.py#L52)
Un ModularPipeline para el modelo FLUX.3 destilado por pasos (16 pasos, sin guía libre de clasificador).
Xet Storage Details

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