Diffusers documentation
Flux
Flux
Flux es una serie de modelos de generación de imágenes a partir de texto basados en transformadores de difusión. Para conocer más sobre Flux, consulta el post de blog original de los creadores de Flux, Black Forest Labs.
Los puntos de control originales del modelo Flux se pueden encontrar aquí. El código de inferencia original se puede encontrar aquí.
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.
La caché también puede acelerar la inferencia almacenando y reutilizando salidas intermedias.
Flux está disponible en las siguientes variantes:
| tipo de modelo | id del modelo |
|---|---|
| Destilado por paso de tiempo | black-forest-labs/FLUX.1-schnell |
| Destilado por guía | black-forest-labs/FLUX.1-dev |
| Relleno Inpainting/Outpainting (Destilado de guía) | black-forest-labs/FLUX.1-Fill-dev |
| Control Canny (Guía destilada) | black-forest-labs/FLUX.1-Canny-dev |
| Control de profundidad (destilado de orientación) | black-forest-labs/FLUX.1-Depth-dev |
| Control Canny (LoRA) | black-forest-labs/FLUX.1-Canny-dev-lora |
| Control de profundidad (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 los puntos de control tienen un uso diferente, que detallamos a continuación.
Destilado por paso de tiempo
max_sequence_lengthno puede ser mayor que 256.guidance_scaledebe ser 0.- Dado que se trata de un modelo destilado en pasos de tiempo, se beneficia de un menor número de pasos de muestreo.
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 guía
- La variante destilada con guía requiere aproximadamente 50 pasos de muestreo para una generación de buena calidad.
- No tiene ninguna limitación en torno a
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")Relleno Inpainting/Outpainting
- El pipeline Flux Fill no requiere
strengthcomo entrada, a diferencia de los pipelines de inpainting habituales. - Admite tanto el inpainting como el 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")Control Canny
Nota: black-forest-labs/Flux.1-Canny-dev no es un modelo ControlNetModel. Los modelos ControlNet son un componente separado del UNet/Transformer, cuyos residuos se suman al modelo subyacente real. Canny Control es una arquitectura alternativa que logra resultados efectivamente iguales a los de un modelo ControlNet, mediante la concatenación por canales con la condición de control de entrada y asegurando que el transformer aprenda el control de estructura siguiendo la condición lo más fielmente posible.
# !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")El control Canny también es posible con una variante LoRA de esta condición. El uso es el siguiente:
# !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")Control de profundidad
Nota: black-forest-labs/Flux.1-Depth-dev no es un modelo de ControlNet. Los modelos ControlNetModel son un componente separado del UNet/Transformer, cuyos residuos se suman al modelo subyacente real. Depth Control es una arquitectura alternativa que logra resultados efectivamente iguales a los de un modelo ControlNet, mediante la concatenación por canales con la condición de control de entrada y asegurando que el transformer aprenda el control de estructura siguiendo la condición lo más fielmente posible.
# !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")El control de profundidad también es posible con una variante LoRA de esta condición. El uso es el siguiente:
# !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
- El pipeline Flux Redux es un adaptador para los modelos base de FLUX.1. Puede usarse tanto con flux-dev como con flux-schnell, para la generación de imagen a imagen.
- Primero puede usar
FluxPriorReduxPipelinepara obtenerprompt_embedsypooled_prompt_embeds, y luego pasarlos aFluxPipelinepara la generación de imagen a imagen. - Al usar
FluxPriorReduxPipelinecon un pipeline base, puedes establecertext_encoder=Noneytext_encoder_2=Noneen el pipeline base para ahorrar 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 es un modelo que permite el control en contexto del proceso de generación de imágenes, lo que facilita la edición, el refinamiento, el reiluminado, la transferencia de estilo, la personalización de personajes y mucho más.
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")Flux Kontext incluye un verificador de seguridad de integridad, que debe ejecutarse después del paso de generación de imágenes. Para ejecutar el verificador de seguridad, instale el repositorio oficial de black-forest-labs/flux y agregue el siguiente 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 modificar imágenes dentro de una región de máscara fija. Actualmente, admite tanto el condicionamiento basado en texto como el condicionamiento basado en una imagen de referencia.
import torch
from diffusers import FluxKontextInpaintPipeline
from diffusers.utils import load_image
prompt = "Change the yellow dinosaur to green one"
img_url = (
"https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/dinosaur_input.jpeg?raw=true"
)
mask_url = (
"https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/dinosaur_mask.png?raw=true"
)
source = load_image(img_url)
mask = load_image(mask_url)
pipe = FluxKontextInpaintPipeline.from_pretrained(
"black-forest-labs/FLUX.1-Kontext-dev", dtype=torch.bfloat16
)
pipe.to("cuda") # or "mps", "xpu", "cpu"
image = pipe(prompt=prompt, image=source, mask_image=mask, strength=1.0).images[0]
image.save("kontext_inpainting_normal.png")import torch
from diffusers import FluxKontextInpaintPipeline
from diffusers.utils import load_image
pipe = FluxKontextInpaintPipeline.from_pretrained(
"black-forest-labs/FLUX.1-Kontext-dev", dtype=torch.bfloat16
)
pipe.to("cuda") # or "mps", "xpu", "cpu"
prompt = "Replace this ball"
img_url = "https://images.pexels.com/photos/39362/the-ball-stadion-football-the-pitch-39362.jpeg?auto=compress&cs=tinysrgb&dpr=1&w=500"
mask_url = "https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/ball_mask.png?raw=true"
image_reference_url = "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTah3x6OL_ECMBaZ5ZlJJhNsyC-OSMLWAI-xw&s"
source = load_image(img_url)
mask = load_image(mask_url)
image_reference = load_image(image_reference_url)
mask = pipe.mask_processor.blur(mask, blur_factor=12)
image = pipe(
prompt=prompt, image=source, mask_image=mask, image_reference=image_reference, strength=1.0
).images[0]
image.save("kontext_inpainting_ref.png")Combinar Flux Turbo LoRAs con Flux Control, Fill y Redux
Podemos combinar Flux Turbo LoRAs con Flux Control y otros pipelines como Fill y Redux para habilitar la inferencia en pocos pasos. El ejemplo de abajo muestra cómo hacerlo para Flux Control LoRA para profundidad y 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")Nota sobre unload_lora_weights() al usar LoRAs de Flux
Al descargar los pesos de Control LoRA, llama a pipe.unload_lora_weights(reset_to_overwritten_params=True) para restablecer por completo pipe.transformer a su forma original. El pipeline resultante puede utilizarse entonces con métodos como DiffusionPipeline.from_pipe(). Más detalles sobre este argumento están disponibles en esta PR.
IP-Adapter
Consulte IP-Adapter para obtener más información sobre cómo funcionan los IP-Adapters.
Un IP-Adapter te permite usar imágenes como prompt para Flux, además del prompt de texto. Esto resulta especialmente útil al describir conceptos complejos que son difíciles de articular solo con texto y dispones de imágenes de referencia.
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')
Optimizar
Flux es un modelo muy grande y requiere ~50GB de RAM/VRAM para cargar todos los componentes de modelado. Habilite algunas de las optimizaciones siguientes para reducir los requisitos de memoria.
Descarga de grupos
Group offloading reduce el uso de VRAM al descargar grupos de capas internas en lugar de todo el modelo o los pesos. Debe usar apply_group_offloading() en todos los componentes del modelo de un pipeline. El parámetro offload_type le permite alternar entre la descarga a nivel de bloque y a nivel de hoja. Si se establece en leaf_level, se descargan los parámetros de nivel de hoja más bajo a la CPU en lugar de descargarlos a nivel de módulo.
En dispositivos CUDA que admiten el flujo de datos asíncrono, establezca use_stream=True para superponer la transferencia de datos y el cálculo, acelerando así la inferencia.
Es posible combinar el descargado a nivel de bloque y a nivel de hoja para diferentes componentes en una tubería.
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]
imageEjecución de inferencia en FP16
Flux puede generar imágenes de alta calidad con FP16 (es decir, para acelerar la inferencia en GPUs Turing/Volta), pero produce salidas diferentes en comparación con FP32/BF16. El problema es que algunas activaciones en los codificadores de texto deben recortarse al ejecutar en FP16, lo que afecta a la imagen en general. Forzar a los codificadores de texto para que se ejecuten con inferencia en FP32 elimina así esta diferencia de salida. Consulte aquí para más detalles.
Código de inferencia 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")Cuantización
La cuantización ayuda a reducir los requisitos de memoria de los modelos muy grandes almacenando los pesos del modelo en un tipo de datos de menor precisión. Sin embargo, la cuantización puede tener un impacto variable en la calidad del vídeo dependiendo del modelo de vídeo.
Consulte el resumen de Quantization para obtener más información sobre los backends de cuantización admitidos y sobre cómo seleccionar un backend de cuantización que admita su caso de uso. El siguiente ejemplo muestra cómo cargar un FluxPipeline cuantizado para inferencia con 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")Carga de un solo archivo para el FluxTransformer2DModel
El FluxTransformer2DModel admite la carga de puntos de control en el formato original distribuido por Black Forest Labs. Esto también resulta útil al intentar cargar versiones afinadas o cuantizadas de los modelos publicadas por la comunidad.
La inferencia con
FP8puede ser frágil dependiendo del tipo de GPU, la versión de CUDA y la versión detorchque estés utilizando. Se recomienda usar la bibliotecaoptimum-quantopara ejecutar la inferencia FP8 en tu máquina.
El siguiente ejemplo demuestra cómo ejecutar Flux con menos de 16 GB de VRAM.
Primero, instala optimum-quanto
pip install optimum-quanto
Luego, ejecuta el siguiente ejemplo
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")FluxPipeline
clase diffusers.FluxPipeline
< source >( scheduler: FlowMatchEulerDiscreteSchedulervae: AutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizertext_encoder_2: T5EncoderModeltokenizer_2: T5Tokenizertransformer: FluxTransformer2DModelimage_encoder: CLIPVisionModelWithProjection = Nonefeature_extractor: CLIPImageProcessorPil = None )
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
transformerpara 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 la generación de imágenes a partir de texto.
Referencia: https://blackforestlabs.ai/announcing-black-forest-labs/
__call__
< source >( prompt: str | list[str] = Noneprompt_2: str | list[str] | None = Nonenegative_prompt: str | list[str] = Nonenegative_prompt_2: str | list[str] | None = Nonetrue_cfg_scale: float = 1.0height: int | None = Nonewidth: int | None = Nonenum_inference_steps: int = 28sigmas: list[float] | None = Noneguidance_scale: float = 3.5num_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] = Noneip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Noneip_adapter_image_embeds: list[torch.Tensor] | None = Nonenegative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Nonenegative_ip_adapter_image_embeds: list[torch.Tensor] | None = Nonenegative_prompt_embeds: typing.Optional[torch.FloatTensor] = Nonenegative_pooled_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 (
strolist[str], opcional) — El prompt o los prompts para guiar la generación de la imagen. Si no se define, hay que pasarprompt_embedsen su lugar. - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán atokenizer_2ytext_encoder_2. Si no está definido, se utilizaráprompten su lugar. - negative_prompt (
strolist[str], opcional) — El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasarnegative_prompt_embedsen su lugar. Se ignora cuando no se usa guía (es decir, se ignora sitrue_cfg_scaleno es mayor que1). - negative_prompt_2 (
strolist[str], opcional) — El prompt o prompts que no deben guiar la generación de la imagen y que se enviarán atokenizer_2ytext_encoder_2. Si no se define, se utilizanegative_prompten todos los text-encoders. - true_cfg_scale (
float, opcional, valor predeterminado 1.0) — La guía libre de clasificador real (escala de guía) se habilita cuandotrue_cfg_scale> 1 y se proporcionanegative_prompt. - 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. - 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 argumentosigmasen su métodoset_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pasenum_inference_steps. - guidance_scale (
float, opcional, valor predeterminado 3.5) — La escala de orientación integrada se habilita al establecerguidance_scale> 1. Valores más altos deguidance_scaleaniman al modelo a generar imágenes más alineadas con laprompt, a costa de una menor calidad de imagen.Los modelos destilados con guía aproximan la guía libre de clase real para
guidance_scale> 1. Consulte el artículo para obtener más información. - num_images_per_prompt (
int, opcional, valor predeterminado 1) — El número de imágenes que se generarán por indicación. - generator (
torch.Generatorolist[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 elgeneratoraleatorio 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 entradaprompt. - 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 entradaprompt. - ip_adapter_image — (
PipelineImageInput, opcional): Entrada de imagen opcional para trabajar con IP Adapters. - ip_adapter_image_embeds (
list[torch.Tensor], opcional) — Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma(batch_size, num_images, emb_dim). Si no se proporciona, las incrustaciones se calculan a partir del argumento de entradaip_adapter_image. - negative_ip_adapter_image —
(
PipelineImageInput, opcional): Entrada de imagen opcional para trabajar con IP Adapters. - negative_ip_adapter_image_embeds (
list[torch.Tensor], opcional) — Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma(batch_size, num_images, emb_dim). Si no se proporciona, las incrustaciones se calculan a partir del argumento de entradaip_adapter_image. - negative_prompt_embeds (
torch.FloatTensor, opcional) — Incrustaciones de texto negativo pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entradanegative_prompt. - negative_pooled_prompt_embeds (
torch.FloatTensor, opcional) — Incrustaciones de texto negativo agrupadas pregeneradas. Se pueden utilizar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, se generarán pooled negative_prompt_embeds a partir del argumento de entradanegative_prompt. - output_type (
str, opcional, valor predeterminado"pil") — El formato de salida de la imagen generada. Elija entre PIL:PIL.Image.Imageonp.array. - return_dict (
bool, opcional, valor predeterminadoTrue) — Indica si se debe devolver un~pipelines.flux.FluxPipelineOutputen lugar de una tupla simple. - joint_attention_kwargs (
dict, opcional) — Un diccionario de kwargs que, si se especifica, se pasa alAttentionProcessordefinido enself.processordentro 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_kwargsincluirá una lista de todos los tensores especificados porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — La lista de entradas de tensor para la funcióncallback_on_step_end. Los tensores especificados en la lista se pasarán como argumentocallback_kwargs. Solo podrás incluir variables listadas en el atributo._callback_tensor_inputsde tu clase de pipeline. - max_sequence_length (
intpor defecto 512) — Longitud máxima de la secuencia para usar con elprompt.
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 FluxPipeline
>>> pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "A cat holding a sign that says hello world"
>>> # Depending on the variant being used, the pipeline call will slightly vary.
>>> # Refer to the pipeline documentation for more details.
>>> image = pipe(prompt, num_inference_steps=4, guidance_scale=0.0).images[0]
>>> image.save("flux.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 (
strolist[str], opcional) — prompt a codificar - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán altokenizer_2y altext_encoder_2. Si no se define, se utilizaprompten 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 entradaprompt. - 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 entradaprompt. - lora_scale (
float, opcional) — Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.
FluxImg2ImgPipeline
clase diffusers.FluxImg2ImgPipeline
< source >( scheduler: FlowMatchEulerDiscreteSchedulervae: AutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizertext_encoder_2: T5EncoderModeltokenizer_2: T5Tokenizertransformer: FluxTransformer2DModelimage_encoder: CLIPVisionModelWithProjection = Nonefeature_extractor: CLIPImageProcessorPil = None )
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
transformerpara 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 inpainting de imágenes.
Referencia: https://blackforestlabs.ai/announcing-black-forest-labs/
__call__
< source >( prompt: str | list[str] = Noneprompt_2: str | list[str] | None = Nonenegative_prompt: str | list[str] = Nonenegative_prompt_2: str | list[str] | None = Nonetrue_cfg_scale: float = 1.0image: 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] = Noneip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Noneip_adapter_image_embeds: list[torch.Tensor] | None = Nonenegative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Nonenegative_ip_adapter_image_embeds: list[torch.Tensor] | None = Nonenegative_prompt_embeds: typing.Optional[torch.FloatTensor] = Nonenegative_pooled_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 (
strolist[str], opcional) — El prompt o los prompts para guiar la generación de la imagen. Si no se define, hay que pasarprompt_embedsen su lugar. - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán atokenizer_2ytext_encoder_2. Si no está definido, se utilizaráprompten su lugar - negative_prompt (
strolist[str], opcional) — El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasarnegative_prompt_embedsen su lugar. Se ignora cuando no se usa guía (es decir, se ignora sitrue_cfg_scaleno es mayor que1). - negative_prompt_2 (
strolist[str], opcional) — El prompt o prompts que no deben guiar la generación de la imagen y que se enviarán atokenizer_2ytext_encoder_2. Si no se define, se utilizanegative_prompten todos los text-encoders. - true_cfg_scale (
float, opcional, valor predeterminado 1.0) — La guía libre de clasificador real (escala de guía) se habilita cuandotrue_cfg_scale> 1 y se proporcionanegative_prompt. - image (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image]olist[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 comoimage, pero si se pasan latentes directamente, no se vuelven a codificar. - 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 laimagede referencia. Debe estar entre 0 y 1.imagese utiliza como punto de partida y se añade más ruido a medida que aumenta elstrength. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuandostrengthes 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado ennum_inference_steps. Un valor de 1 ignora esencialmenteimage. - 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 argumentosigmasen su métodoset_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pasenum_inference_steps. - guidance_scale (
float, opcional, valor predeterminado 7.0) — Escala de guía definida en Classifier-Free Diffusion Guidance.guidance_scalese define comowde la ecuación 2 del Imagen Paper. La escala de guía se habilita estableciendoguidance_scale > 1. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas alpromptde 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.Generatorolist[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 elgeneratoraleatorio 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 entradaprompt. - 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 entradaprompt. - negative_prompt_embeds (
torch.FloatTensor, opcional) — Incrustaciones de texto negativo pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entradanegative_prompt. - negative_pooled_prompt_embeds (
torch.FloatTensor, opcional) — Incrustaciones de texto negativo agrupadas pregeneradas. Se pueden utilizar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, se generarán pooled negative_prompt_embeds a partir del argumento de entradanegative_prompt. - ip_adapter_image — (
PipelineImageInput, opcional): Entrada de imagen opcional para trabajar con IP Adapters. - ip_adapter_image_embeds (
list[torch.Tensor], opcional) — Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma(batch_size, num_images, emb_dim). Si no se proporciona, las incrustaciones se calculan a partir del argumento de entradaip_adapter_image. - negative_ip_adapter_image —
(
PipelineImageInput, opcional): Entrada de imagen opcional para trabajar con IP Adapters. - negative_ip_adapter_image_embeds (
list[torch.Tensor], opcional) — Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma(batch_size, num_images, emb_dim). Si no se proporciona, las incrustaciones se calculan a partir del argumento de entradaip_adapter_image. - output_type (
str, opcional, valor predeterminado"pil") — El formato de salida de la imagen generada. Elija entre PIL:PIL.Image.Imageonp.array. - return_dict (
bool, opcional, valor predeterminadoTrue) — Indica si se debe devolver un~pipelines.flux.FluxPipelineOutputen lugar de una tupla simple. - joint_attention_kwargs (
dict, opcional) — Un diccionario de kwargs que, si se especifica, se pasa alAttentionProcessordefinido enself.processordentro 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_kwargsincluirá una lista de todos los tensores especificados porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — La lista de entradas de tensor para la funcióncallback_on_step_end. Los tensores especificados en la lista se pasarán como argumentocallback_kwargs. Solo podrás incluir variables listadas en el atributo._callback_tensor_inputsde tu clase de pipeline. - max_sequence_length (
intpor defecto 512) — Longitud máxima de la secuencia para usar con elprompt.
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 FluxImg2ImgPipeline
>>> from diffusers.utils import load_image
>>> device = "cuda"
>>> pipe = FluxImg2ImgPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16)
>>> pipe = pipe.to(device)
>>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
>>> init_image = load_image(url).resize((1024, 1024))
>>> prompt = "cat wizard, gandalf, lord of the rings, detailed, fantasy, cute, adorable, Pixar, Disney, 8k"
>>> images = pipe(
... prompt=prompt, image=init_image, num_inference_steps=4, strength=0.95, guidance_scale=0.0
... ).images[0]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 (
strolist[str], opcional) — prompt a codificar - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán altokenizer_2y altext_encoder_2. Si no se define, se utilizaprompten 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 entradaprompt. - 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 entradaprompt. - lora_scale (
float, opcional) — Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.
FluxInpaintPipeline
clase diffusers.FluxInpaintPipeline
< source >( scheduler: FlowMatchEulerDiscreteSchedulervae: AutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizertext_encoder_2: T5EncoderModeltokenizer_2: T5Tokenizertransformer: FluxTransformer2DModelimage_encoder: CLIPVisionModelWithProjection = Nonefeature_extractor: CLIPImageProcessorPil = None )
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
transformerpara 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 inpainting de imágenes.
Referencia: https://blackforestlabs.ai/announcing-black-forest-labs/
__call__
< source >( prompt: str | list[str] = Noneprompt_2: str | list[str] | None = Nonenegative_prompt: str | list[str] = Nonenegative_prompt_2: str | list[str] | None = Nonetrue_cfg_scale: float = 1.0image: 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 = Nonepadding_mask_crop: 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] = Noneip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Noneip_adapter_image_embeds: list[torch.Tensor] | None = Nonenegative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Nonenegative_ip_adapter_image_embeds: list[torch.Tensor] | None = Nonenegative_prompt_embeds: typing.Optional[torch.FloatTensor] = Nonenegative_pooled_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 (
strolist[str], opcional) — El prompt o los prompts para guiar la generación de la imagen. Si no se define, hay que pasarprompt_embedsen su lugar. - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán atokenizer_2ytext_encoder_2. Si no está definido, se utilizaráprompten su lugar - negative_prompt (
strolist[str], opcional) — El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasarnegative_prompt_embedsen su lugar. Se ignora cuando no se usa guía (es decir, se ignora sitrue_cfg_scaleno es mayor que1). - negative_prompt_2 (
strolist[str], opcional) — El prompt o prompts que no deben guiar la generación de la imagen y que se enviarán atokenizer_2ytext_encoder_2. Si no se define, se utilizanegative_prompten todos los text-encoders. - true_cfg_scale (
float, opcional, valor predeterminado 1.0) — La guía libre de clasificador real (escala de guía) se habilita cuandotrue_cfg_scale> 1 y se proporcionanegative_prompt. - image (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image]olist[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 comoimage, pero si se pasan latentes directamente, no se vuelven a codificar. - mask_image (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image]olist[np.ndarray]) —Image, array de numpy o tensor que representa un lote de imágenes para enmascararimage. Los píxeles blancos de la máscara se repintan, mientras que los píxeles negros se conservan. Simask_imagees 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]) —Tensorque representa un lote de imágenes para enmascarar laimagegenerada por el VAE. Si no se proporciona, el tensor de latentes de la máscara se generará mediantemask_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. - padding_mask_crop (
int, opcional, valor predeterminadoNone) — El tamaño del margen en el recorte que se aplicará a la imagen y la máscara. Si esNone, no se aplica ningún recorte a image y mask_image. Sipadding_mask_cropno esNone, primero se busca una región rectangular con la misma relación de aspecto que la imagen y que contenga toda el área enmascarada, y luego se expande esa área en función depadding_mask_crop. A continuación, la imagen y mask_image se recortan según el área expandida antes de redimensionarlas al tamaño original de la imagen para el inpainting. Esto es útil cuando el área enmascarada es pequeña mientras que la imagen es grande y contiene información irrelevante para el inpainting, como el fondo. - strength (
float, opcional, valor predeterminado 1.0) — Indica el grado en que se transforma laimagede referencia. Debe estar entre 0 y 1.imagese utiliza como punto de partida y se añade más ruido a medida que aumenta elstrength. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuandostrengthes 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado ennum_inference_steps. Un valor de 1 ignora esencialmenteimage. - 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 argumentosigmasen su métodoset_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pasenum_inference_steps. - guidance_scale (
float, opcional, valor predeterminado 7.0) — Escala de guía definida en Classifier-Free Diffusion Guidance.guidance_scalese define comowde la ecuación 2 del Imagen Paper. La escala de guía se habilita estableciendoguidance_scale > 1. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas alpromptde 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.Generatorolist[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 elgeneratoraleatorio 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 entradaprompt. - 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 entradaprompt. - negative_prompt_embeds (
torch.FloatTensor, opcional) — Incrustaciones de texto negativo pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entradanegative_prompt. - negative_pooled_prompt_embeds (
torch.FloatTensor, opcional) — Incrustaciones de texto negativo agrupadas pregeneradas. Se pueden utilizar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, se generarán pooled negative_prompt_embeds a partir del argumento de entradanegative_prompt. - ip_adapter_image — (
PipelineImageInput, opcional): Entrada de imagen opcional para trabajar con IP Adapters. - ip_adapter_image_embeds (
list[torch.Tensor], opcional) — Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma(batch_size, num_images, emb_dim). Si no se proporciona, las incrustaciones se calculan a partir del argumento de entradaip_adapter_image. - negative_ip_adapter_image —
(
PipelineImageInput, opcional): Entrada de imagen opcional para trabajar con IP Adapters. - negative_ip_adapter_image_embeds (
list[torch.Tensor], opcional) — Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma(batch_size, num_images, emb_dim). Si no se proporciona, las incrustaciones se calculan a partir del argumento de entradaip_adapter_image. - output_type (
str, opcional, valor predeterminado"pil") — El formato de salida de la imagen generada. Elija entre PIL:PIL.Image.Imageonp.array. - return_dict (
bool, opcional, valor predeterminadoTrue) — Indica si se debe devolver un~pipelines.flux.FluxPipelineOutputen lugar de una tupla simple. - joint_attention_kwargs (
dict, opcional) — Un diccionario de kwargs que, si se especifica, se pasa alAttentionProcessordefinido enself.processordentro 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_kwargsincluirá una lista de todos los tensores especificados porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — La lista de entradas de tensor para la funcióncallback_on_step_end. Los tensores especificados en la lista se pasarán como argumentocallback_kwargs. Solo podrás incluir variables listadas en el atributo._callback_tensor_inputsde tu clase de pipeline. - max_sequence_length (
intpor defecto 512) — Longitud máxima de la secuencia para usar con elprompt.
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 FluxInpaintPipeline
>>> from diffusers.utils import load_image
>>> pipe = FluxInpaintPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "Face of a yellow cat, high resolution, sitting on a park bench"
>>> img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
>>> mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"
>>> source = load_image(img_url)
>>> mask = load_image(mask_url)
>>> image = pipe(prompt=prompt, image=source, mask_image=mask).images[0]
>>> image.save("flux_inpainting.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 (
strolist[str], opcional) — prompt a codificar - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán altokenizer_2y altext_encoder_2. Si no se define, se utilizaprompten 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 entradaprompt. - 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 entradaprompt. - lora_scale (
float, opcional) — Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.
FluxControlNetInpaintPipeline
clase diffusers.FluxControlNetInpaintPipeline
< source >( scheduler: FlowMatchEulerDiscreteSchedulervae: AutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizertext_encoder_2: T5EncoderModeltokenizer_2: T5Tokenizertransformer: FluxTransformer2DModelcontrolnet: 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 )
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
transformerpara 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 controlnet de Flux para inpainting.
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]] = 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]] = Nonecontrol_image: 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.6padding_mask_crop: int | None = Nonesigmas: list[float] | None = Nonenum_inference_steps: int = 28guidance_scale: float = 7.0control_guidance_start: float | list[float] = 0.0control_guidance_end: float | list[float] = 1.0control_mode: int | list[int] | None = Nonecontrolnet_conditioning_scale: float | list[float] = 1.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 (
strolist[str], opcional) — El prompt o los prompts para guiar la generación de la imagen. - prompt_2 (
strolist[str], opcional) — El prompt o los prompts que se enviarán altokenizer_2y altext_encoder_2. - image (
PIL.Image.Imageolist[PIL.Image.Image]otorch.FloatTensor) — La(s) imagen(es) a inpaintar. - mask_image (
PIL.Image.Imageolist[PIL.Image.Image]otorch.FloatTensor) — La(s) imagen(es) de máscara a utilizar para el inpainting. Los píxeles blancos de la máscara se repintarán, mientras que los píxeles negros se conservarán. - masked_image_latents (
torch.FloatTensor, opcional) — Latentes de imagen enmascarada pregenerados. - control_image (
PIL.Image.Imageolist[PIL.Image.Image]otorch.FloatTensor) — La condición de entrada de ControlNet. La imagen para controlar la generación. - height (
int, opcional, valor predeterminado: self.default_sample_size * self.vae_scale_factor) — La altura en píxeles de la imagen generada. - width (
int, opcional, valor predeterminado: self.default_sample_size * self.vae_scale_factor) — El ancho en píxeles de la imagen generada. - strength (
float, opcional, valor predeterminado 0.6) — Conceptualmente, indica cuánto se debe pintar la zona enmascarada. Debe estar entre 0 y 1. - padding_mask_crop (
int, opcional) — El tamaño del relleno que se utilizará al recortar la máscara. - num_inference_steps (
int, opcional, valor predeterminado 28) — 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 argumentosigmasen su métodoset_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pasenum_inference_steps. - guidance_scale (
float, opcional, valor predeterminado 7.0) — Escala de guía definida en Classifier-Free Diffusion Guidance. - control_guidance_start (
floatolist[float], opcional, valor predeterminado 0.0) — El porcentaje de pasos totales en el que ControlNet comienza a aplicarse. - control_guidance_end (
floatolist[float], opcional, valor predeterminado 1.0) — El porcentaje de pasos totales en el que ControlNet deja de aplicarse. - control_mode (
intolist[int], opcional) — El modo para el ControlNet. Si se usan varios ControlNets, esto debe ser una lista. - controlnet_conditioning_scale (
floatolist[float], opcional, valor predeterminado 1.0) — Las salidas de ControlNet se multiplican porcontrolnet_conditioning_scaleantes de sumarse al residual en el transformador original. - num_images_per_prompt (
int, opcional, valor predeterminado 1) — El número de imágenes que se generarán por indicación. - generator (
torch.Generatorolist[torch.Generator], opcional) — Uno o más generadores de torch para hacer la generación determinista. - latents (
torch.FloatTensor, opcional) — Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. - 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. - pooled_prompt_embeds (
torch.FloatTensor, opcional) — Incrustaciones de texto agrupadas pregeneradas. - output_type (
str, opcional, por defecto"pil") — El formato de salida de la imagen generada. Elija entrePIL.Imageonp.array. - return_dict (
bool, opcional, valor predeterminadoTrue) — Indica si se debe devolver un~pipelines.flux.FluxPipelineOutputen lugar de una tupla simple. - joint_attention_kwargs (
dict, opcional) — Argumentos de palabra clave adicionales que se pasarán al mecanismo de atención conjunta. - callback_on_step_end (
Callable, opcional) — Una función que se llama al final de cada paso de desruido durante la inferencia. - callback_on_step_end_tensor_inputs (
list[str], opcional) — La lista de entradas de tensor para la funcióncallback_on_step_end. - max_sequence_length (
int, opcional, valor predeterminado 512) — La longitud máxima de la secuencia que se generará.
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 FluxControlNetInpaintPipeline
>>> from diffusers.models import FluxControlNetModel
>>> from diffusers.utils import load_image
>>> controlnet = FluxControlNetModel.from_pretrained(
... "InstantX/FLUX.1-dev-controlnet-canny", torch_dtype=torch.float16
... )
>>> pipe = FluxControlNetInpaintPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-schnell", controlnet=controlnet, torch_dtype=torch.float16
... )
>>> pipe.to("cuda")
>>> control_image = load_image(
... "https://huggingface.co/InstantX/FLUX.1-dev-Controlnet-Canny-alpha/resolve/main/canny.jpg"
... )
>>> init_image = load_image(
... "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
... )
>>> mask_image = load_image(
... "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"
... )
>>> prompt = "A girl holding a sign that says InstantX"
>>> image = pipe(
... prompt,
... image=init_image,
... mask_image=mask_image,
... control_image=control_image,
... control_guidance_start=0.2,
... control_guidance_end=0.8,
... controlnet_conditioning_scale=0.7,
... strength=0.7,
... num_inference_steps=28,
... guidance_scale=3.5,
... ).images[0]
>>> image.save("flux_controlnet_inpaint.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 (
strolist[str], opcional) — prompt a codificar - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán altokenizer_2y altext_encoder_2. Si no se define, se utilizaprompten 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 entradaprompt. - 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 entradaprompt. - lora_scale (
float, opcional) — Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.
FluxControlNetImg2ImgPipeline
clase diffusers.FluxControlNetImg2ImgPipeline
< source >( scheduler: FlowMatchEulerDiscreteSchedulervae: AutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizertext_encoder_2: T5EncoderModeltokenizer_2: T5Tokenizertransformer: FluxTransformer2DModelcontrolnet: 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 )
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
transformerpara 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 controlnet de Flux para la generación de imagen a imagen.
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]] = Noneheight: int | None = Nonewidth: int | None = Nonestrength: float = 0.6num_inference_steps: int = 28sigmas: list[float] | None = Noneguidance_scale: float = 7.0control_guidance_start: float | list[float] = 0.0control_guidance_end: float | list[float] = 1.0control_mode: int | list[int] | None = Nonecontrolnet_conditioning_scale: float | list[float] = 1.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 (
strolist[str], opcional) — El prompt o los prompts para guiar la generación de la imagen. - prompt_2 (
strolist[str], opcional) — El prompt o los prompts que se enviarán altokenizer_2y altext_encoder_2. - image (
PIL.Image.Imageolist[PIL.Image.Image]otorch.FloatTensor) — La imagen o las imágenes que se modificarán con el pipeline. - control_image (
PIL.Image.Imageolist[PIL.Image.Image]otorch.FloatTensor) — La condición de entrada de ControlNet. La imagen para controlar la generación. - height (
int, opcional, valor predeterminado: self.default_sample_size * self.vae_scale_factor) — La altura en píxeles de la imagen generada. - width (
int, opcional, valor predeterminado: self.default_sample_size * self.vae_scale_factor) — El ancho en píxeles de la imagen generada. - strength (
float, opcional, valor predeterminado 0.6) — Indica, conceptualmente, cuánto se debe transformar laimagede referencia. Debe estar entre 0 y 1. - num_inference_steps (
int, opcional, valor predeterminado 28) — 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 argumentosigmasen su métodoset_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pasenum_inference_steps. - guidance_scale (
float, opcional, valor predeterminado 7.0) — Escala de guía definida en Classifier-Free Diffusion Guidance. - control_mode (
intolist[int], opcional) — El modo para el ControlNet. Si se usan varios ControlNets, esto debe ser una lista. - controlnet_conditioning_scale (
floatolist[float], opcional, valor predeterminado 1.0) — Las salidas de ControlNet se multiplican porcontrolnet_conditioning_scaleantes de sumarse al residual en el transformador original. - control_guidance_start (
floatolist[float], opcional, valor predeterminado 0.0) — El porcentaje de pasos totales en el que ControlNet comienza a aplicarse. - control_guidance_end (
floatolist[float], opcional, valor predeterminado 1.0) — El porcentaje de pasos totales en el que ControlNet deja de aplicarse. - num_images_per_prompt (
int, opcional, valor predeterminado 1) — El número de imágenes que se generarán por indicación. - generator (
torch.Generatorolist[torch.Generator], opcional) — Uno o más generadores de torch para hacer la generación determinista. - latents (
torch.FloatTensor, opcional) — Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. - 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. - pooled_prompt_embeds (
torch.FloatTensor, opcional) — Incrustaciones de texto agrupadas pregeneradas. - output_type (
str, opcional, por defecto"pil") — El formato de salida de la imagen generada. Elija entrePIL.Imageonp.array. - return_dict (
bool, opcional, valor predeterminadoTrue) — Indica si se debe devolver un~pipelines.flux.FluxPipelineOutputen lugar de una tupla simple. - joint_attention_kwargs (
dict, opcional) — Argumentos de palabra clave adicionales que se pasarán al mecanismo de atención conjunta. - callback_on_step_end (
Callable, opcional) — Una función que se llama al final de cada paso de desruido durante la inferencia. - callback_on_step_end_tensor_inputs (
list[str], opcional) — La lista de entradas de tensor para la funcióncallback_on_step_end. - max_sequence_length (
int, opcional, valor predeterminado 512) — La longitud máxima de la secuencia que se generará.
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 FluxControlNetImg2ImgPipeline, FluxControlNetModel
>>> from diffusers.utils import load_image
>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> controlnet = FluxControlNetModel.from_pretrained(
... "InstantX/FLUX.1-dev-Controlnet-Canny-alpha", torch_dtype=torch.bfloat16
... )
>>> pipe = FluxControlNetImg2ImgPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-schnell", controlnet=controlnet, torch_dtype=torch.float16
... )
>>> pipe.text_encoder.to(torch.float16)
>>> pipe.controlnet.to(torch.float16)
>>> pipe.to("cuda")
>>> control_image = load_image("https://huggingface.co/InstantX/SD3-Controlnet-Canny/resolve/main/canny.jpg")
>>> init_image = load_image(
... "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
... )
>>> prompt = "A girl in city, 25 years old, cool, futuristic"
>>> image = pipe(
... prompt,
... image=init_image,
... control_image=control_image,
... control_guidance_start=0.2,
... control_guidance_end=0.8,
... controlnet_conditioning_scale=1.0,
... strength=0.7,
... num_inference_steps=2,
... guidance_scale=3.5,
... ).images[0]
>>> image.save("flux_controlnet_img2img.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 (
strolist[str], opcional) — prompt a codificar - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán altokenizer_2y altext_encoder_2. Si no se define, se utilizaprompten 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 entradaprompt. - 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 entradaprompt. - lora_scale (
float, opcional) — Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.
FluxControlPipeline
clase diffusers.FluxControlPipeline
< 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
transformerpara 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 la generación de imágenes a partir de texto controlable con condiciones de imagen.
Referencia: https://bfl.ai/flux-1-tools
__call__
< source >( prompt: str | list[str] = Noneprompt_2: str | list[str] | None = Nonecontrol_image: 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 = Nonenum_inference_steps: int = 28sigmas: list[float] | None = Noneguidance_scale: float = 3.5num_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 (
strolist[str], opcional) — El prompt o los prompts para guiar la generación de la imagen. Si no se define, hay que pasarprompt_embedsen su lugar. - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán atokenizer_2ytext_encoder_2. Si no está definido, se utilizaráprompten su lugar - 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]]olist[list[PIL.Image.Image]]): La condición de entrada de ControlNet para proporcionar orientación alunetdurante la generación. Si el tipo se especifica comotorch.Tensor, se pasa a ControlNet tal cual. También se puede aceptarPIL.Image.Imagecomo imagen. Las dimensiones de la imagen de salida son, por defecto, las dimensiones deimage. Si se pasan height y/o width,imagese redimensiona en consecuencia. Si se especifican varios ControlNets eninit, las imágenes deben pasarse como una lista para que cada elemento de la lista pueda agruparse correctamente como entrada para un solo ControlNet. - 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. - 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 argumentosigmasen su métodoset_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pasenum_inference_steps. - guidance_scale (
float, opcional, valor predeterminado 3.5) — La escala de orientación integrada se habilita al establecerguidance_scale> 1. Valores más altos deguidance_scalefomentan que el modelo genere imágenes más alineadas con el prompt a costa de una menor calidad de imagen.Los modelos destilados con guía aproximan la guía libre de clasificador real para
guidance_scale> 1. Consulte el artículo para obtener más información. - num_images_per_prompt (
int, opcional, valor predeterminado 1) — El número de imágenes que se generarán por indicación. - generator (
torch.Generatorolist[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 elgeneratoraleatorio 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 entradaprompt. - 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 entradaprompt. - output_type (
str, opcional, valor predeterminado"pil") — El formato de salida de la imagen generada. Elija entre PIL:PIL.Image.Imageonp.array. - return_dict (
bool, opcional, valor predeterminadoTrue) — Indica si se debe devolver un~pipelines.flux.FluxPipelineOutputen lugar de una tupla simple. - joint_attention_kwargs (
dict, opcional) — Un diccionario de kwargs que, si se especifica, se pasa alAttentionProcessordefinido enself.processordentro 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_kwargsincluirá una lista de todos los tensores especificados porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — La lista de entradas de tensor para la funcióncallback_on_step_end. Los tensores especificados en la lista se pasarán como argumentocallback_kwargs. Solo podrás incluir variables listadas en el atributo._callback_tensor_inputsde tu clase de pipeline. - max_sequence_length (
intpor defecto 512) — Longitud máxima de la secuencia para usar con elprompt.
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 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", torch_dtype=torch.bfloat16
... ).to("cuda")
>>> 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")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 (
strolist[str], opcional) — prompt a codificar - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán altokenizer_2y altext_encoder_2. Si no se define, se utilizaprompten 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 entradaprompt. - 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 entradaprompt. - lora_scale (
float, opcional) — Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.
FluxControlImg2ImgPipeline
clase diffusers.FluxControlImg2ImgPipeline
< 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
transformerpara 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 inpainting de imágenes.
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]] = 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 (
strolist[str], opcional) — El prompt o los prompts para guiar la generación de la imagen. Si no se define, hay que pasarprompt_embedsen su lugar. - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán atokenizer_2ytext_encoder_2. Si no está definido, se utilizaráprompten su lugar - image (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image]olist[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 comoimage, 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]]olist[list[PIL.Image.Image]]): La condición de entrada de ControlNet para proporcionar orientación alunetdurante la generación. Si el tipo se especifica comotorch.Tensor, se pasa a ControlNet tal cual. También se puede aceptarPIL.Image.Imagecomo imagen. Las dimensiones de la imagen de salida son, por defecto, las dimensiones deimage. Si se pasan height y/o width,imagese redimensiona en consecuencia. Si se especifican varios ControlNets eninit, las imágenes deben pasarse como una lista para que cada elemento de la lista pueda agruparse correctamente como entrada para un solo ControlNet. - 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 laimagede referencia. Debe estar entre 0 y 1.imagese utiliza como punto de partida y se añade más ruido a medida que aumenta elstrength. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuandostrengthes 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado ennum_inference_steps. Un valor de 1 ignora esencialmenteimage. - 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 argumentosigmasen su métodoset_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pasenum_inference_steps. - guidance_scale (
float, opcional, valor predeterminado 7.0) — Escala de guía definida en Classifier-Free Diffusion Guidance.guidance_scalese define comowde la ecuación 2 del Imagen Paper. La escala de guía se habilita estableciendoguidance_scale > 1. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas alpromptde 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.Generatorolist[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 elgeneratoraleatorio 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 entradaprompt. - 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 entradaprompt. - output_type (
str, opcional, valor predeterminado"pil") — El formato de salida de la imagen generada. Elija entre PIL:PIL.Image.Imageonp.array. - return_dict (
bool, opcional, valor predeterminadoTrue) — Indica si se debe devolver un~pipelines.flux.FluxPipelineOutputen lugar de una tupla simple. - joint_attention_kwargs (
dict, opcional) — Un diccionario de kwargs que, si se especifica, se pasa alAttentionProcessordefinido enself.processordentro 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_kwargsincluirá una lista de todos los tensores especificados porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — La lista de entradas de tensor para la funcióncallback_on_step_end. Los tensores especificados en la lista se pasarán como argumentocallback_kwargs. Solo podrás incluir variables listadas en el atributo._callback_tensor_inputsde tu clase de pipeline. - max_sequence_length (
intpor defecto 512) — Longitud máxima de la secuencia para usar con elprompt.
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 controlnet_aux import CannyDetector
>>> from diffusers import FluxControlImg2ImgPipeline
>>> from diffusers.utils import load_image
>>> pipe = FluxControlImg2ImgPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-Canny-dev", torch_dtype=torch.bfloat16
... ).to("cuda")
>>> prompt = "A robot made of exotic candies and chocolates of different kinds. Abstract background"
>>> image = load_image(
... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/watercolor-painting.jpg"
... )
>>> 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,
... image=image,
... control_image=control_image,
... strength=0.8,
... height=1024,
... width=1024,
... num_inference_steps=50,
... guidance_scale=30.0,
... ).images[0]
>>> image.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 (
strolist[str], opcional) — prompt a codificar - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán altokenizer_2y altext_encoder_2. Si no se define, se utilizaprompten 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 entradaprompt. - 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 entradaprompt. - lora_scale (
float, opcional) — Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.
FluxPriorReduxPipeline
clase diffusers.FluxPriorReduxPipeline
< source >( image_encoder: SiglipVisionModelfeature_extractor: SiglipImageProcessorPilimage_embedder: ReduxImageEncodertext_encoder: CLIPTextModel = Nonetokenizer: CLIPTokenizer = Nonetext_encoder_2: T5EncoderModel = Nonetokenizer_2: T5Tokenizer = None )
Parámetros
- image_encoder (
SiglipVisionModel) — Modelo de visión SIGLIP para codificar la imagen de entrada. - feature_extractor (
SiglipImageProcessor) — Procesador de imágenes para preprocesar imágenes para el modelo SIGLIP. - image_embedder (
ReduxImageEncoder) — Codificador de imágenes de Redux para procesar los embeddings de SIGLIP. - text_encoder (
CLIPTextModel, opcional) — CLIP, concretamente la variante clip-vit-large-patch14. - text_encoder_2 (
T5EncoderModel, opcional) — T5, concretamente la variante google/t5-v1_1-xxl. - tokenizer (
CLIPTokenizer, opcional) — Tokenizer de la clase CLIPTokenizer. - tokenizer_2 (
T5TokenizerFast, opcional) — Segundo Tokenizer de la clase T5TokenizerFast.
El pipeline Flux Redux para la generación de imagen a imagen.
Referencia: https://blackforestlabs.ai/flux-1-tools/
__call__
< source >( image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]prompt: str | list[str] = Noneprompt_2: str | list[str] | None = Noneprompt_embeds: typing.Optional[torch.FloatTensor] = Nonepooled_prompt_embeds: typing.Optional[torch.FloatTensor] = Noneprompt_embeds_scale: float | list[float] | None = 1.0pooled_prompt_embeds_scale: float | list[float] | None = 1.0return_dict: bool = True ) → ~pipelines.flux.FluxPriorReduxPipelineOutput or tuple
Parámetros
- image (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image]olist[np.ndarray]) —Image, array de numpy o tensor que representa un lote de imágenes para usar 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) - prompt (
strolist[str], opcional) — El prompt o los prompts para guiar la generación de la imagen. función experimental: para usar esta función, asegúrate de cargar los codificadores de texto en el pipeline de forma explícita. Los prompt se ignorarán si los codificadores de texto no están cargados. - prompt_2 (
strolist[str], opcional) — El prompt o los prompts que se enviarán altokenizer_2y altext_encoder_2. - 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. - pooled_prompt_embeds (
torch.FloatTensor, opcional) — Incrustaciones de texto agrupadas pregeneradas. - prompt_embeds_scale (
floatolist[float], opcional, valor predeterminado 1.0) — Factor de escala (o lista de factores de escala por imagen) aplicado a los embeddings del prompt de redux antes de que se devuelvan. - pooled_prompt_embeds_scale (
floatolist[float], opcional, valor predeterminado 1.0) — Factor de escala (o lista de factores de escala por imagen) aplicado a los embeddings de prompt agrupados de redux antes de que se devuelvan. - return_dict (
bool, opcional, valor predeterminadoTrue) — Indica si se debe devolver un~pipelines.flux.FluxPriorReduxPipelineOutputen lugar de una tupla simple.
Devuelve
~pipelines.flux.FluxPriorReduxPipelineOutput o tuple
~pipelines.flux.FluxPriorReduxPipelineOutput 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 FluxPriorReduxPipeline, FluxPipeline
>>> from diffusers.utils import load_image
>>> device = "cuda"
>>> 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, torch_dtype=dtype).to(device)
>>> pipe = FluxPipeline.from_pretrained(
... repo_base, text_encoder=None, text_encoder_2=None, torch_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")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 (
strolist[str], opcional) — prompt a codificar - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán altokenizer_2y altext_encoder_2. Si no se define, se utilizaprompten 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 entradaprompt. - 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 entradaprompt. - lora_scale (
float, opcional) — Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.
FluxFillPipeline
clase diffusers.FluxFillPipeline
< 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
transformerpara 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 Flux Fill para inpainting/outpainting de imágenes.
Referencia: https://blackforestlabs.ai/flux-1-tools/
__call__
< source >( prompt: str | list[str] = Noneprompt_2: str | list[str] | None = Noneimage: typing.Optional[torch.FloatTensor] = Nonemask_image: typing.Optional[torch.FloatTensor] = Nonemasked_image_latents: typing.Optional[torch.FloatTensor] = Noneheight: int | None = Nonewidth: int | None = Nonestrength: float = 1.0num_inference_steps: int = 50sigmas: list[float] | None = Noneguidance_scale: float = 30.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 (
strolist[str], opcional) — El prompt o los prompts para guiar la generación de la imagen. Si no se define, hay que pasarprompt_embedsen su lugar. - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán atokenizer_2ytext_encoder_2. Si no está definido, se utilizaráprompten su lugar - image (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image]olist[np.ndarray]) —Image, array de numpy o tensor que representa un lote de imágenes para usar 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). - mask_image (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image]olist[np.ndarray]) —Image, array de numpy o tensor que representa un lote de imágenes para enmascararimage. Los píxeles blancos de la máscara se repintan, mientras que los píxeles negros se conservan. Simask_imagees 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]) —Tensorque representa un lote de imágenes para enmascarar laimagegenerada por el VAE. Si no se proporciona, el tensor de latentes de la máscara se generará mediantemask_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 laimagede referencia. Debe estar entre 0 y 1.imagese utiliza como punto de partida y se añade más ruido a medida que aumenta elstrength. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuandostrengthes 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado ennum_inference_steps. Un valor de 1 ignora esencialmenteimage. - 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 argumentosigmasen su métodoset_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pasenum_inference_steps. - guidance_scale (
float, opcional, valor predeterminado 30.0) — Escala de guía tal como se define en Classifier-Free Diffusion Guidance.guidance_scalese define comowde la ecuación 2 de Imagen Paper. La escala de guía se habilita al establecerguidance_scale > 1. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al textoprompt, 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.Generatorolist[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 elgeneratoraleatorio 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 entradaprompt. - 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 entradaprompt. - output_type (
str, opcional, valor predeterminado"pil") — El formato de salida de la imagen generada. Elija entre PIL:PIL.Image.Imageonp.array. - return_dict (
bool, opcional, valor predeterminadoTrue) — Indica si se debe devolver un~pipelines.flux.FluxPipelineOutputen lugar de una tupla simple. - joint_attention_kwargs (
dict, opcional) — Un diccionario de kwargs que, si se especifica, se pasa alAttentionProcessordefinido enself.processordentro 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_kwargsincluirá una lista de todos los tensores especificados porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — La lista de entradas de tensor para la funcióncallback_on_step_end. Los tensores especificados en la lista se pasarán como argumentocallback_kwargs. Solo podrás incluir variables listadas en el atributo._callback_tensor_inputsde tu clase de pipeline. - max_sequence_length (
intpor defecto 512) — Longitud máxima de la secuencia para usar con elprompt.
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 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")
>>> pipe = FluxFillPipeline.from_pretrained("black-forest-labs/FLUX.1-Fill-dev", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload() # save some VRAM by offloading the model to CPU
>>> image = pipe(
... prompt="a white paper cup",
... image=image,
... mask_image=mask,
... height=1632,
... width=1232,
... guidance_scale=30,
... num_inference_steps=50,
... max_sequence_length=512,
... generator=torch.Generator("cpu").manual_seed(0),
... ).images[0]
>>> image.save("flux_fill.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 (
strolist[str], opcional) — prompt a codificar - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán altokenizer_2y altext_encoder_2. Si no se define, se utilizaprompten 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 entradaprompt. - 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 entradaprompt. - lora_scale (
float, opcional) — Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.
FluxKontextPipeline
clase diffusers.FluxKontextPipeline
< source >( scheduler: FlowMatchEulerDiscreteSchedulervae: AutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizertext_encoder_2: T5EncoderModeltokenizer_2: T5Tokenizertransformer: FluxTransformer2DModelimage_encoder: CLIPVisionModelWithProjection = Nonefeature_extractor: CLIPImageProcessorPil = None )
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
transformerpara 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 Flux Kontext para la generación de imagen a imagen y texto a imagen.
Referencia: https://bfl.ai/announcements/flux-1-kontext-dev
__call__
< source >( image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Noneprompt: str | list[str] = Noneprompt_2: str | list[str] | None = Nonenegative_prompt: str | list[str] = Nonenegative_prompt_2: str | list[str] | None = Nonetrue_cfg_scale: float = 1.0height: int | None = Nonewidth: int | None = Nonenum_inference_steps: int = 28sigmas: list[float] | None = Noneguidance_scale: float = 3.5num_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] = Noneip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Noneip_adapter_image_embeds: list[torch.Tensor] | None = Nonenegative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Nonenegative_ip_adapter_image_embeds: list[torch.Tensor] | None = Nonenegative_prompt_embeds: typing.Optional[torch.FloatTensor] = Nonenegative_pooled_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 = 512max_area: int = 1048576_auto_resize: bool = True ) → ~pipelines.flux.FluxPipelineOutput or tuple
Parámetros
- image (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image]olist[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 comoimage, pero si se pasan latentes directamente, no se vuelven a codificar. - prompt (
strolist[str], opcional) — El prompt o los prompts para guiar la generación de la imagen. Si no se define, hay que pasarprompt_embedsen su lugar. - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán atokenizer_2ytext_encoder_2. Si no está definido, se utilizaráprompten su lugar. - negative_prompt (
strolist[str], opcional) — El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasarnegative_prompt_embedsen su lugar. Se ignora cuando no se usa guía (es decir, se ignora sitrue_cfg_scaleno es mayor que1). - negative_prompt_2 (
strolist[str], opcional) — El prompt o prompts que no deben guiar la generación de la imagen y que se enviarán atokenizer_2ytext_encoder_2. Si no se define, se utilizanegative_prompten todos los text-encoders. - true_cfg_scale (
float, opcional, valor predeterminado 1.0) — Cuando es > 1.0 y se proporciona unnegative_prompt, habilita la guía libre de clasificador real. - 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. - 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 argumentosigmasen su métodoset_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pasenum_inference_steps. - guidance_scale (
float, opcional, valor predeterminado 3.5) — La escala de orientación integrada se habilita al establecerguidance_scale> 1. Valores más altos deguidance_scalefomentan que el modelo genere imágenes más alineadas con el prompt a costa de una menor calidad de imagen.Los modelos destilados con guía aproximan la guía libre de clasificador real para
guidance_scale> 1. Consulte el artículo para obtener más información. - num_images_per_prompt (
int, opcional, valor predeterminado 1) — El número de imágenes que se generarán por indicación. - generator (
torch.Generatorolist[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 elgeneratoraleatorio 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 entradaprompt. - 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 entradaprompt. - ip_adapter_image — (
PipelineImageInput, opcional): Entrada de imagen opcional para trabajar con IP Adapters. - ip_adapter_image_embeds (
list[torch.Tensor], opcional) — Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma(batch_size, num_images, emb_dim). Si no se proporciona, las incrustaciones se calculan a partir del argumento de entradaip_adapter_image. - negative_ip_adapter_image —
(
PipelineImageInput, opcional): Entrada de imagen opcional para trabajar con IP Adapters. - negative_ip_adapter_image_embeds (
list[torch.Tensor], opcional) — Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma(batch_size, num_images, emb_dim). Si no se proporciona, las incrustaciones se calculan a partir del argumento de entradaip_adapter_image. - negative_prompt_embeds (
torch.FloatTensor, opcional) — Incrustaciones de texto negativo pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entradanegative_prompt. - negative_pooled_prompt_embeds (
torch.FloatTensor, opcional) — Incrustaciones de texto negativo agrupadas pregeneradas. Se pueden utilizar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, se generarán pooled negative_prompt_embeds a partir del argumento de entradanegative_prompt. - output_type (
str, opcional, valor predeterminado"pil") — El formato de salida de la imagen generada. Elija entre PIL:PIL.Image.Imageonp.array. - return_dict (
bool, opcional, valor predeterminadoTrue) — Indica si se debe devolver un~pipelines.flux.FluxPipelineOutputen lugar de una tupla simple. - joint_attention_kwargs (
dict, opcional) — Un diccionario de kwargs que, si se especifica, se pasa alAttentionProcessordefinido enself.processordentro 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_kwargsincluirá una lista de todos los tensores especificados porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — La lista de entradas de tensor para la funcióncallback_on_step_end. Los tensores especificados en la lista se pasarán como argumentocallback_kwargs. Solo podrás incluir variables listadas en el atributo._callback_tensor_inputsde tu clase de pipeline. - max_sequence_length (
intpor defecto 512) — Longitud máxima de secuencia para usar con elprompt. - max_area (
int, por defecto1024 ** 2) — El área máxima de la imagen generada en píxeles. La altura y el ancho se ajustarán para encajar en esta área manteniendo la relación de aspecto. - _auto_resize (
bool, opcional, valor predeterminadoTrue) — Si se debe redimensionar automáticamente la imagen de entrada a las resoluciones preferidas.
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 FluxKontextPipeline
>>> from diffusers.utils import load_image
>>> pipe = FluxKontextPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-Kontext-dev", torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")
>>> 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("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 (
strolist[str], opcional) — prompt a codificar - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán altokenizer_2y altext_encoder_2. Si no se define, se utilizaprompten 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 entradaprompt. - 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 entradaprompt. - lora_scale (
float, opcional) — Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.
FluxKontextInpaintPipeline
clase diffusers.FluxKontextInpaintPipeline
< source >( scheduler: FlowMatchEulerDiscreteSchedulervae: AutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizertext_encoder_2: T5EncoderModeltokenizer_2: T5Tokenizertransformer: FluxTransformer2DModelimage_encoder: CLIPVisionModelWithProjection = Nonefeature_extractor: CLIPImageProcessorPil = None )
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
transformerpara 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 Flux Kontext para la generación de imágenes a partir de texto.
Referencia: https://blackforestlabs.ai/announcing-black-forest-labs/
__call__
< source >( image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Noneimage_reference: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Nonemask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = Noneprompt: str | list[str] = Noneprompt_2: str | list[str] | None = Nonenegative_prompt: str | list[str] = Nonenegative_prompt_2: str | list[str] | None = Nonetrue_cfg_scale: float = 1.0height: int | None = Nonewidth: int | None = Nonestrength: float = 1.0padding_mask_crop: int | None = Nonenum_inference_steps: int = 28sigmas: list[float] | None = Noneguidance_scale: float = 3.5num_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] = Noneip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Noneip_adapter_image_embeds: list[torch.Tensor] | None = Nonenegative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Nonenegative_ip_adapter_image_embeds: list[torch.Tensor] | None = Nonenegative_prompt_embeds: typing.Optional[torch.FloatTensor] = Nonenegative_pooled_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 = 512max_area: int = 1048576_auto_resize: bool = True ) → ~pipelines.flux.FluxPipelineOutput or tuple
Parámetros
- image (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image]olist[np.ndarray]) —Image, array de numpy o tensor que representa un lote de imágenes para ser inpaintadas (qué partes de la imagen deben enmascararse conmask_imagey repintarse segúnpromptyimage_reference). 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 comoimage, pero si se pasan latentes directamente, no se vuelven a codificar. - image_reference (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image], orlist[np.ndarray]) —Image, numpy array or tensor representing an image batch to be used as the starting point for the masked area. For both numpy array and pytorch tensor, the expected value range is between[0, 1]If it’s a tensor or a list or tensors, the expected shape should be(B, C, H, W)or(C, H, W)If it is a numpy array or a list of arrays, the expected shape should be(B, H, W, C)or(H, W, C)It can also accept image latents asimage, but if passing latents directly it is not encoded again. - mask_image (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image]olist[np.ndarray]) —Image, array de numpy o tensor que representa un lote de imágenes para enmascararimage. Los píxeles blancos de la máscara se repintan, mientras que los píxeles negros se conservan. Simask_imagees 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). - prompt (
strolist[str], opcional) — El prompt o los prompts para guiar la generación de la imagen. Si no se define, hay que pasarprompt_embedsen su lugar. - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán atokenizer_2ytext_encoder_2. Si no está definido, se utilizaráprompten su lugar. - negative_prompt (
strolist[str], opcional) — El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasarnegative_prompt_embedsen su lugar. Se ignora cuando no se usa guía (es decir, se ignora sitrue_cfg_scaleno es mayor que1). - negative_prompt_2 (
strolist[str], opcional) — El prompt o prompts que no deben guiar la generación de la imagen y que se enviarán atokenizer_2ytext_encoder_2. Si no se define, se utilizanegative_prompten todos los text-encoders. - true_cfg_scale (
float, opcional, valor predeterminado 1.0) — La guía libre de clasificador real (escala de guía) se habilita cuandotrue_cfg_scale> 1 y se proporcionanegative_prompt. - 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 laimagede referencia. Debe estar entre 0 y 1.imagese utiliza como punto de partida y se añade más ruido a medida que aumenta elstrength. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuandostrengthes 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado ennum_inference_steps. Un valor de 1 ignora esencialmenteimage. - padding_mask_crop (
int, opcional, valor predeterminadoNone) — El tamaño del margen en el recorte que se aplicará a la imagen y la máscara. Si esNone, no se aplica ningún recorte a image y mask_image. Sipadding_mask_cropno esNone, primero se busca una región rectangular con la misma relación de aspecto que la imagen y que contenga toda el área enmascarada, y luego se expande esa área en función depadding_mask_crop. A continuación, la imagen y mask_image se recortan según el área expandida antes de redimensionarlas al tamaño original de la imagen para el inpainting. Esto es útil cuando el área enmascarada es pequeña mientras que la imagen es grande y contiene información irrelevante para el inpainting, como el fondo. - 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 argumentosigmasen su métodoset_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pasenum_inference_steps. - guidance_scale (
float, opcional, valor predeterminado 3.5) — La escala de orientación integrada se habilita al establecerguidance_scale> 1. valores más altos deguidance_scaleaniman al modelo a generar imágenes más alineadas con laprompt, a costa de una menor calidad de imagen.Los modelos destilados con guía aproximan la guía libre de clasificador real para
guidance_scale> 1. Consulte el artículo para obtener más información. - num_images_per_prompt (
int, opcional, valor predeterminado 1) — El número de imágenes que se generarán por indicación. - generator (
torch.Generatorolist[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 elgeneratoraleatorio 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 entradaprompt. - 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 entradaprompt. - ip_adapter_image — (
PipelineImageInput, opcional): Entrada de imagen opcional para trabajar con IP Adapters. - ip_adapter_image_embeds (
list[torch.Tensor], opcional) — Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma(batch_size, num_images, emb_dim). Si no se proporciona, las incrustaciones se calculan a partir del argumento de entradaip_adapter_image. - negative_ip_adapter_image —
(
PipelineImageInput, opcional): Entrada de imagen opcional para trabajar con IP Adapters. - negative_ip_adapter_image_embeds (
list[torch.Tensor], opcional) — Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma(batch_size, num_images, emb_dim). Si no se proporciona, las incrustaciones se calculan a partir del argumento de entradaip_adapter_image. - negative_prompt_embeds (
torch.FloatTensor, opcional) — Incrustaciones de texto negativo pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entradanegative_prompt. - negative_pooled_prompt_embeds (
torch.FloatTensor, opcional) — Incrustaciones de texto negativo agrupadas pregeneradas. Se pueden utilizar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, se generarán pooled negative_prompt_embeds a partir del argumento de entradanegative_prompt. - output_type (
str, opcional, valor predeterminado"pil") — El formato de salida de la imagen generada. Elija entre PIL:PIL.Image.Imageonp.array. - return_dict (
bool, opcional, valor predeterminadoTrue) — Indica si se debe devolver un~pipelines.flux.FluxPipelineOutputen lugar de una tupla simple. - joint_attention_kwargs (
dict, opcional) — Un diccionario de kwargs que, si se especifica, se pasa alAttentionProcessordefinido enself.processordentro 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_kwargsincluirá una lista de todos los tensores especificados porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — La lista de entradas de tensor para la funcióncallback_on_step_end. Los tensores especificados en la lista se pasarán como argumentocallback_kwargs. Solo podrás incluir variables listadas en el atributo._callback_tensor_inputsde tu clase de pipeline. - max_sequence_length (
intpor defecto 512) — Longitud máxima de secuencia para usar con elprompt. - max_area (
int, por defecto1024 ** 2) — El área máxima de la imagen generada en píxeles. La altura y el ancho se ajustarán para encajar en esta área manteniendo la relación de aspecto. - _auto_resize (
bool, opcional, valor predeterminadoTrue) — Si se debe redimensionar automáticamente la imagen de entrada a las resoluciones preferidas.
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:
Inpainting solo con texto
>>> import torch
>>> from diffusers import FluxKontextInpaintPipeline
>>> from diffusers.utils import load_image
>>> prompt = "Change the yellow dinosaur to green one"
>>> img_url = (
... "https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/dinosaur_input.jpeg?raw=true"
... )
>>> mask_url = (
... "https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/dinosaur_mask.png?raw=true"
... )
>>> source = load_image(img_url)
>>> mask = load_image(mask_url)
>>> pipe = FluxKontextInpaintPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-Kontext-dev", torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")
>>> image = pipe(prompt=prompt, image=source, mask_image=mask, strength=1.0).images[0]
>>> image.save("kontext_inpainting_normal.png")Inpainting con condicionamiento de imagen
>>> import torch
>>> from diffusers import FluxKontextInpaintPipeline
>>> from diffusers.utils import load_image
>>> pipe = FluxKontextInpaintPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-Kontext-dev", torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")
>>> prompt = "Replace this ball"
>>> img_url = "https://images.pexels.com/photos/39362/the-ball-stadion-football-the-pitch-39362.jpeg?auto=compress&cs=tinysrgb&dpr=1&w=500"
>>> mask_url = (
... "https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/ball_mask.png?raw=true"
... )
>>> image_reference_url = (
... "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTah3x6OL_ECMBaZ5ZlJJhNsyC-OSMLWAI-xw&s"
... )
>>> source = load_image(img_url)
>>> mask = load_image(mask_url)
>>> image_reference = load_image(image_reference_url)
>>> mask = pipe.mask_processor.blur(mask, blur_factor=12)
>>> image = pipe(
... prompt=prompt, image=source, mask_image=mask, image_reference=image_reference, strength=1.0
... ).images[0]
>>> image.save("kontext_inpainting_ref.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 (
strolist[str], opcional) — prompt a codificar - prompt_2 (
strolist[str], opcional) — El prompt o prompts que se enviarán altokenizer_2y altext_encoder_2. Si no se define, se utilizaprompten 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 entradaprompt. - 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 entradaprompt. - lora_scale (
float, opcional) — Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.