Diffusers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.42.1).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

FluxControlInpaint

FluxControlInpaintPipeline es una implementación de Inpainting para los modelos Flux.1 Depth/Canny. Es un pipeline que permite realizar inpainting en imágenes utilizando los modelos Flux.1 Depth/Canny. El pipeline toma una imagen y una máscara como entrada y devuelve la imagen con el inpainting aplicado.

FLUX.1 Depth and Canny [dev] es un transformer de flujo rectificado de 12 mil millones de parámetros capaz de generar una imagen a partir de una descripción de texto mientras sigue la estructura de una imagen de entrada dada. Este no es un modelo ControlNet.

Tipo de control	Desarrollador	Enlace
Profundidad	Black Forest Labs	Enlace
Canny	Black Forest Labs	Enlace

Flux puede ser bastante costoso de ejecutar en dispositivos de hardware de consumo. Sin embargo, puedes realizar una serie de optimizaciones para ejecutarlo más rápido y de una manera más eficiente en memoria. Consulta esta sección para más detalles. Además, Flux puede beneficiarse de la cuantización para la eficiencia de memoria, a cambio de una mayor latencia de inferencia. Consulta esta publicación de blog para obtener más información. Para una lista exhaustiva de recursos, consulta este gist.

import torch
from diffusers import FluxControlInpaintPipeline
from diffusers.models.transformers import FluxTransformer2DModel
from transformers import T5EncoderModel
from diffusers.utils import load_image, make_image_grid
from image_gen_aux import DepthPreprocessor # https://github.com/huggingface/image_gen_aux
from PIL import Image
import numpy as np

pipe = FluxControlInpaintPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-Depth-dev",
    dtype=torch.bfloat16,
)
# use following lines if you have GPU constraints
# ---------------------------------------------------------------
transformer = FluxTransformer2DModel.from_pretrained(
    "sayakpaul/FLUX.1-Depth-dev-nf4", subfolder="transformer", dtype=torch.bfloat16
)
text_encoder_2 = T5EncoderModel.from_pretrained(
    "sayakpaul/FLUX.1-Depth-dev-nf4", subfolder="text_encoder_2", dtype=torch.bfloat16
)
pipe.transformer = transformer
pipe.text_encoder_2 = text_encoder_2
pipe.enable_model_cpu_offload()
# ---------------------------------------------------------------
pipe.to("cuda")  # or "mps", "xpu", "cpu"

prompt = "a blue robot singing opera with human-like expressions"
image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")

head_mask = np.zeros_like(image)
head_mask[65:580,300:642] = 255
mask_image = Image.fromarray(head_mask)

processor = DepthPreprocessor.from_pretrained("LiheYoung/depth-anything-large-hf")
control_image = processor(image)[0].convert("RGB")

output = pipe(
    prompt=prompt,
    image=image,
    control_image=control_image,
    mask_image=mask_image,
    num_inference_steps=30,
    strength=0.9,
    guidance_scale=10.0,
    generator=torch.Generator().manual_seed(42),
).images[0]
make_image_grid([image, control_image, mask_image, output.resize(image.size)], rows=1, cols=4).save("output.png")

FluxControlInpaintPipeline

clase diffusers.FluxControlInpaintPipeline

< source >

( scheduler: FlowMatchEulerDiscreteSchedulervae: AutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizertext_encoder_2: T5EncoderModeltokenizer_2: T5Tokenizertransformer: FluxTransformer2DModel )

Parámetros

transformer (FluxTransformer2DModel) — Arquitectura Conditional Transformer (MMDiT) para desruidar los latentes de imagen codificados.
scheduler (FlowMatchEulerDiscreteScheduler) — Un scheduler para usar en combinación con transformer para desruidar los latentes de imagen codificados.
vae (AutoencoderKL) — Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes a partir de y hacia representaciones latentes.
text_encoder (CLIPTextModel) — CLIP, concretamente la variante clip-vit-large-patch14.
text_encoder_2 (T5EncoderModel) — T5, concretamente la variante google/t5-v1_1-xxl.
tokenizer (CLIPTokenizer) — Tokenizer de la clase CLIPTokenizer.
tokenizer_2 (T5TokenizerFast) — Segundo Tokenizer de la clase T5TokenizerFast.

El pipeline de Flux para el relleno de imágenes (inpainting) utilizando Flux-dev-Depth/Canny.

Referencia: https://blackforestlabs.ai/announcing-black-forest-labs/

call

< source >

