Buckets:

hf-doc-build/doc / diffusers /main /pt /api /pipelines /control_flux_inpaint.md
mishig's picture
|
download
raw
19.8 kB

FluxControlInpaint

FluxControlInpaintPipeline é uma implementação de Inpainting para os modelos Flux.1 Depth/Canny. Trata-se de um pipeline que permite realizar inpainting em imagens usando os modelos Flux.1 Depth/Canny. O pipeline recebe uma imagem e uma máscara como entrada e retorna a imagem com o inpainting aplicado.

FLUX.1 Depth and Canny [dev] é um transformer de fluxo retificado com 12 bilhões de parâmetros, capaz de gerar uma imagem com base em uma descrição de texto, seguindo a estrutura de uma imagem de entrada fornecida. Este não é um modelo ControlNet.

Tipo de controle Desenvolvedor Link
Profundidade Black Forest Labs Link
Canny Black Forest Labs Link

Flux pode ser bastante caro de executar em dispositivos de hardware de consumo. No entanto, é possível 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 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 para saber mais. Para uma lista exaustiva de recursos, consulte 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[[diffusers.FluxControlInpaintPipeline]]

diffusers.FluxControlInpaintPipeline[[diffusers.FluxControlInpaintPipeline]]

diffusers.FluxControlInpaintPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel)

Fonte

Parâmetros:

transformer (FluxTransformer2DModel) : Arquitetura de Transformer condicional (MMDiT) para desruidar os latentes da imagem codificada.

scheduler (FlowMatchEulerDiscreteScheduler) : Um scheduler a ser usado em combinação com transformer para desruidar os latentes da imagem codificada.

vae (AutoencoderKL) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes.

text_encoder (CLIPTextModel) : CLIP, especificamente a variante clip-vit-large-patch14.

text_encoder_2 (T5EncoderModel) : T5, especificamente a variante google/t5-v1_1-xxl.

tokenizer (CLIPTokenizer) : Tokenizer da classe CLIPTokenizer.

tokenizer_2 (T5TokenizerFast) : Segundo Tokenizer da classe T5TokenizerFast.

O pipeline Flux para inpainting de imagens usando Flux-dev-Depth/Canny.

Referência: https://blackforestlabs.ai/announcing-black-forest-labs/

call[[diffusers.FluxControlInpaintPipeline.call]]

__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, masked_image_latents: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, strength: float = 0.6, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 7.0, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_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)

Fonte

Parâmetros:

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.

prompt_2 (str ou list[str], opcional) : O prompt ou os prompts a serem enviados para tokenizer_2 e text_encoder_2. Se não definido, prompt será usado no lugar

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.

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]]): A condição de entrada do ControlNet para fornecer orientação ao unet para a geração. Se o tipo for especificado como torch.Tensor, ele é passado ao ControlNet como está. PIL.Image.Image também pode ser aceito como uma imagem. As dimensões da imagem de saída padrão são as dimensões de image. Se altura e/ou largura forem passadas, image será redimensionada de acordo. Se múltiplos ControlNets forem especificados em init, as imagens devem ser passadas como uma lista, de modo que cada elemento da lista possa ser corretamente agrupado (batched) para entrada em um único ControlNet.

mask_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 para mascarar image. Os pixels brancos na máscara são repintados, enquanto os pixels pretos são preservados. Se mask_image for uma imagem PIL, ela é convertida para um único canal (luminância) antes do uso. Se for um array numpy ou tensor pytorch, ele deve conter um único canal de cor (L) em vez de 3, portanto, a forma esperada para um tensor pytorch seria (B, 1, H, W), (B, H, W), (1, H, W) ou (H, W). E para um array numpy seria (B, H, W, 1), (B, H, W), (H, W, 1) ou (H, W).

masked_image_latents (torch.Tensor, list[torch.Tensor]) : Tensor representando um lote de imagens para mascarar a image gerada pelo VAE. Se não for fornecido, o tensor de latentes de máscara será gerado por mask_image.

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.

strength (float, opcional, padrão 1.0) : Indica o grau de transformação da image de referência. Deve estar entre 0 e 1. image é usado como ponto de partida e mais ruído é adicionado quanto maior for o strength. O número de etapas de desruidamento depende da quantidade de ruído inicialmente adicionada. Quando strength é 1, o ruído adicionado é máximo e o processo de desruidamento executa pelo número total de iterações especificado em num_inference_steps. Um valor de 1 essencialmente ignora image.

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.

guidance_scale (float, opcional, padrão 7.0) : Escala de orientação definida em Classifier-Free Diffusion Guidance. guidance_scale é definido como w da equação 2. do Imagen Paper. 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.

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 para tornar a geração determinística.

latents (torch.FloatTensor, 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.FloatTensor, opcional) : Emojis de texto pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, os emojis de texto serão gerados a partir do argumento de entrada prompt.

pooled_prompt_embeds (torch.FloatTensor, opcional) : Embeddings de texto agrupados pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, os embeddings de texto agrupados 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: PIL.Image.Image ou np.array.

return_dict (bool, opcional, padrão True) : Se deve ou não retornar um ~pipelines.flux.FluxPipelineOutput em vez de uma tupla simples.

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

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.

Retorna: ~pipelines.flux.FluxPipelineOutput ou tuple

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

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[[diffusers.FluxControlInpaintPipeline.encode_prompt]]

encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)

Fonte

Parâmetros:

prompt (str ou list[str], opcional) : prompt a ser codificado

prompt_2 (str ou list[str], opcional) : O prompt ou os prompts a serem enviados para o tokenizer_2 e o text_encoder_2. Se não definido, prompt é usado em todos os text-encoders

device : (torch.device): dispositivo torch

num_images_per_prompt (int) : número de imagens que devem ser geradas por prompt

prompt_embeds (torch.FloatTensor, opcional) : Emojis de texto pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, os emojis de texto serão gerados a partir do argumento de entrada prompt.

pooled_prompt_embeds (torch.FloatTensor, opcional) : Embeddings de texto agrupados pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, os embeddings de texto agrupados serão gerados a partir do argumento de entrada prompt.

lora_scale (float, opcional) : Uma escala lora que será aplicada a todas as camadas LoRA do text encoder, caso as camadas LoRA sejam carregadas.

FluxPipelineOutput[[diffusers.pipelines.flux.pipeline_output.FluxPipelineOutput]]

diffusers.pipelines.flux.pipeline_output.FluxPipelineOutput[[diffusers.pipelines.flux.pipeline_output.FluxPipelineOutput]]

diffusers.pipelines.flux.pipeline_output.FluxPipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray)

Fonte

Parâmetros:

images (list[PIL.Image.Image] ou torch.Tensor ou np.ndarray) : lista de imagens PIL desruidas de comprimento batch_size ou array numpy ou tensor torch de forma (batch_size, height, width, num_channels). Imagens PIL ou array numpy apresentam as imagens desruidas do pipeline de difusão. Tensors torch podem representar tanto as imagens desruidas quanto os latentes intermediários prontos para serem passados ao decodificador.

Classe de saída para pipelines de geração de imagens do Flux.

Xet Storage Details

Size:
19.8 kB
·
Xet hash:
22d66f1cdb46196fac496f816385530fe05cb79baf58ca8b04ab4c2b71433dbd

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.