Diffusers documentation

Flux

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

Flux

Flux é uma série de modelos de geração de imagem a partir de texto baseados em transformadores de difusão. Para saber mais sobre o Flux, confira o post original no blog dos criadores do Flux, a Black Forest Labs.

Os checkpoints originais do modelo Flux podem ser encontrados aqui. O código de inferência original pode ser encontrado aqui.

Flux pode ser bastante caro de executar em dispositivos de hardware de consumo. No entanto, você pode 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, confira este gist.

Caching também pode acelerar a inferência ao armazenar e reutilizar saídas intermediárias.

O Flux está disponível nas seguintes variantes:

tipo de modelo	ID do modelo
Timestep destilado	`black-forest-labs/FLUX.1-schnell`
Destilado por orientação	`black-forest-labs/FLUX.1-dev`
Preencher Inpainting/Outpainting (Guidance-distilled)	`black-forest-labs/FLUX.1-Fill-dev`
Canny Control (Guidance destilado)	`black-forest-labs/FLUX.1-Canny-dev`
Controle de Profundidade (Destilado de Orientação)	`black-forest-labs/FLUX.1-Depth-dev`
Canny Control (LoRA)	`black-forest-labs/FLUX.1-Canny-dev-lora`
Controle de Profundidade (LoRA)	`black-forest-labs/FLUX.1-Depth-dev-lora`
Redux (Adaptador)	`black-forest-labs/FLUX.1-Redux-dev`
Kontext	`black-forest-labs/FLUX.1-kontext`

Todos os checkpoints têm usos diferentes, que detalhamos abaixo.

Timestep destilado

max_sequence_length não pode ser maior que 256.
guidance_scale precisa ser 0.
Como este é um modelo destilado em passos de tempo, ele se beneficia de menos etapas de amostragem.

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()

prompt = "A cat holding a sign that says hello world"
out = pipe(
    prompt=prompt,
    guidance_scale=0.,
    height=768,
    width=1360,
    num_inference_steps=4,
    max_sequence_length=256,
).images[0]
out.save("image.png")

Destilado por orientação

A variante destilada por orientação leva cerca de 50 etapas de amostragem para uma geração de boa qualidade.
Ele não possui limitações em relação ao max_sequence_length.

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()

prompt = "a tiny astronaut hatching from an egg on the moon"
out = pipe(
    prompt=prompt,
    guidance_scale=3.5,
    height=768,
    width=1360,
    num_inference_steps=50,
).images[0]
out.save("image.png")

Preencher Inpainting/Outpainting

O pipeline Flux Fill não requer strength como entrada, ao contrário dos pipelines de inpainting regulares.
Ele suporta tanto inpainting quanto outpainting.

import torch
from diffusers import FluxFillPipeline
from diffusers.utils import load_image

image = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup.png")
mask = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup_mask.png")

repo_id = "black-forest-labs/FLUX.1-Fill-dev"
pipe = FluxFillPipeline.from_pretrained(repo_id, dtype=torch.bfloat16).to("cuda")  # or "mps", "xpu", "cpu"

image = pipe(
    prompt="a white paper cup",
    image=image,
    mask_image=mask,
    height=1632,
    width=1232,
    max_sequence_length=512,
    generator=torch.Generator("cpu").manual_seed(0)
).images[0]
image.save(f"output.png")

Canny Control

Observação: black-forest-labs/Flux.1-Canny-dev não é um modelo ControlNetModel. Os modelos ControlNet são um componente separado do UNet/Transformer, cujos resíduos são somados ao modelo subjacente real. O Canny Control é uma arquitetura alternativa que alcança resultados efetivamente iguais aos de um modelo ControlNet, utilizando concatenação por canal com a condição de controle de entrada e garantindo que o transformer aprenda o controle de estrutura seguindo a condição o mais fielmente possível.

# !pip install -U controlnet-aux
import torch
from controlnet_aux import CannyDetector
from diffusers import FluxControlPipeline
from diffusers.utils import load_image

pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-Canny-dev", dtype=torch.bfloat16).to("cuda")  # or "mps", "xpu", "cpu"

prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")

processor = CannyDetector()
control_image = processor(control_image, low_threshold=50, high_threshold=200, detect_resolution=1024, image_resolution=1024)

image = pipe(
    prompt=prompt,
    control_image=control_image,
    height=1024,
    width=1024,
    num_inference_steps=50,
    guidance_scale=30.0,
).images[0]
image.save("output.png")