( prompt: str | list[str] = Noneprompt_2: str | list[str] | None = Noneimage: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = Nonecontrol_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = Nonemask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = Nonemasked_image_latents: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = Noneheight: int | None = Nonewidth: int | None = Nonestrength: float = 0.6num_inference_steps: int = 28sigmas: list[float] | None = Noneguidance_scale: float = 7.0num_images_per_prompt: int | None = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.FloatTensor] = Noneprompt_embeds: typing.Optional[torch.FloatTensor] = Nonepooled_prompt_embeds: typing.Optional[torch.FloatTensor] = Noneoutput_type: str | None = 'pil'return_dict: bool = Truejoint_attention_kwargs: dict[str, typing.Any] | None = Nonecallback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = Nonecallback_on_step_end_tensor_inputs: list = ['latents']max_sequence_length: int = 512 ) → ~pipelines.flux.FluxPipelineOutput or tuple

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, hay que pasar prompt_embeds en su lugar.
prompt_2 (str o list[str], opcional) — El prompt o prompts que se enviarán a tokenizer_2 y text_encoder_2. Si no está definido, se utilizará prompt en su lugar
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.
control_image (torch.Tensor, PIL.Image.Image, np.ndarray, list[torch.Tensor], list[PIL.Image.Image], list[np.ndarray], — list[list[torch.Tensor]], list[list[np.ndarray]] o list[list[PIL.Image.Image]]): La condición de entrada de ControlNet para proporcionar orientación al unet durante la generación. Si el tipo se especifica como torch.Tensor, se pasa a ControlNet tal cual. También se puede aceptar PIL.Image.Image como imagen. Las dimensiones de la imagen de salida son, por defecto, las dimensiones de image. Si se pasan height y/o width, image se redimensiona en consecuencia. Si se especifican varios ControlNets en init, las imágenes deben pasarse como una lista para que cada elemento de la lista pueda agruparse correctamente como entrada para un solo ControlNet.
mask_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 enmascarar image. Los píxeles blancos de la máscara se repintan, mientras que los píxeles negros se conservan. Si mask_image es una imagen PIL, se convierte a un solo canal (luminancia) antes de su uso. Si es un array de numpy o un tensor de pytorch, debe contener un solo canal de color (L) en lugar de 3, por lo que la forma esperada para un tensor de pytorch sería (B, 1, H, W), (B, H, W), (1, H, W), (H, W). Y para un array de numpy sería (B, H, W, 1), (B, H, W), (H, W, 1) o (H, W).
masked_image_latents (torch.Tensor, list[torch.Tensor]) — Tensor que representa un lote de imágenes para enmascarar la image generada por el VAE. Si no se proporciona, el tensor de latentes de la máscara se generará mediante mask_image.
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, valor predeterminado 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.
strength (float, opcional, valor predeterminado 1.0) — Indica el grado en que se transforma la image de referencia. Debe estar entre 0 y 1. image se utiliza como punto de partida y se añade más ruido a medida que aumenta el strength. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuando strength es 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado en num_inference_steps. Un valor de 1 ignora esencialmente image.
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.
guidance_scale (float, opcional, valor predeterminado 7.0) — Escala de guía definida en Classifier-Free Diffusion Guidance. guidance_scale se define como w de la ecuación 2 del Imagen Paper. La escala de guía se habilita estableciendo guidance_scale > 1. Una escala de guía 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 que se generarán por indicación.
generator (torch.Generator o list[torch.Generator], opcional) — Un generador o una lista de generadores de torch para hacer la generación determinista.
latents (torch.FloatTensor, opcional) — Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se usarán como entradas para la generación de imágenes. Se pueden utilizar 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.FloatTensor, opcional) — Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporcionan, las incrustaciones de texto se generarán a partir del argumento de entrada prompt.
pooled_prompt_embeds (torch.FloatTensor, opcional) — Incrustaciones de texto agrupadas pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporciona, las incrustaciones de texto agrupadas se generarán a partir del argumento de entrada prompt.
output_type (str, opcional, valor predeterminado "pil") — El formato de salida de la imagen generada. Elija entre PIL: PIL.Image.Image o np.array.
return_dict (bool, opcional, valor predeterminado True) — Indica si se debe devolver un ~pipelines.flux.FluxPipelineOutput en lugar de una tupla simple.
joint_attention_kwargs (dict, opcional) — Un diccionario de kwargs que, si se especifica, se pasa al AttentionProcessor definido en self.processor dentro de diffusers.models.attention_processor.
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ás incluir variables listadas en el atributo ._callback_tensor_inputs de tu clase de pipeline.
max_sequence_length (int por defecto 512) — Longitud máxima de la secuencia para usar con el prompt.

