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 est une implémentation de l'inpainting pour les modèles Flux.1 Depth/Canny. C'est un pipeline qui permet d'effectuer de l'inpainting sur des images à l'aide des modèles Flux.1 Depth/Canny. Le pipeline prend en entrée une image et un masque, et renvoie l'image après inpainting.

FLUX.1 Depth and Canny [dev] est un transformateur de flux rectifié de 12 milliards de paramètres capable de générer une image à partir d'une description textuelle tout en respectant la structure d'une image d'entrée donnée. Ceci n'est pas un modèle ControlNet.

Type de contrôle	Développeur	Lien
Profondeur	Black Forest Labs	Lien
Canny	Black Forest Labs	Lien

Flux peut être relativement coûteux à exécuter sur du matériel grand public. Toutefois, vous pouvez effectuer une série d’optimisations pour l’exécuter plus rapidement et de manière plus économe en mémoire. Consultez cette section pour plus de détails. De plus, Flux peut bénéficier de la quantification pour une meilleure efficacité mémoire, au prix d’une latence d’inférence accrue. Reportez-vous à ce billet de blog pour en savoir plus. Pour une liste exhaustive des ressources, consultez ce 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

classe diffusers.FluxControlInpaintPipeline

< source >

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

Paramètres

transformer (FluxTransformer2DModel) — Architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents d’image encodés.
scheduler (FlowMatchEulerDiscreteScheduler) — Un planificateur à utiliser en combinaison avec transformer pour débruyer les latents d'image encodés.
vae (AutoencoderKL) — Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
text_encoder (CLIPTextModel) — CLIP, plus précisément la variante clip-vit-large-patch14.
text_encoder_2 (T5EncoderModel) — T5, plus précisément la variante google/t5-v1_1-xxl.
tokenizer (CLIPTokenizer) — Tokeniseur de la classe CLIPTokenizer.
tokenizer_2 (T5TokenizerFast) — Deuxième Tokenizer de la classe T5TokenizerFast.

Le pipeline Flux pour l'inpainting d'images à l'aide de Flux-dev-Depth/Canny.

Référence : 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

Paramètres