O Canny Control também é possível com uma variante LoRA desta condição. O uso é o seguinte:

# !pip install -U controlnet-aux
import torch
from controlnet_aux import CannyDetector
from diffusers import FluxControlPipeline
from diffusers.utils import load_image

pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16).to("cuda")  # or "mps", "xpu", "cpu"
pipe.load_lora_weights("black-forest-labs/FLUX.1-Canny-dev-lora")

prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")

processor = CannyDetector()
control_image = processor(control_image, low_threshold=50, high_threshold=200, detect_resolution=1024, image_resolution=1024)

image = pipe(
    prompt=prompt,
    control_image=control_image,
    height=1024,
    width=1024,
    num_inference_steps=50,
    guidance_scale=30.0,
).images[0]
image.save("output.png")

Controle de Profundidade

Observação: black-forest-labs/Flux.1-Depth-dev não é um modelo ControlNet. Modelos ControlNetModel são um componente separado do UNet/Transformer, cujos resíduos são adicionados ao modelo subjacente real. O Depth Control é uma arquitetura alternativa que alcança resultados efetivamente iguais aos de um modelo ControlNet, utilizando concatenação por canal com a condição de controle de entrada e garantindo que o transformer aprenda o controle de estrutura seguindo a condição o mais próximo possível.

# !pip install git+https://github.com/huggingface/image_gen_aux
import torch
from diffusers import FluxControlPipeline, FluxTransformer2DModel
from diffusers.utils import load_image
from image_gen_aux import DepthPreprocessor

pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-Depth-dev", dtype=torch.bfloat16).to("cuda")  # or "mps", "xpu", "cpu"

prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")

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

image = pipe(
    prompt=prompt,
    control_image=control_image,
    height=1024,
    width=1024,
    num_inference_steps=30,
    guidance_scale=10.0,
    generator=torch.Generator().manual_seed(42),
).images[0]
image.save("output.png")

O Controle de Profundidade também é possível com uma variante LoRA desta condição. O uso é o seguinte:

# !pip install git+https://github.com/huggingface/image_gen_aux
import torch
from diffusers import FluxControlPipeline, FluxTransformer2DModel
from diffusers.utils import load_image
from image_gen_aux import DepthPreprocessor

pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16).to("cuda")  # or "mps", "xpu", "cpu"
pipe.load_lora_weights("black-forest-labs/FLUX.1-Depth-dev-lora")

prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")

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

image = pipe(
    prompt=prompt,
    control_image=control_image,
    height=1024,
    width=1024,
    num_inference_steps=30,
    guidance_scale=10.0,
    generator=torch.Generator().manual_seed(42),
).images[0]
image.save("output.png")

Redux

O pipeline Flux Redux é um adaptador para os modelos base FLUX.1. Ele pode ser usado tanto com flux-dev quanto com flux-schnell, para geração de imagem a partir de imagem.
Primeiro, você pode usar o FluxPriorReduxPipeline para obter os prompt_embeds e os pooled_prompt_embeds e, em seguida, inseri-los no FluxPipeline para a geração de imagem a partir de imagem.
Ao usar FluxPriorReduxPipeline com um pipeline base, você pode definir text_encoder=None e text_encoder_2=None no pipeline base, a fim de economizar VRAM.

import torch
from diffusers import FluxPriorReduxPipeline, FluxPipeline
from diffusers.utils import load_image
device = "cuda"  # or "mps", "xpu", "cpu"
dtype = torch.bfloat16


repo_redux = "black-forest-labs/FLUX.1-Redux-dev"
repo_base = "black-forest-labs/FLUX.1-dev" 
pipe_prior_redux = FluxPriorReduxPipeline.from_pretrained(repo_redux, dtype=dtype).to(device)
pipe = FluxPipeline.from_pretrained(
    repo_base, 
    text_encoder=None,
    text_encoder_2=None,
    dtype=torch.bfloat16
).to(device)

image = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/style_ziggy/img5.png")
pipe_prior_output = pipe_prior_redux(image)
images = pipe(
    guidance_scale=2.5,
    num_inference_steps=50,
    generator=torch.Generator("cpu").manual_seed(0),
    **pipe_prior_output,
).images
images[0].save("flux-redux.png")

Kontext

