Buckets:
| # ControlNet con Stable Diffusion 3 | |
| StableDiffusion3ControlNetPipeline es una implementación de ControlNet para Stable Diffusion 3. | |
| ControlNet se introdujo en [Adding Conditional Control to Text-to-Image Diffusion Models](https://huggingface.co/papers/2302.05543) por Lvmin Zhang, Anyi Rao y Maneesh Agrawala. | |
| Con un modelo de ControlNet, puedes proporcionar una imagen de control adicional para condicionar y controlar la generación de Stable Diffusion. Por ejemplo, si proporcionas un mapa de profundidad, el modelo de ControlNet genera una imagen que preservará la información espacial del mapa de profundidad. Es una forma más flexible y precisa de controlar el proceso de generación de imágenes. | |
| El resumen del artículo es: | |
| *Presentamos ControlNet, una arquitectura de red neuronal para añadir controles de condicionamiento espacial a grandes modelos de difusión de texto a imagen preentrenados. ControlNet bloquea los grandes modelos de difusión listos para producción y reutiliza sus capas de codificación profundas y robustas, preentrenadas con miles de millones de imágenes, como una base sólida para aprender un conjunto diverso de controles condicionales. La arquitectura neuronal se conecta mediante "convoluciones cero" (capas de convolución inicializadas en cero) que hacen crecer progresivamente los parámetros desde cero y garantizan que ningún ruido perjudicial pueda afectar el ajuste fino. Probamos varios controles de condicionamiento, por ejemplo, bordes, profundidad, segmentación, pose humana, etc., con Stable Diffusion, utilizando una o varias condiciones, con o sin indicaciones. Mostramos que el entrenamiento de ControlNets es robusto con conjuntos de datos pequeños (<50k) y grandes (>1m). Resultados extensos muestran que ControlNet puede facilitar aplicaciones más amplias para controlar los modelos de difusión de imágenes.* | |
| Este código de controlnet está implementado principalmente por [The InstantX Team](https://huggingface.co/InstantX). El código relacionado con inpainting fue desarrollado por [The Alimama Creative Team](https://huggingface.co/alimama-creative). Puedes encontrar puntos de control preentrenados para SD3-ControlNet en la tabla siguiente: | |
| | Tipo de ControlNet | Desarrollador | Enlace | | |
| | -------- | ---------- | ---- | | |
| | Canny | [El equipo de InstantX](https://huggingface.co/InstantX) | [Enlace](https://huggingface.co/InstantX/SD3-Controlnet-Canny) | | |
| | Profundidad | [El equipo de InstantX](https://huggingface.co/InstantX) | [Enlace](https://huggingface.co/InstantX/SD3-Controlnet-Depth) | | |
| | Pose | [El equipo de InstantX](https://huggingface.co/InstantX) | [Enlace](https://huggingface.co/InstantX/SD3-Controlnet-Pose) | | |
| | Tile | [El equipo de InstantX](https://huggingface.co/InstantX) | [Enlace](https://huggingface.co/InstantX/SD3-Controlnet-Tile) | | |
| | Inpainting | [El equipo AlimamaCreative](https://huggingface.co/alimama-creative) | [enlace](https://huggingface.co/alimama-creative/SD3-Controlnet-Inpainting) | | |
| > [!TIP] | |
| > Asegúrate de consultar la [guía de Schedulers](../../using-diffusers/schedulers) para aprender a explorar el equilibrio entre la velocidad y la calidad del scheduler, y consulta la sección [reutilizar componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a cargar eficientemente los mismos componentes en múltiples pipelines. | |
| ## StableDiffusion3ControlNetPipeline[[diffusers.StableDiffusion3ControlNetPipeline]] | |
| #### diffusers.StableDiffusion3ControlNetPipeline[[diffusers.StableDiffusion3ControlNetPipeline]] | |
| ```python | |
| diffusers.StableDiffusion3ControlNetPipeline(transformer: SD3Transformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, text_encoder_2: CLIPTextModelWithProjection, tokenizer_2: CLIPTokenizer, text_encoder_3: T5EncoderModel, tokenizer_3: T5Tokenizer, controlnet: diffusers.models.controlnets.controlnet_sd3.SD3ControlNetModel | list[diffusers.models.controlnets.controlnet_sd3.SD3ControlNetModel] | tuple[diffusers.models.controlnets.controlnet_sd3.SD3ControlNetModel] | diffusers.models.controlnets.controlnet_sd3.SD3MultiControlNetModel, image_encoder: transformers.models.siglip.modeling_siglip.SiglipVisionModel | None = None, feature_extractor: transformers.models.siglip.image_processing_pil_siglip.SiglipImageProcessorPil | None = None) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet.py#L143) | |
| **Parámetros:** | |
| transformer ([SD3Transformer2DModel](/docs/diffusers/v0.43.0/es/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados. | |
| scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados. | |
| vae ([AutoencoderKL](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes. | |
| text_encoder (`CLIPTextModelWithProjection`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), específicamente la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14), con una capa de proyección adicional que se inicializa con una matriz diagonal cuya dimensión es `hidden_size`. | |
| text_encoder_2 (`CLIPTextModelWithProjection`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), específicamente la variante [laion/CLIP-ViT-bigG-14-laion2B-39B-b160k](https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k). | |
| text_encoder_3 (`T5EncoderModel`) : Codificador de texto congelado. Stable Diffusion 3 utiliza [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), específicamente la variante [t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl). | |
| tokenizer (`CLIPTokenizer`) : Tokenizador de la clase [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). | |
| tokenizer_2 (`CLIPTokenizer`) : Segundo Tokenizer de la clase [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). | |
| tokenizer_3 (`T5TokenizerFast`) : Tokenizador de la clase [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer). | |
| controlnet ([SD3ControlNetModel](/docs/diffusers/v0.43.0/es/api/models/controlnet_sd3#diffusers.SD3ControlNetModel) o `list[SD3ControlNetModel]` o `SD3MultiControlNetModel`) : Proporciona una condición adicional al `unet` durante el proceso de desruido. Si configuras varios ControlNets como una lista, las salidas de cada ControlNet se suman para crear una condición adicional combinada. | |
| image_encoder (`SiglipVisionModel`, *opcional*) : Modelo de visión preentrenado para IP Adapter. | |
| feature_extractor (`SiglipImageProcessor`, *opcional*) : Procesador de imágenes para IP Adapter. | |
| #### __call__[[diffusers.StableDiffusion3ControlNetPipeline.__call__]] | |
| ```python | |
| __call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, prompt_3: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 7.0, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, controlnet_conditioning_scale: float | list[float] = 1.0, controlnet_pooled_projections: typing.Optional[torch.FloatTensor] = None, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, negative_prompt_3: str | list[str] | None = None, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, clip_skip: int | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 256) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet.py#L819) | |
| **Parámetros:** | |
| prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar. | |
| prompt_2 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que se enviarán a `tokenizer_2` y `text_encoder_2`. Si no se define, se usará `prompt` en su lugar | |
| prompt_3 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que se enviarán a `tokenizer_3` y `text_encoder_3`. Si no se define, se utilizará `prompt` en su lugar | |
| 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*, por defecto 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 argumento `sigmas` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. | |
| guidance_scale (`float`, *opcional*, valor predeterminado 5.0) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de orientación se habilita estableciendo `guidance_scale > 1`. Una escala de orientación más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen. | |
| control_guidance_start (`float` o `list[float]`, *opcional*, valor predeterminado 0.0) : El porcentaje de pasos totales en el que ControlNet comienza a aplicarse. | |
| control_guidance_end (`float` o `list[float]`, *opcional*, valor predeterminado 1.0) : El porcentaje de pasos totales en el que ControlNet deja de aplicarse. | |
| 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]]` o `list[list[PIL.Image.Image]]`): La condición de entrada de ControlNet para proporcionar orientación a la `unet` durante la generación. Si el tipo se especifica como `torch.Tensor`, se pasa a ControlNet tal cual. También se puede aceptar `PIL.Image.Image` como imagen. Las dimensiones de la imagen de salida son, por defecto, las dimensiones de `image`. Si se pasan la altura y/o el ancho, `image` se redimensiona en consecuencia. Si se especifican varios ControlNets en `init`, las imágenes deben pasarse como una lista para que cada elemento de la lista pueda agruparse correctamente como entrada para un solo ControlNet. | |
| controlnet_conditioning_scale (`float` o `list[float]`, *opcional*, valor predeterminado 1.0) : Las salidas del ControlNet se multiplican por `controlnet_conditioning_scale` antes de sumarse al residual en el `unet` original. Si se especifican varios ControlNets en `init`, puedes establecer la escala correspondiente como una lista. | |
| controlnet_pooled_projections (`torch.FloatTensor` de forma `(batch_size, projection_dim)`) : Incrustaciones proyectadas a partir de las incrustaciones de las condiciones de entrada de controlnet. | |
| negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). | |
| negative_prompt_2 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen y que se enviarán a `tokenizer_2` y `text_encoder_2`. Si no se define, se utiliza `negative_prompt` en su lugar | |
| negative_prompt_3 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen y que se enviarán a `tokenizer_3` y `text_encoder_3`. Si no se define, se utiliza `negative_prompt` en su lugar | |
| num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. | |
| generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) 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 el `generator` aleatorio suministrado. | |
| prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. | |
| negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`. | |
| pooled_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto agrupados se generarán a partir del argumento de entrada `prompt`. | |
| negative_pooled_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativo ya generados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* el peso de los prompts. Si no se proporcionan, los pooled negative_prompt_embeds se generarán a partir del argumento de entrada `negative_prompt`. | |
| ip_adapter_image (`PipelineImageInput`, *opcional*) : Entrada de imagen opcional para trabajar con IP Adapters. | |
| ip_adapter_image_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser un tensor de forma `(batch_size, num_images, emb_dim)`. Debe contener la incrustación de imagen negativa si `do_classifier_free_guidance` está establecido en `True`. Si no se proporciona, las incrustaciones se calculan a partir del argumento de entrada `ip_adapter_image`. | |
| output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`. | |
| return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` en lugar de una tupla simple. | |
| joint_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). | |
| clip_skip (`int`, *opcional*) : Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la capa previa a la final para calcular los embeddings del prompt. | |
| 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_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`. | |
| callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline. | |
| max_sequence_length (`int` por defecto 256) : Longitud máxima de la secuencia a utilizar con el `prompt`. | |
| **Devuelve:** `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` o `tuple` | |
| `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` 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: | |
| ```py | |
| >>> import torch | |
| >>> from diffusers import StableDiffusion3ControlNetPipeline | |
| >>> from diffusers.models import SD3ControlNetModel, SD3MultiControlNetModel | |
| >>> from diffusers.utils import load_image | |
| >>> controlnet = SD3ControlNetModel.from_pretrained("InstantX/SD3-Controlnet-Canny", torch_dtype=torch.float16) | |
| >>> pipe = StableDiffusion3ControlNetPipeline.from_pretrained( | |
| ... "stabilityai/stable-diffusion-3-medium-diffusers", controlnet=controlnet, torch_dtype=torch.float16 | |
| ... ) | |
| >>> pipe.to("cuda") | |
| >>> control_image = load_image( | |
| ... "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png" | |
| ... ) | |
| >>> prompt = "A bird in space" | |
| >>> image = pipe( | |
| ... prompt, control_image=control_image, height=1024, width=768, controlnet_conditioning_scale=0.7 | |
| ... ).images[0] | |
| >>> image.save("sd3.png") | |
| ``` | |
| #### encode_image[[diffusers.StableDiffusion3ControlNetPipeline.encode_image]] | |
| ```python | |
| encode_image(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], device: device) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet.py#L742) | |
| **Parámetros:** | |
| image (`PipelineImageInput`) : Imagen de entrada que se codificará. | |
| device : (`torch.device`): Dispositivo de Torch. | |
| **Devuelve:** `torch.Tensor` | |
| La representación de características de la imagen codificada. | |
| Codifica la imagen dada en una representación de características utilizando un codificador de imágenes preentrenado. | |
| #### encode_prompt[[diffusers.StableDiffusion3ControlNetPipeline.encode_prompt]] | |
| ```python | |
| encode_prompt(prompt: str | list[str], prompt_2: str | list[str], prompt_3: str | list[str], device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, negative_prompt_3: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, clip_skip: int | None = None, max_sequence_length: int = 256, lora_scale: float | None = None) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet.py#L365) | |
| **Parámetros:** | |
| prompt (`str` o `list[str]`, *opcional*) : prompt a codificar | |
| prompt_2 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que se enviarán al `tokenizer_2` y al `text_encoder_2`. Si no se define, se utiliza `prompt` en todos los text-encoders | |
| prompt_3 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que se enviarán al `tokenizer_3` y al `text_encoder_3`. Si no se define, se utiliza `prompt` en 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 | |
| do_classifier_free_guidance (`bool`) : si se debe usar o no la guía libre de clasificador | |
| negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). | |
| negative_prompt_2 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen y que se enviarán a `tokenizer_2` y `text_encoder_2`. Si no se define, `negative_prompt` se utiliza en todos los text-encoders. | |
| negative_prompt_3 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen y que se enviarán a `tokenizer_3` y `text_encoder_3`. Si no se define, `negative_prompt` se utiliza en todos los text-encoders. | |
| prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. | |
| negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`. | |
| pooled_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto agrupados se generarán a partir del argumento de entrada `prompt`. | |
| negative_pooled_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativo ya generados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* el peso de los prompts. Si no se proporcionan, los pooled negative_prompt_embeds se generarán a partir del argumento de entrada `negative_prompt`. | |
| clip_skip (`int`, *opcional*) : Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la capa previa a la final para calcular los embeddings del prompt. | |
| lora_scale (`float`, *opcional*) : Una escala lora que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA. | |
| #### prepare_ip_adapter_image_embeds[[diffusers.StableDiffusion3ControlNetPipeline.prepare_ip_adapter_image_embeds]] | |
| ```python | |
| prepare_ip_adapter_image_embeds(ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: typing.Optional[torch.Tensor] = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet.py#L762) | |
| **Parámetros:** | |
| ip_adapter_image (`PipelineImageInput`, *opcional*) : La imagen de entrada de la que se extraerán las características para IP-Adapter. | |
| ip_adapter_image_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de imagen precalculadas. | |
| device : (`torch.device`, *opcional*): Dispositivo de Torch. | |
| num_images_per_prompt (`int`, por defecto 1) : Número de imágenes que deben generarse por indicación. | |
| do_classifier_free_guidance (`bool`, por defecto True) : Si se debe usar o no la guía libre de clasificador. | |
| Prepara los embeddings de imagen para su uso en el IP-Adapter. | |
| Se debe pasar `ip_adapter_image` o `ip_adapter_image_embeds`. | |
| ## StableDiffusion3ControlNetInpaintingPipeline[[diffusers.StableDiffusion3ControlNetInpaintingPipeline]] | |
| #### diffusers.StableDiffusion3ControlNetInpaintingPipeline[[diffusers.StableDiffusion3ControlNetInpaintingPipeline]] | |
| ```python | |
| diffusers.StableDiffusion3ControlNetInpaintingPipeline(transformer: SD3Transformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, text_encoder_2: CLIPTextModelWithProjection, tokenizer_2: CLIPTokenizer, text_encoder_3: T5EncoderModel, tokenizer_3: T5Tokenizer, controlnet: diffusers.models.controlnets.controlnet_sd3.SD3ControlNetModel | list[diffusers.models.controlnets.controlnet_sd3.SD3ControlNetModel] | tuple[diffusers.models.controlnets.controlnet_sd3.SD3ControlNetModel] | diffusers.models.controlnets.controlnet_sd3.SD3MultiControlNetModel, image_encoder: SiglipModel = None, feature_extractor: transformers.models.siglip.image_processing_pil_siglip.SiglipImageProcessorPil | None = None) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet_inpainting.py#L166) | |
| **Parámetros:** | |
| transformer ([SD3Transformer2DModel](/docs/diffusers/v0.43.0/es/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados. | |
| scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados. | |
| vae ([AutoencoderKL](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes. | |
| text_encoder (`CLIPTextModelWithProjection`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), específicamente la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14), con una capa de proyección adicional que se inicializa con una matriz diagonal cuya dimensión es `hidden_size`. | |
| text_encoder_2 (`CLIPTextModelWithProjection`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), específicamente la variante [laion/CLIP-ViT-bigG-14-laion2B-39B-b160k](https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k). | |
| text_encoder_3 (`T5EncoderModel`) : Codificador de texto congelado. Stable Diffusion 3 utiliza [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), específicamente la variante [t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl). | |
| tokenizer (`CLIPTokenizer`) : Tokenizador de la clase [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). | |
| tokenizer_2 (`CLIPTokenizer`) : Segundo Tokenizer de la clase [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). | |
| tokenizer_3 (`T5TokenizerFast`) : Tokenizador de la clase [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer). | |
| controlnet ([SD3ControlNetModel](/docs/diffusers/v0.43.0/es/api/models/controlnet_sd3#diffusers.SD3ControlNetModel) o `list[SD3ControlNetModel]` o `SD3MultiControlNetModel`) : Proporciona una condición adicional al `transformer` durante el proceso de desruido. Si configuras varios ControlNets como una lista, las salidas de cada ControlNet se suman para crear una condición adicional combinada. | |
| image_encoder (`PreTrainedModel`, *opcional*) : Modelo de visión preentrenado para IP Adapter. | |
| feature_extractor (`BaseImageProcessor`, *opcional*) : Procesador de imágenes para IP Adapter. | |
| #### __call__[[diffusers.StableDiffusion3ControlNetInpaintingPipeline.__call__]] | |
| ```python | |
| __call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, prompt_3: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 7.0, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, control_mask: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, controlnet_conditioning_scale: float | list[float] = 1.0, controlnet_pooled_projections: typing.Optional[torch.FloatTensor] = None, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, negative_prompt_3: str | list[str] | None = None, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, clip_skip: int | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 256) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet_inpainting.py#L986) | |
| **Parámetros:** | |
| prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar. | |
| prompt_2 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que se enviarán a `tokenizer_2` y `text_encoder_2`. Si no se define, se usará `prompt` en su lugar | |
| prompt_3 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que se enviarán a `tokenizer_3` y `text_encoder_3`. Si no se define, se utilizará `prompt` en su lugar | |
| 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*, por defecto 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 argumento `sigmas` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. | |
| guidance_scale (`float`, *opcional*, valor predeterminado 5.0) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de orientación se habilita estableciendo `guidance_scale > 1`. Una escala de orientación más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen. | |
| control_guidance_start (`float` o `list[float]`, *opcional*, valor predeterminado 0.0) : El porcentaje de pasos totales en el que ControlNet comienza a aplicarse. | |
| control_guidance_end (`float` o `list[float]`, *opcional*, valor predeterminado 1.0) : El porcentaje de pasos totales en el que ControlNet deja de aplicarse. | |
| control_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, `list[np.ndarray]`) : `Image`, array de numpy o tensor que representa un lote de imágenes para ser inpaintadas (qué partes de la imagen se deben enmascarar con `control_mask` y repintar según `prompt`). 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)`. Si es un array de numpy o una lista de arrays, la forma esperada debe ser `(B, H, W, C)` o `(H, W, C)`. | |
| control_mask (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, `list[np.ndarray]`) : `Image`, array de numpy o tensor que representa un lote de imágenes para enmascarar `image`. Los píxeles blancos de la máscara se repintan, mientras que los píxeles negros se conservan. Si `mask_image` es 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)`. Y para un array de numpy sería `(B, H, W, 1)`, `(B, H, W)`, `(H, W, 1)` o `(H, W)`. | |
| controlnet_conditioning_scale (`float` o `list[float]`, *opcional*, valor predeterminado 1.0) : Las salidas del ControlNet se multiplican por `controlnet_conditioning_scale` antes de sumarse al residual en el `unet` original. Si se especifican varios ControlNets en `init`, puedes establecer la escala correspondiente como una lista. | |
| controlnet_pooled_projections (`torch.FloatTensor` de forma `(batch_size, projection_dim)`) : Incrustaciones proyectadas a partir de las incrustaciones de las condiciones de entrada de controlnet. | |
| negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). | |
| negative_prompt_2 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen y que se enviarán a `tokenizer_2` y `text_encoder_2`. Si no se define, se utiliza `negative_prompt` en su lugar | |
| negative_prompt_3 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen y que se enviarán a `tokenizer_3` y `text_encoder_3`. Si no se define, se utiliza `negative_prompt` en su lugar | |
| num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. | |
| generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) 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 el `generator` aleatorio suministrado. | |
| prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. | |
| negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`. | |
| pooled_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto agrupados se generarán a partir del argumento de entrada `prompt`. | |
| negative_pooled_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativo ya generados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* el peso de los prompts. Si no se proporcionan, los pooled negative_prompt_embeds se generarán a partir del argumento de entrada `negative_prompt`. | |
| ip_adapter_image (`PipelineImageInput`, *opcional*) : Entrada de imagen opcional para trabajar con IP Adapters. | |
| ip_adapter_image_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser un tensor de forma `(batch_size, num_images, emb_dim)`. Debe contener la incrustación de imagen negativa si `do_classifier_free_guidance` está establecido en `True`. Si no se proporciona, las incrustaciones se calculan a partir del argumento de entrada `ip_adapter_image`. | |
| output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`. | |
| return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` en lugar de una tupla simple. | |
| joint_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). | |
| clip_skip (`int`, *opcional*) : Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la capa previa a la final para calcular los embeddings del prompt. | |
| 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_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`. | |
| callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline. | |
| max_sequence_length (`int` por defecto 256) : Longitud máxima de la secuencia a utilizar con el `prompt`. | |
| **Devuelve:** `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` o `tuple` | |
| `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` 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: | |
| ```py | |
| >>> import torch | |
| >>> from diffusers.utils import load_image, check_min_version | |
| >>> from diffusers.pipelines import StableDiffusion3ControlNetInpaintingPipeline | |
| >>> from diffusers.models.controlnet_sd3 import SD3ControlNetModel | |
| >>> controlnet = SD3ControlNetModel.from_pretrained( | |
| ... "alimama-creative/SD3-Controlnet-Inpainting", use_safetensors=True, extra_conditioning_channels=1 | |
| ... ) | |
| >>> pipe = StableDiffusion3ControlNetInpaintingPipeline.from_pretrained( | |
| ... "stabilityai/stable-diffusion-3-medium-diffusers", | |
| ... controlnet=controlnet, | |
| ... torch_dtype=torch.float16, | |
| ... ) | |
| >>> pipe.text_encoder.to(torch.float16) | |
| >>> pipe.controlnet.to(torch.float16) | |
| >>> pipe.to("cuda") | |
| >>> image = load_image( | |
| ... "https://huggingface.co/alimama-creative/SD3-Controlnet-Inpainting/resolve/main/images/dog.png" | |
| ... ) | |
| >>> mask = load_image( | |
| ... "https://huggingface.co/alimama-creative/SD3-Controlnet-Inpainting/resolve/main/images/dog_mask.png" | |
| ... ) | |
| >>> width = 1024 | |
| >>> height = 1024 | |
| >>> prompt = "A cat is sitting next to a puppy." | |
| >>> generator = torch.Generator(device="cuda").manual_seed(24) | |
| >>> res_image = pipe( | |
| ... negative_prompt="deformed, distorted, disfigured, poorly drawn, bad anatomy, wrong anatomy, extra limb, missing limb, floating limbs, mutated hands and fingers, disconnected limbs, mutation, mutated, ugly, disgusting, blurry, amputation, NSFW", | |
| ... prompt=prompt, | |
| ... height=height, | |
| ... width=width, | |
| ... control_image=image, | |
| ... control_mask=mask, | |
| ... num_inference_steps=28, | |
| ... generator=generator, | |
| ... controlnet_conditioning_scale=0.95, | |
| ... guidance_scale=7, | |
| ... ).images[0] | |
| >>> res_image.save(f"sd3.png") | |
| ``` | |
| #### encode_image[[diffusers.StableDiffusion3ControlNetInpaintingPipeline.encode_image]] | |
| ```python | |
| encode_image(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], device: device) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet_inpainting.py#L909) | |
| **Parámetros:** | |
| image (`PipelineImageInput`) : Imagen de entrada que se codificará. | |
| device : (`torch.device`): Dispositivo de Torch. | |
| **Devuelve:** `torch.Tensor` | |
| La representación de características de la imagen codificada. | |
| Codifica la imagen dada en una representación de características utilizando un codificador de imágenes preentrenado. | |
| #### encode_prompt[[diffusers.StableDiffusion3ControlNetInpaintingPipeline.encode_prompt]] | |
| ```python | |
| encode_prompt(prompt: str | list[str], prompt_2: str | list[str], prompt_3: str | list[str], device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, negative_prompt_3: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, clip_skip: int | None = None, max_sequence_length: int = 256, lora_scale: float | None = None) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet_inpainting.py#L387) | |
| **Parámetros:** | |
| prompt (`str` o `list[str]`, *opcional*) : prompt a codificar | |
| prompt_2 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que se enviarán al `tokenizer_2` y al `text_encoder_2`. Si no se define, se utiliza `prompt` en todos los text-encoders | |
| prompt_3 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que se enviarán al `tokenizer_3` y al `text_encoder_3`. Si no se define, se utiliza `prompt` en 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 | |
| do_classifier_free_guidance (`bool`) : si se debe usar o no la guía libre de clasificador | |
| negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). | |
| negative_prompt_2 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen y que se enviarán a `tokenizer_2` y `text_encoder_2`. Si no se define, `negative_prompt` se utiliza en todos los text-encoders. | |
| negative_prompt_3 (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen y que se enviarán a `tokenizer_3` y `text_encoder_3`. Si no se define, `negative_prompt` se utiliza en todos los text-encoders. | |
| prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. | |
| negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`. | |
| pooled_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto agrupados se generarán a partir del argumento de entrada `prompt`. | |
| negative_pooled_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativo ya generados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* el peso de los prompts. Si no se proporcionan, los pooled negative_prompt_embeds se generarán a partir del argumento de entrada `negative_prompt`. | |
| clip_skip (`int`, *opcional*) : Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la capa previa a la final para calcular los embeddings del prompt. | |
| lora_scale (`float`, *opcional*) : Una escala lora que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA. | |
| #### prepare_ip_adapter_image_embeds[[diffusers.StableDiffusion3ControlNetInpaintingPipeline.prepare_ip_adapter_image_embeds]] | |
| ```python | |
| prepare_ip_adapter_image_embeds(ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: typing.Optional[torch.Tensor] = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/controlnet_sd3/pipeline_stable_diffusion_3_controlnet_inpainting.py#L929) | |
| **Parámetros:** | |
| ip_adapter_image (`PipelineImageInput`, *opcional*) : La imagen de entrada de la que se extraerán las características para IP-Adapter. | |
| ip_adapter_image_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de imagen precalculadas. | |
| device : (`torch.device`, *opcional*): Dispositivo de Torch. | |
| num_images_per_prompt (`int`, por defecto 1) : Número de imágenes que deben generarse por indicación. | |
| do_classifier_free_guidance (`bool`, por defecto True) : Si se debe usar o no la guía libre de clasificador. | |
| Prepara los embeddings de imagen para su uso en el IP-Adapter. | |
| Se debe pasar `ip_adapter_image` o `ip_adapter_image_embeds`. | |
| ## StableDiffusion3PipelineOutput[[diffusers.pipelines.stable_diffusion_3.pipeline_output.StableDiffusion3PipelineOutput]] | |
| #### diffusers.pipelines.stable_diffusion_3.pipeline_output.StableDiffusion3PipelineOutput[[diffusers.pipelines.stable_diffusion_3.pipeline_output.StableDiffusion3PipelineOutput]] | |
| ```python | |
| diffusers.pipelines.stable_diffusion_3.pipeline_output.StableDiffusion3PipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_3/pipeline_output.py#L10) | |
| **Parámetros:** | |
| images (`list[PIL.Image.Image]` o `np.ndarray`) : lista de imágenes PIL desruidas de longitud `batch_size` o matriz numpy de forma `(batch_size, height, width, num_channels)`. Las imágenes PIL o la matriz numpy presentan las imágenes desruidas del pipeline de difusión. | |
| Clase de salida para las tuberías de Stable Diffusion. | |
Xet Storage Details
- Size:
- 50 kB
- Xet hash:
- 9034ea41e0607c53cc09424f46cfaea0483e5ef77fc7d608878c3ff7e7ee94e3
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.