prompt (str ou list[str], facultatif) — Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, il faut passer prompt_embeds à la place.
prompt_2 (str ou list[str], facultatif) — Le prompt ou les prompts à envoyer à tokenizer_2 et text_encoder_2. S'il n'est pas défini, prompt sera utilisé à la place
image (torch.Tensor, PIL.Image.Image, np.ndarray, list[torch.Tensor], list[PIL.Image.Image] ou list[np.ndarray]) — Image, tableau numpy ou tenseur représentant un lot d’images à utiliser comme point de départ. Pour un tableau numpy comme pour un tenseur pytorch, la plage de valeurs attendue est comprise entre [0, 1]. S’il s’agit d’un tenseur ou d’une liste de tenseurs, la forme attendue doit être (B, C, H, W) ou (C, H, W). S’il s’agit d’un tableau numpy ou d’une liste de tableaux, la forme attendue doit être (B, H, W, C) ou (H, W, C). Il peut également accepter des latents d’image en tant que image, mais si des latents sont transmis directement, ils ne sont pas réencodés.
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]] ou list[list[PIL.Image.Image]]) : La condition d’entrée ControlNet à fournir pour guider le unet lors de la génération. Si le type est spécifié comme torch.Tensor, il est transmis à ControlNet tel quel. PIL.Image.Image peut également être accepté en tant qu’image. Les dimensions de l’image de sortie sont par défaut celles de image. Si la hauteur et/ou la largeur sont passées, image est redimensionnée en conséquence. Si plusieurs ControlNets sont spécifiés dans init, les images doivent être passées sous forme de liste afin que chaque élément de la liste puisse être correctement groupé (batching) pour l’entrée d’un seul ControlNet.
mask_image (torch.Tensor, PIL.Image.Image, np.ndarray, list[torch.Tensor], list[PIL.Image.Image] ou list[np.ndarray]) — Image, tableau numpy ou tenseur représentant un lot d’images à masquer image. Les pixels blancs du masque sont repeints tandis que les pixels noirs sont conservés. Si mask_image est une image PIL, elle est convertie en un seul canal (luminance) avant utilisation. S’il s’agit d’un tableau numpy ou d’un tenseur pytorch, il doit contenir un seul canal de couleur (L) au lieu de 3, la forme attendue pour un tenseur pytorch serait donc (B, 1, H, W), (B, H, W), (1, H, W), (H, W). Et pour un tableau numpy, elle serait (B, H, W, 1), (B, H, W), (H, W, 1) ou (H, W).
masked_image_latents (torch.Tensor, list[torch.Tensor]) — Tensor représentant un lot d’images à masquer image généré par le VAE. S’il n’est pas fourni, le tenseur de latents du masque sera généré par mask_image.
height (int, facultatif, par défaut self.unet.config.sample_size * self.vae_scale_factor) — La hauteur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
width (int, facultatif, par défaut self.unet.config.sample_size * self.vae_scale_factor) — La largeur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
strength (float, facultatif, valeur par défaut 1.0) — Indique l'étendue de la transformation de l'image de référence. Doit être compris entre 0 et 1. L'image est utilisée comme point de départ et plus le strength est élevé, plus du bruit est ajouté. Le nombre d'étapes de débruitage dépend de la quantité de bruit initialement ajoutée. Lorsque strength vaut 1, le bruit ajouté est maximal et le processus de débruitage s'exécute pendant le nombre complet d'itérations spécifié dans num_inference_steps. Une valeur de 1 ignore essentiellement l'image.
num_inference_steps (int, facultatif, valeur par défaut 50) — Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente.
sigmas (list[float], facultatif) — Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument sigmas dans leur méthode set_timesteps. S'il n'est pas défini, le comportement par défaut lorsque num_inference_steps est passé sera utilisé.
guidance_scale (float, facultatif, valeur par défaut 7.0) — Échelle de guidage telle que définie dans Classifier-Free Diffusion Guidance. guidance_scale est défini comme w de l’équation 2 de Imagen Paper. L’échelle de guidage est activée en définissant guidance_scale > 1. Une échelle de guidage plus élevée encourage la génération d’images étroitement liées au prompt texte, généralement au détriment de la qualité de l’image.
num_images_per_prompt (int, facultatif, valeur par défaut 1) — Le nombre d'images à générer par invite.
generator (torch.Generator ou list[torch.Generator], facultatif) — Un ou une liste de générateurs torch pour rendre la génération déterministe.
latents (torch.FloatTensor, facultatif) — Latents bruités pré-générés, échantillonnés à partir d’une distribution gaussienne, à utiliser comme entrées pour la génération d’images. Peut être utilisé pour ajuster la même génération avec des prompts différents. S’il n’est pas fourni, un tenseur de latents sera généré par échantillonnage à l’aide du generator aléatoire fourni.
prompt_embeds (torch.FloatTensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront générés à partir de l'argument d'entrée prompt.
pooled_prompt_embeds (torch.FloatTensor, facultatif) — Embeddings de texte pré-poolés pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, les embeddings de texte pré-poolés seront générés à partir de l'argument d'entrée prompt.
output_type (str, facultatif, par défaut "pil") — Le format de sortie de l'image générée. Choisissez entre PIL : PIL.Image.Image ou np.array.
return_dict (bool, facultatif, par défaut True) — Indique s'il faut retourner un ~pipelines.flux.FluxPipelineOutput plutôt qu'un simple tuple.
joint_attention_kwargs (dict, facultatif) — Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'AttentionProcessor défini sous self.processor dans diffusers.models.attention_processor.
callback_on_step_end (Callable, facultatif) — Une fonction appelée à la fin de chaque étape de débruitage pendant l'inférence. La fonction est appelée avec les arguments suivants : callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict). callback_kwargs contiendra une liste de tous les tenseurs spécifiés par callback_on_step_end_tensor_inputs.
callback_on_step_end_tensor_inputs (list, facultatif) — La liste des entrées tensorielles pour la fonction callback_on_step_end. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument callback_kwargs. Vous ne pourrez inclure que les variables listées dans l'attribut ._callback_tensor_inputs de votre classe de pipeline.
max_sequence_length (int par défaut 512) — Longueur maximale de la séquence à utiliser avec le prompt.

Retourne

~pipelines.flux.FluxPipelineOutput ou tuple

~pipelines.flux.FluxPipelineOutput si return_dict est True, sinon un tuple. En cas de retour d'un tuple, le premier élément est une liste contenant les images générées.

Fonction appelée lors de l'appel du pipeline pour la génération.

Exemples :

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 )

Paramètres

prompt (str ou list[str], facultatif) — prompt à encoder
prompt_2 (str ou list[str], facultatif) — Le prompt ou les prompts à envoyer au tokenizer_2 et au text_encoder_2. S'il n'est pas défini, prompt est utilisé dans tous les encodeurs de texte
device — (torch.device) : torch device
num_images_per_prompt (int) — nombre d'images à générer par invite
prompt_embeds (torch.FloatTensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront générés à partir de l'argument d'entrée prompt.
pooled_prompt_embeds (torch.FloatTensor, facultatif) — Embeddings de texte pré-poolés pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, les embeddings de texte pré-poolés seront générés à partir de l'argument d'entrée prompt.
lora_scale (float, facultatif) — Un facteur d’échelle LoRA qui sera appliqué à toutes les couches LoRA de l’encodeur de texte si des couches LoRA sont chargées.

FluxPipelineOutput

classe diffusers.pipelines.flux.pipeline_output.FluxPipelineOutput

< source >

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

Paramètres

images (list[PIL.Image.Image] ou torch.Tensor ou np.ndarray) — liste d’images PIL débruitées de longueur batch_size ou tableau numpy ou tenseur torch de forme (batch_size, height, width, num_channels). Les images PIL ou le tableau numpy présentent les images débruitées du pipeline de diffusion. Les tenseurs Torch peuvent représenter soit les images débruitées, soit les latents intermédiaires prêts à être transmis au décodeur.

Classe de sortie pour les pipelines de génération d’images Flux.

Update on GitHub

←Flux3 GLM-Image→

Diffusers

FluxControlInpaint

FluxControlInpaintPipeline

classe diffusers.FluxControlInpaintPipeline

__call__

encode_prompt

FluxPipelineOutput

classe diffusers.pipelines.flux.pipeline_output.FluxPipelineOutput

call