Flux Kontext é um modelo que permite controle em contexto do processo de geração de imagens, possibilitando edição, refinamento, reiluminação, transferência de estilo, personalização de personagens e muito mais.

import torch
from diffusers import FluxKontextPipeline
from diffusers.utils import load_image

pipe = FluxKontextPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-Kontext-dev", dtype=torch.bfloat16
)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png").convert("RGB")
prompt = "Make Pikachu hold a sign that says 'Black Forest Labs is awesome', yarn art style, detailed, vibrant colors"
image = pipe(
    image=image,
    prompt=prompt,
    guidance_scale=2.5,
    generator=torch.Generator().manual_seed(42),
).images[0]
image.save("flux-kontext.png")

O Flux Kontext vem com um verificador de segurança de integridade, que deve ser executado após a etapa de geração de imagem. Para executar o verificador de segurança, instale o repositório oficial de black-forest-labs/flux e adicione o seguinte código:

from flux.content_filters import PixtralContentFilter

# ... pipeline invocation to generate images

integrity_checker = PixtralContentFilter(torch.device("cuda"))
image_ = np.array(image) / 255.0
image_ = 2 * image_ - 1
image_ = torch.from_numpy(image_).to("cuda", dtype=torch.float32).unsqueeze(0).permute(0, 3, 1, 2)
if integrity_checker.test_image(image_):
    raise ValueError("Your image has been flagged. Choose another prompt/image or try again.")

Kontext Inpainting

FluxKontextInpaintPipeline permite a modificação de imagens dentro de uma região de máscara fixa. Atualmente, ele suporta tanto a condicionamento baseado em texto quanto o condicionamento baseado em referência de imagem.

somente texto

condicionamento de imagem

Combinando Flux Turbo LoRAs com Flux Control, Fill e Redux

Podemos combinar Flux Turbo LoRAs com Flux Control e outros pipelines, como Fill e Redux, para habilitar inferência em poucas etapas. O exemplo abaixo mostra como fazer isso para o Flux Control LoRA de profundidade e o turbo LoRA de ByteDance/Hyper-SD.

from diffusers import FluxControlPipeline
from image_gen_aux import DepthPreprocessor
from diffusers.utils import load_image
from huggingface_hub import hf_hub_download
import torch

control_pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16)
control_pipe.load_lora_weights("black-forest-labs/FLUX.1-Depth-dev-lora", adapter_name="depth")
control_pipe.load_lora_weights(
    hf_hub_download("ByteDance/Hyper-SD", "Hyper-FLUX.1-dev-8steps-lora.safetensors"), adapter_name="hyper-sd"
)
control_pipe.set_adapters(["depth", "hyper-sd"], adapter_weights=[0.85, 0.125])
control_pipe.enable_model_cpu_offload()

prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")

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

image = control_pipe(
    prompt=prompt,
    control_image=control_image,
    height=1024,
    width=1024,
    num_inference_steps=8,
    guidance_scale=10.0,
    generator=torch.Generator().manual_seed(42),
).images[0]
image.save("output.png")

Observação sobre unload_lora_weights() ao usar LoRAs do Flux

Ao descarregar os pesos do Control LoRA, chame pipe.unload_lora_weights(reset_to_overwritten_params=True) para redefinir completamente o pipe.transformer para sua forma original. O pipeline resultante pode então ser usado com métodos como DiffusionPipeline.from_pipe(). Mais detalhes sobre este argumento estão disponíveis em este PR.

IP-Adapter

Confira o IP-Adapter para saber mais sobre como os IP-Adapters funcionam.

Um IP-Adapter permite que você use imagens para fazer o prompt do Flux, além do prompt de texto. Isso é especialmente útil ao descrever conceitos complexos que são difíceis de articular apenas por meio de texto e quando você possui imagens de referência.

import torch
from diffusers import FluxPipeline
from diffusers.utils import load_image

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16
).to("cuda")  # or "mps", "xpu", "cpu"

image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flux_ip_adapter_input.jpg").resize((1024, 1024))

pipe.load_ip_adapter(
    "XLabs-AI/flux-ip-adapter",
    weight_name="ip_adapter.safetensors",
    image_encoder_pretrained_model_name_or_path="openai/clip-vit-large-patch14"
)
pipe.set_ip_adapter_scale(1.0)

image = pipe(
    width=1024,
    height=1024,
    prompt="wearing sunglasses",
    negative_prompt="",
    true_cfg_scale=4.0,
    generator=torch.Generator().manual_seed(4444),
    ip_adapter_image=image,
).images[0]

