# ControlNet com Flux.1 FluxControlNetPipeline é uma implementação do ControlNet para Flux.1. ControlNet foi introduzido em [Adding Conditional Control to Text-to-Image Diffusion Models](https://huggingface.co/papers/2302.05543) por Lvmin Zhang, Anyi Rao e Maneesh Agrawala. Com um modelo ControlNet, você pode fornecer uma imagem de controle adicional para condicionar e controlar a geração do Stable Diffusion. Por exemplo, se você fornecer um mapa de profundidade, o modelo ControlNet gera uma imagem que preservará as informações espaciais do mapa de profundidade. É uma maneira mais flexível e precisa de controlar o processo de geração de imagens. O resumo do artigo é: *Apresentamos o ControlNet, uma arquitetura de rede neural para adicionar controles de condicionamento espacial a grandes modelos de difusão de texto para imagem pré-treinados. O ControlNet trava os grandes modelos de difusão prontos para produção e reutiliza suas camadas de codificação profundas e robustas, pré-treinadas com bilhões de imagens, como uma base forte para aprender um conjunto diversificado de controles condicionais. A arquitetura neural é conectada com "convoluções zero" (camadas de convolução inicializadas em zero) que crescem progressivamente os parâmetros a partir de zero e garantem que nenhum ruído prejudicial possa afetar o ajuste fino. Testamos vários controles de condicionamento, por exemplo, bordas, profundidade, segmentação, pose humana, etc., com o Stable Diffusion, usando condições únicas ou múltiplas, com ou sem prompts. Mostramos que o treinamento dos ControlNets é robusto com conjuntos de dados pequenos (<50k) e grandes (>1m). Resultados extensos mostram que o ControlNet pode facilitar aplicações mais amplas para controlar modelos de difusão de imagem.* Este código de controlnet é implementado pela [The InstantX Team](https://huggingface.co/InstantX). Você pode encontrar checkpoints pré-treinados para Flux-ControlNet na tabela abaixo: | Tipo de ControlNet | Desenvolvedor | Link | | -------- | ---------- | ---- | | Canny | [A Equipe InstantX](https://huggingface.co/InstantX) | [Link](https://huggingface.co/InstantX/FLUX.1-dev-Controlnet-Canny) | | Profundidade | [A Equipe InstantX](https://huggingface.co/InstantX) | [Link](https://huggingface.co/Shakker-Labs/FLUX.1-dev-ControlNet-Depth) | | União | [A Equipe InstantX](https://huggingface.co/InstantX) | [Link](https://huggingface.co/InstantX/FLUX.1-dev-Controlnet-Union) | Os ControlNets da XLabs também são suportados, tendo sido contribuídos pela [equipe da XLabs](https://huggingface.co/XLabs-AI). | Tipo de ControlNet | Desenvolvedor | Link | | -------- | ---------- | ---- | | Canny | [A Equipe XLabs](https://huggingface.co/XLabs-AI) | [Link](https://huggingface.co/XLabs-AI/flux-controlnet-canny-diffusers) | | Profundidade | [A Equipe XLabs](https://huggingface.co/XLabs-AI) | [Link](https://huggingface.co/XLabs-AI/flux-controlnet-depth-diffusers) | | HED | [A Equipe XLabs](https://huggingface.co/XLabs-AI) | [Link](https://huggingface.co/XLabs-AI/flux-controlnet-hed-diffusers) | > [!TIP] > Certifique-se de consultar o [guia](../../using-diffusers/schedulers) de Schedulers para aprender a explorar o compromisso entre a velocidade e a qualidade do scheduler, e veja a seção [reutilização de componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a carregar eficientemente os mesmos componentes em vários pipelines. ## FluxControlNetPipeline[[diffusers.FluxControlNetPipeline]] #### diffusers.FluxControlNetPipeline[[diffusers.FluxControlNetPipeline]] ```python diffusers.FluxControlNetPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel, controlnet: diffusers.models.controlnets.controlnet_flux.FluxControlNetModel | list[diffusers.models.controlnets.controlnet_flux.FluxControlNetModel] | tuple[diffusers.models.controlnets.controlnet_flux.FluxControlNetModel] | diffusers.models.controlnets.controlnet_flux.FluxMultiControlNetModel, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_controlnet.py#L177) **Parâmetros:** transformer ([FluxTransformer2DModel](/docs/diffusers/main/pt/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : Arquitetura de Transformer condicional (MMDiT) para desruidar os latentes da imagem codificada. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. vae ([AutoencoderKL](/docs/diffusers/main/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes. text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), especificamente a variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14). text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), especificamente a variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl). tokenizer (`CLIPTokenizer`) : Tokenizer da classe [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer). tokenizer_2 (`T5TokenizerFast`) : Segundo Tokenizer da classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast). O pipeline Flux para geração de imagens a partir de texto. Referência: https://blackforestlabs.ai/announcing-black-forest-labs/ #### __call__[[diffusers.FluxControlNetPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, negative_prompt: str | list[str] = None, negative_prompt_2: str | list[str] | None = None, true_cfg_scale: float = 1.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 7.0, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, control_mode: int | list[int] | None = None, controlnet_conditioning_scale: float | list[float] = 1.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, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_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 = ['latents'], max_sequence_length: int = 512) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_controlnet.py#L677) **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 negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `true_cfg_scale` não for maior que `1`). negative_prompt_2 (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem a serem enviados para `tokenizer_2` e `text_encoder_2`. Se não definido, `negative_prompt` é usado em todos os text-encoders. true_cfg_scale (`float`, *opcional*, padrão 1.0) : A orientação livre de classificador verdadeira (escala de orientação) é ativada quando `true_cfg_scale` > 1 e `negative_prompt` é fornecido. 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. 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](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). 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. control_guidance_start (`float` ou `list[float]`, *opcional*, padrão 0.0) : A porcentagem do total de etapas em que o ControlNet começa a ser aplicado. control_guidance_end (`float` ou `list[float]`, *opcional*, padrão 1.0) : A porcentagem do total de etapas em que o ControlNet para de ser aplicado. 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. controlnet_conditioning_scale (`float` ou `list[float]`, *opcional*, padrão 1.0) : As saídas do ControlNet são multiplicadas por `controlnet_conditioning_scale` antes de serem adicionadas ao residual no `unet` original. Se múltiplos ControlNets forem especificados em `init`, você pode definir a escala correspondente como uma lista. control_mode (`int` ou `list[int]`,, *opcional*, padrão None) : O modo de controle ao aplicar o ControlNet-Union. 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](https://pytorch.org/docs/stable/generated/torch.Generator.html) 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`. negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`. negative_pooled_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não for fornecido, os pooled negative_prompt_embeds serão gerados a partir do argumento de entrada `negative_prompt`. ip_adapter_image : (`PipelineImageInput`, *opcional*): Entrada de imagem opcional para trabalhar com IP Adapters. ip_adapter_image_embeds (`list[torch.Tensor]`, *opcional*) : Embebimentos de imagem pré-gerados para IP-Adapter. Deve ser uma lista com o mesmo comprimento que o número de IP-adapters. Cada elemento deve ser um tensor de forma `(batch_size, num_images, emb_dim)`. Se não for fornecido, os embebimentos são calculados a partir do argumento de entrada `ip_adapter_image`. negative_ip_adapter_image : (`PipelineImageInput`, *opcional*): Entrada de imagem opcional para trabalhar com IP Adapters. negative_ip_adapter_image_embeds (`list[torch.Tensor]`, *opcional*) : Embebimentos de imagem pré-gerados para IP-Adapter. Deve ser uma lista com o mesmo comprimento que o número de IP-adapters. Cada elemento deve ser um tensor de forma `(batch_size, num_images, emb_dim)`. Se não for fornecido, os embebimentos são calculados a partir do argumento de entrada `ip_adapter_image`. output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre [PIL](https://pillow.readthedocs.io/en/stable/): `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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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: ```py >>> import torch >>> from diffusers.utils import load_image >>> from diffusers import FluxControlNetPipeline >>> from diffusers import FluxControlNetModel >>> base_model = "black-forest-labs/FLUX.1-dev" >>> controlnet_model = "InstantX/FLUX.1-dev-controlnet-canny" >>> controlnet = FluxControlNetModel.from_pretrained(controlnet_model, torch_dtype=torch.bfloat16) >>> pipe = FluxControlNetPipeline.from_pretrained( ... base_model, controlnet=controlnet, torch_dtype=torch.bfloat16 ... ) >>> pipe.to("cuda") >>> control_image = load_image("https://huggingface.co/InstantX/SD3-Controlnet-Canny/resolve/main/canny.jpg") >>> prompt = "A girl in city, 25 years old, cool, futuristic" >>> image = pipe( ... prompt, ... control_image=control_image, ... control_guidance_start=0.2, ... control_guidance_end=0.8, ... controlnet_conditioning_scale=1.0, ... num_inference_steps=28, ... guidance_scale=3.5, ... ).images[0] >>> image.save("flux.png") ``` #### encode_prompt[[diffusers.FluxControlNetPipeline.encode_prompt]] ```python 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_controlnet.py#L344) **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]] ```python diffusers.pipelines.flux.pipeline_output.FluxPipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_output.py#L11) **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.