Devuelve

~pipelines.flux.FluxPipelineOutput o tuple

~pipelines.flux.FluxPipelineOutput 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:

import torch
from diffusers import FluxControlInpaintPipeline
from diffusers.models.transformers import FluxTransformer2DModel
from transformers import T5EncoderModel
from diffusers.utils import load_image, make_image_grid
from image_gen_aux import DepthPreprocessor  # https://github.com/huggingface/image_gen_aux
from PIL import Image
import numpy as np

pipe = FluxControlInpaintPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-Depth-dev",
    torch_dtype=torch.bfloat16,
)
# use following lines if you have GPU constraints
# ---------------------------------------------------------------
transformer = FluxTransformer2DModel.from_pretrained(
    "sayakpaul/FLUX.1-Depth-dev-nf4", subfolder="transformer", torch_dtype=torch.bfloat16
)
text_encoder_2 = T5EncoderModel.from_pretrained(
    "sayakpaul/FLUX.1-Depth-dev-nf4", subfolder="text_encoder_2", torch_dtype=torch.bfloat16
)
pipe.transformer = transformer
pipe.text_encoder_2 = text_encoder_2
pipe.enable_model_cpu_offload()
# ---------------------------------------------------------------
pipe.to("cuda")

prompt = "a blue robot singing opera with human-like expressions"
image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")

head_mask = np.zeros_like(image)
head_mask[65:580, 300:642] = 255
mask_image = Image.fromarray(head_mask)

processor = DepthPreprocessor.from_pretrained("LiheYoung/depth-anything-large-hf")
control_image = processor(image)[0].convert("RGB")

output = pipe(
    prompt=prompt,
    image=image,
    control_image=control_image,
    mask_image=mask_image,
    num_inference_steps=30,
    strength=0.9,
    guidance_scale=10.0,
    generator=torch.Generator().manual_seed(42),
).images[0]
make_image_grid([image, control_image, mask_image, output.resize(image.size)], rows=1, cols=4).save(
    "output.png"
)

encode_prompt

< source >

( prompt: str | list[str]prompt_2: str | list[str] | None = Nonedevice: typing.Optional[torch.device] = Nonenum_images_per_prompt: int = 1prompt_embeds: typing.Optional[torch.FloatTensor] = Nonepooled_prompt_embeds: typing.Optional[torch.FloatTensor] = Nonemax_sequence_length: int = 512lora_scale: float | None = None )

Parámetros

prompt (str o list[str], opcional) — prompt a codificar
prompt_2 (str o list[str], opcional) — El prompt o prompts que se enviarán al tokenizer_2 y al text_encoder_2. Si no se define, se utiliza prompt en todos los text-encoders
device — (torch.device): dispositivo de torch
num_images_per_prompt (int) — número de imágenes que deben generarse por prompt
prompt_embeds (torch.FloatTensor, opcional) — Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporcionan, las incrustaciones de texto se generarán a partir del argumento de entrada prompt.
pooled_prompt_embeds (torch.FloatTensor, opcional) — Incrustaciones de texto agrupadas pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporciona, las incrustaciones de texto agrupadas se generarán a partir del argumento de entrada prompt.
lora_scale (float, opcional) — Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.

FluxPipelineOutput

clase diffusers.pipelines.flux.pipeline_output.FluxPipelineOutput

< source >

( images: list[PIL.Image.Image] | numpy.ndarray )

Parámetros

images (list[PIL.Image.Image] o torch.Tensor o np.ndarray) — lista de imágenes PIL desruidas de longitud batch_size o array de numpy o tensor de torch de forma (batch_size, height, width, num_channels). Las imágenes PIL o el array de numpy presentan las imágenes desruidas del pipeline de difusión. Los tensors de torch pueden representar tanto las imágenes desruidas como los latentes intermedios listos para ser pasados al decodificador.

Clase de salida para las tuberías de generación de imágenes de Flux.

Update on GitHub

←Flux3 GLM-Image→

Diffusers

FluxControlInpaint

FluxControlInpaintPipeline

clase diffusers.FluxControlInpaintPipeline

__call__

encode_prompt

FluxPipelineOutput

clase diffusers.pipelines.flux.pipeline_output.FluxPipelineOutput

call