image.save('flux_ip_adapter_output.jpg')

Exemplos de IP-Adapter com o prompt "wearing sunglasses"

Otimizar

Flux é um modelo muito grande e requer ~50GB de RAM/VRAM para carregar todos os componentes de modelagem. Ative algumas das otimizações abaixo para reduzir os requisitos de memória.

Descarregamento em grupo

Group offloading reduz o uso de VRAM ao transferir grupos de camadas internas para fora da GPU, em vez de transferir o modelo inteiro ou os pesos. É necessário usar apply_group_offloading() em todos os componentes do modelo de um pipeline. O parâmetro offload_type permite alternar entre offloading em nível de bloco e em nível de folha. Ao defini-lo como leaf_level, os parâmetros de nível de folha mais baixos são transferidos para a CPU, em vez de serem transferidos em nível de módulo.

Em dispositivos CUDA que suportam streaming de dados assíncrono, defina use_stream=True para sobrepor a transferência de dados e o cálculo, acelerando a inferência.

É possível misturar o offloading em nível de bloco e em nível de folha para diferentes componentes em um pipeline.

import torch
from diffusers import FluxPipeline
from diffusers.hooks import apply_group_offloading

model_id = "black-forest-labs/FLUX.1-dev"
dtype = torch.bfloat16
pipe = FluxPipeline.from_pretrained(
	model_id,
	dtype=dtype,
)

apply_group_offloading(
    pipe.transformer,
    offload_type="leaf_level",
    offload_device=torch.device("cpu"),
    onload_device=torch.device("cuda"),
    use_stream=True,
)
apply_group_offloading(
    pipe.text_encoder, 
    offload_device=torch.device("cpu"),
    onload_device=torch.device("cuda"),
    offload_type="leaf_level",
    use_stream=True,
)
apply_group_offloading(
    pipe.text_encoder_2, 
    offload_device=torch.device("cpu"),
    onload_device=torch.device("cuda"),
    offload_type="leaf_level",
    use_stream=True,
)
apply_group_offloading(
    pipe.vae, 
    offload_device=torch.device("cpu"),
    onload_device=torch.device("cuda"),
    offload_type="leaf_level",
    use_stream=True,
)

prompt="A cat wearing sunglasses and working as a lifeguard at pool."

generator = torch.Generator().manual_seed(181201)
image = pipe(
    prompt,
    width=576,
    height=1024,
    num_inference_steps=30,
    generator=generator
).images[0]
image

Executando inferência em FP16

Flux pode gerar imagens de alta qualidade com FP16 (ou seja, para acelerar a inferência em GPUs Turing/Volta), mas produz saídas diferentes em comparação com FP32/BF16. O problema é que algumas ativações nos codificadores de texto precisam ser limitadas (clipped) ao executar em FP16, o que afeta a imagem geral. Forçar os codificadores de texto a executar com inferência em FP32, portanto, remove essa diferença de saída. Veja aqui para mais detalhes.

Código de inferência em FP16:

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", dtype=torch.bfloat16) # can replace schnell with dev
# to run on low vram GPUs (i.e. between 4 and 32 GB VRAM)
pipe.enable_sequential_cpu_offload()
pipe.vae.enable_slicing()
pipe.vae.enable_tiling()

pipe.to(torch.float16) # casting here instead of in the pipeline constructor because doing so in the constructor loads all models into CPU memory at once

prompt = "A cat holding a sign that says hello world"
out = pipe(
    prompt=prompt,
    guidance_scale=0.,
    height=768,
    width=1360,
    num_inference_steps=4,
    max_sequence_length=256,
).images[0]
out.save("image.png")

Quantização

A quantização ajuda a reduzir os requisitos de memória de modelos muito grandes armazenando os pesos do modelo em um tipo de dados de menor precisão. No entanto, a quantização pode ter um impacto variável na qualidade do vídeo, dependendo do modelo de vídeo.

Consulte a visão geral de Quantization para saber mais sobre os backends de quantização suportados e sobre como selecionar um backend de quantização que atenda ao seu caso de uso. O exemplo abaixo demonstra como carregar um FluxPipeline quantizado para inferência com bitsandbytes.

import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, FluxTransformer2DModel, FluxPipeline
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel

quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = T5EncoderModel.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    subfolder="text_encoder_2",
    quantization_config=quant_config,
    dtype=torch.float16,
)

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = FluxTransformer2DModel.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.float16,
)

pipeline = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    text_encoder_2=text_encoder_8bit,
    transformer=transformer_8bit,
    dtype=torch.float16,
    device_map="balanced",
)

prompt = "a tiny astronaut hatching from an egg on the moon"
image = pipeline(prompt, guidance_scale=3.5, height=768, width=1360, num_inference_steps=50).images[0]
image.save("flux.png")

Carregamento de arquivo único para o FluxTransformer2DModel

O FluxTransformer2DModel suporta o carregamento de checkpoints no formato original distribuído pela Black Forest Labs. Isso também é útil ao tentar carregar versões finetunadas ou quantizadas dos modelos publicadas pela comunidade.

A inferência com FP8 pode ser instável, dependendo do tipo de GPU, da versão do CUDA e da versão do torch que você está usando. Recomenda-se usar a biblioteca optimum-quanto para executar a inferência FP8 na sua máquina.

O exemplo a seguir demonstra como executar o Flux com menos de 16GB de VRAM.

Primeiro, instale optimum-quanto

pip install optimum-quanto

Em seguida, execute o exemplo a seguir

import torch
from diffusers import FluxTransformer2DModel, FluxPipeline
from transformers import T5EncoderModel, CLIPTextModel
from optimum.quanto import freeze, qfloat8, quantize

bfl_repo = "black-forest-labs/FLUX.1-dev"
dtype = torch.bfloat16

transformer = FluxTransformer2DModel.from_single_file("https://huggingface.co/Kijai/flux-fp8/blob/main/flux1-dev-fp8.safetensors", dtype=dtype)
quantize(transformer, weights=qfloat8)
freeze(transformer)

text_encoder_2 = T5EncoderModel.from_pretrained(bfl_repo, subfolder="text_encoder_2", dtype=dtype)
quantize(text_encoder_2, weights=qfloat8)
freeze(text_encoder_2)

pipe = FluxPipeline.from_pretrained(bfl_repo, transformer=None, text_encoder_2=None, dtype=dtype)
pipe.transformer = transformer
pipe.text_encoder_2 = text_encoder_2

pipe.enable_model_cpu_offload()

prompt = "A cat holding a sign that says hello world"
image = pipe(
    prompt,
    guidance_scale=3.5,
    output_type="pil",
    num_inference_steps=20,
    generator=torch.Generator("cpu").manual_seed(0)
).images[0]

image.save("flux-fp8-dev.png")

Diffusers

Flux

Timestep destilado

Destilado por orientação

Preencher Inpainting/Outpainting

Canny Control

Controle de Profundidade

Redux

Kontext

Kontext Inpainting

Combinando Flux Turbo LoRAs com Flux Control, Fill e Redux

Observação sobre unload_lora_weights() ao usar LoRAs do Flux

IP-Adapter

Otimizar

Descarregamento em grupo

Executando inferência em FP16

Quantização

Carregamento de arquivo único para o FluxTransformer2DModel

FluxPipeline

classe diffusers.FluxPipeline

__call__

encode_prompt

FluxImg2ImgPipeline

classe diffusers.FluxImg2ImgPipeline

__call__

encode_prompt

FluxInpaintPipeline

classe diffusers.FluxInpaintPipeline

__call__

encode_prompt

FluxControlNetInpaintPipeline

classe diffusers.FluxControlNetInpaintPipeline

__call__

encode_prompt

FluxControlNetImg2ImgPipeline

classe diffusers.FluxControlNetImg2ImgPipeline

__call__

encode_prompt

FluxControlPipeline

classe diffusers.FluxControlPipeline

__call__

encode_prompt

FluxControlImg2ImgPipeline

classe diffusers.FluxControlImg2ImgPipeline

__call__

encode_prompt

FluxPriorReduxPipeline

classe diffusers.FluxPriorReduxPipeline

__call__

encode_prompt

FluxFillPipeline

classe diffusers.FluxFillPipeline

__call__

encode_prompt

FluxKontextPipeline

classe diffusers.FluxKontextPipeline

__call__

encode_prompt

FluxKontextInpaintPipeline

classe diffusers.FluxKontextInpaintPipeline

__call__

Inpainting apenas com texto

Inpainting com condicionamento por imagem

encode_prompt

call

call

call

call

call

call

call

call

call

call

call