# Guía de atención perturbada [Perturbed-Attention Guidance (PAG)](https://ku-cvlab.github.io/Perturbed-Attention-Guidance/) es una nueva guía de muestreo de difusión que mejora la calidad de las muestras tanto en configuraciones incondicionales como condicionales, lográndolo sin necesidad de entrenamiento adicional ni de la integración de módulos externos. PAG se introdujo en [Self-Rectifying Diffusion Sampling with Perturbed-Attention Guidance](https://huggingface.co/papers/2403.17377) por Donghoon Ahn, Hyoungwon Cho, Jaewon Min, Wooseok Jang, Jungwoo Kim, SeonHwa Kim, Hyun Hee Park, Kyong Hwan Jin y Seungryong Kim. El resumen del artículo es: *Estudios recientes han demostrado que los modelos de difusión son capaces de generar muestras de alta calidad, pero su calidad depende en gran medida de las técnicas de guía de muestreo, como la guía del clasificador (CG) y la guía libre de clasificador (CFG). Estas técnicas a menudo no son aplicables en la generación incondicional o en diversas tareas descendentes, como la restauración de imágenes. En este artículo, proponemos una guía de muestreo novedosa, llamada Perturbed-Attention Guidance (PAG), que mejora la calidad de las muestras de difusión tanto en configuraciones incondicionales como condicionales, lográndolo sin necesidad de entrenamiento adicional ni de la integración de módulos externos. PAG está diseñado para mejorar progresivamente la estructura de las muestras a lo largo del proceso de eliminación de ruido. Implica generar muestras intermedias con estructura degradada sustituyendo mapas de autoatención seleccionados en la U-Net de difusión por una matriz identidad, considerando la capacidad de los mecanismos de autoatención para capturar información estructural, y guiando el proceso de eliminación de ruido alejándolo de estas muestras degradadas. Tanto en ADM como en Stable Diffusion, PAG mejora de manera sorprendente la calidad de las muestras en escenarios condicionales e incluso incondicionales. Además, PAG mejora significativamente el rendimiento de la línea base en diversas tareas descendentes donde las guías existentes, como CG o CFG, no pueden aprovecharse por completo, incluyendo ControlNet con prompts vacíos y la restauración de imágenes, como el inpainting y la eliminación de desenfoque.* PAG se puede utilizar especificando `pag_applied_layers` como parámetro al instanciar un pipeline de PAG. Puede ser una sola cadena o una lista de cadenas. Cada cadena puede ser un identificador de capa único o una expresión regular para identificar una o más capas. - Identificador completo como una cadena normal: `down_blocks.2.attentions.0.transformer_blocks.0.attn1.processor` - Identificador completo como RegEx: `down_blocks.2.(attentions|motion_modules).0.transformer_blocks.0.attn1.processor` - Identificador parcial como RegEx: `down_blocks.2` o `attn1` - Lista de identificadores (puede ser una combinación de cadenas y ReGex): `["blocks.1", "blocks.(14|20)", r"down_blocks\.(2,3)"]` > [!WARNING] > Dado que RegEx se admite como método para coincidir con identificadores de capas, es crucial utilizarlo correctamente; de lo contrario, podría haber un comportamiento inesperado. La forma recomendada de usar PAG es especificar las capas como `blocks.{layer_index}` y `blocks.({layer_index_1|layer_index_2|...})`. Usarlo de cualquier otra manera, aunque sea posible, puede omitir nuestras comprobaciones básicas de validación y darte resultados inesperados. ## Tareas generales Puedes aplicar PAG a [StableDiffusionXLPipeline](/docs/diffusers/main/es/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLPipeline) para tareas como texto a imagen, imagen a imagen e inpainting. Para habilitar PAG para una tarea específica, carga el pipeline usando la API [AutoPipeline](./auto_pipeline) con la bandera `enable_pag=True` y el argumento `pag_applied_layers`. > [!TIP] > 🤗 Diffusers actualmente solo admite el uso de PAG con las pipelines seleccionadas de SDXL y [PixArtSigmaPAGPipeline](/docs/diffusers/main/es/api/pipelines/pag#diffusers.PixArtSigmaPAGPipeline). Pero no dudes en abrir una [solicitud de funcionalidad](https://github.com/huggingface/diffusers/issues/new/choose) si deseas agregar soporte para PAG a una nueva pipeline. ```py from diffusers import AutoPipelineForText2Image from diffusers.utils import load_image import torch pipeline = AutoPipelineForText2Image.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", enable_pag=True, pag_applied_layers=["mid"], dtype=torch.float16 ) pipeline.enable_model_cpu_offload() ``` > [!TIP] > El argumento `pag_applied_layers` permite especificar a qué capas se aplica PAG. Además, puede usar el método `set_pag_applied_layers` para actualizar estas capas después de que se haya creado el pipeline. Consulte la sección [pag_applied_layers](#pagappliedlayers) para obtener más información sobre cómo aplicar PAG a otras capas. Si ya tienes un pipeline creado y cargado, puedes activar PAG en él usando la API `from_pipe` con la bandera `enable_pag`. Internamente, se crea un pipeline PAG basado en el pipeline y la tarea que especificaste. En el ejemplo siguiente, como usamos `AutoPipelineForText2Image` y pasamos un `StableDiffusionXLPipeline`, se crea un `StableDiffusionXLPAGPipeline` en consecuencia. Ten en cuenta que esto no requiere memoria adicional, y tendrás tanto `StableDiffusionXLPipeline` como `StableDiffusionXLPAGPipeline` cargados y listos para usar. Puedes leer más sobre la API `from_pipe` y cómo reutilizar pipelines en diffuser [aquí](../../using-diffusers/loading#reusing-models-in-multiple-pipelines). ```py pipeline_sdxl = AutoPipelineForText2Image.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16) pipeline = AutoPipelineForText2Image.from_pipe(pipeline_sdxl, enable_pag=True) ``` Para generar una imagen, también es necesario pasar un `pag_scale`. A medida que `pag_scale` aumenta, las imágenes adquieren estructuras más coherentes semánticamente y presentan menos artefactos. Sin embargo, una escala de guía demasiado grande puede resultar en texturas más suaves y una ligera saturación en las imágenes, de manera similar a CFG. Se utiliza `pag_scale=3.0` en la demo oficial y funciona bien en la mayoría de los casos de uso, pero no dudes en experimentar y seleccionar el valor adecuado según tus necesidades! PAG se desactiva cuando `pag_scale=0`. ```py prompt = "an insect robot preparing a delicious meal, anime style" for pag_scale in [0.0, 3.0]: generator = torch.Generator(device="cpu").manual_seed(0) images = pipeline( prompt=prompt, num_inference_steps=25, guidance_scale=7.0, generator=generator, pag_scale=pag_scale, ).images ``` imagen generada sin PAG imagen generada con PAG Puedes usar PAG con pipelines de imagen a imagen. ```py from diffusers import AutoPipelineForImage2Image from diffusers.utils import load_image import torch pipeline = AutoPipelineForImage2Image.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", enable_pag=True, pag_applied_layers=["mid"], dtype=torch.float16 ) pipeline.enable_model_cpu_offload() ``` Si ya tienes un pipeline de imagen a imagen y deseas habilitar PAG en él, puedes ejecutar esto ```py pipeline_t2i = AutoPipelineForImage2Image.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16) pipeline = AutoPipelineForImage2Image.from_pipe(pipeline_t2i, enable_pag=True) ``` También es muy fácil cambiar directamente de un pipeline de texto a imagen a un pipeline de imagen a imagen con PAG habilitado ```py pipeline_pag = AutoPipelineForText2Image.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16) pipeline = AutoPipelineForImage2Image.from_pipe(pipeline_t2i, enable_pag=True) ``` Si tienes un pipeline de texto a imagen con PAG habilitado, puedes cambiar directamente a un pipeline de imagen a imagen manteniendo PAG habilitado ```py pipeline_pag = AutoPipelineForText2Image.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0", enable_pag=True, dtype=torch.float16) pipeline = AutoPipelineForImage2Image.from_pipe(pipeline_t2i) ``` Ahora generemos una imagen. ```py pag_scales = 4.0 guidance_scales = 7.0 url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/sdxl-text2img.png" init_image = load_image(url) prompt = "a dog catching a frisbee in the jungle" generator = torch.Generator(device="cpu").manual_seed(0) image = pipeline( prompt, image=init_image, strength=0.8, guidance_scale=guidance_scale, pag_scale=pag_scale, generator=generator).images[0] ``` ```py from diffusers import AutoPipelineForInpainting from diffusers.utils import load_image import torch pipeline = AutoPipelineForInpainting.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", enable_pag=True, dtype=torch.float16 ) pipeline.enable_model_cpu_offload() ``` Puedes habilitar PAG en un pipeline de inpainting existente de la siguiente manera ```py pipeline_inpaint = AutoPipelineForInpainting.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16) pipeline = AutoPipelineForInpainting.from_pipe(pipeline_inpaint, enable_pag=True) ``` Esto sigue funcionando cuando tu pipeline tiene una tarea diferente: ```py pipeline_t2i = AutoPipelineForText2Image.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16) pipeline = AutoPipelineForInpaiting.from_pipe(pipeline_t2i, enable_pag=True) ``` ¡Generemos una imagen! ```py 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" init_image = load_image(img_url).convert("RGB") mask_image = load_image(mask_url).convert("RGB") prompt = "A majestic tiger sitting on a bench" pag_scales = 3.0 guidance_scales = 7.5 generator = torch.Generator(device="cpu").manual_seed(1) images = pipeline( prompt=prompt, image=init_image, mask_image=mask_image, strength=0.8, num_inference_steps=50, guidance_scale=guidance_scale, generator=generator, pag_scale=pag_scale, ).images images[0] ``` ## PAG con ControlNet Para usar PAG con ControlNet, primero cree un `controlnet`. A continuación, pase el `controlnet` y otros argumentos de PAG al método `from_pretrained` del AutoPipeline para la tarea especificada. ```py from diffusers import AutoPipelineForText2Image, ControlNetModel import torch controlnet = ControlNetModel.from_pretrained( "diffusers/controlnet-canny-sdxl-1.0", dtype=torch.float16 ) pipeline = AutoPipelineForText2Image.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", controlnet=controlnet, enable_pag=True, pag_applied_layers="mid", dtype=torch.float16 ) pipeline.enable_model_cpu_offload() ``` > [!TIP] > Si ya tienes un pipeline de controlnet y quieres habilitar PAG, puedes usar la API `from_pipe`: `AutoPipelineForText2Image.from_pipe(pipeline_controlnet, enable_pag=True)` Puede usar el pipeline de la misma manera que normalmente usa los pipelines de ControlNet, con la opción adicional de especificar un parámetro `pag_scale`. Tenga en cuenta que PAG funciona bien para la generación incondicional. En este ejemplo, generaremos una imagen sin un prompt. ```py from diffusers.utils import load_image canny_image = load_image( "https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/pag_control_input.png" ) for pag_scale in [0.0, 3.0]: generator = torch.Generator(device="cpu").manual_seed(1) images = pipeline( prompt="", controlnet_conditioning_scale=controlnet_conditioning_scale, image=canny_image, num_inference_steps=50, guidance_scale=0, generator=generator, pag_scale=pag_scale, ).images images[0] ``` imagen generada sin PAG imagen generada con PAG ## PAG con IP-Adapter [IP-Adapter](https://hf.co/papers/2308.06721) es un modelo popular que se puede integrar en modelos de difusión para habilitar el uso de imágenes como prompt sin realizar cambios en el modelo subyacente. Puedes habilitar PAG en un pipeline con IP-Adapter cargado. ```py from diffusers import AutoPipelineForText2Image from diffusers.utils import load_image from transformers import CLIPVisionModelWithProjection import torch image_encoder = CLIPVisionModelWithProjection.from_pretrained( "h94/IP-Adapter", subfolder="models/image_encoder", dtype=torch.float16 ) pipeline = AutoPipelineForText2Image.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", image_encoder=image_encoder, enable_pag=True, dtype=torch.float16 ).to("cuda") # or "mps", "xpu", "cpu" pipeline.load_ip_adapter("h94/IP-Adapter", subfolder="sdxl_models", weight_name="ip-adapter-plus_sdxl_vit-h.bin") pag_scales = 5.0 ip_adapter_scales = 0.8 image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/ip_adapter_diner.png") pipeline.set_ip_adapter_scale(ip_adapter_scale) generator = torch.Generator(device="cpu").manual_seed(0) images = pipeline( prompt="a polar bear sitting in a chair drinking a milkshake", ip_adapter_image=image, negative_prompt="deformed, ugly, wrong proportion, low res, bad anatomy, worst quality, low quality", num_inference_steps=25, guidance_scale=3.0, generator=generator, pag_scale=pag_scale, ).images images[0] ``` PAG reduce los artefactos y mejora la composición general. imagen generada sin PAG imagen generada con PAG ## Configurar parámetros ### pag_applied_layers El argumento `pag_applied_layers` permite especificar a qué capas se aplica PAG. De forma predeterminada, solo se aplica a los bloques intermedios. Cambiar esta configuración tendrá un impacto significativo en la salida. Puede utilizar el método `set_pag_applied_layers` para ajustar las capas de PAG después de crear la pipeline, lo que le ayuda a encontrar las capas óptimas para su modelo. Como ejemplo, aquí están las imágenes generadas con `pag_layers = ["down.block_2"]` y `pag_layers = ["down.block_2", "up.block_1.attentions_0"]` ```py prompt = "an insect robot preparing a delicious meal, anime style" pipeline.set_pag_applied_layers(pag_layers) generator = torch.Generator(device="cpu").manual_seed(0) images = pipeline( prompt=prompt, num_inference_steps=25, guidance_scale=guidance_scale, generator=generator, pag_scale=pag_scale, ).images images[0] ``` down.block_2 + up.block1.attentions_0 down.block_2 ## AnimateDiffPAGPipeline[[diffusers.AnimateDiffPAGPipeline]] #### diffusers.AnimateDiffPAGPipeline[[diffusers.AnimateDiffPAGPipeline]] ```python diffusers.AnimateDiffPAGPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: diffusers.models.unets.unet_2d_condition.UNet2DConditionModel | diffusers.models.unets.unet_motion_model.UNetMotionModel, motion_adapter: MotionAdapter, scheduler: KarrasDiffusionSchedulers, feature_extractor: CLIPImageProcessorPil = None, image_encoder: CLIPVisionModelWithProjection = None, pag_applied_layers: str | list[str] = 'mid_block.*attn1') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_animatediff.py#L89) **Parámetros:** vae ([AutoencoderKL](/docs/diffusers/main/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 (`CLIPTextModel`) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). tokenizer (`CLIPTokenizer`) : Un [CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer) para tokenizar texto. unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Un [UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel) utilizado para crear un UNetMotionModel que desruidice los latentes de video codificados. motion_adapter (`MotionAdapter`) : Un `MotionAdapter` para usar en combinación con `unet` para desruidar los latentes de video codificados. scheduler ([SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Puede ser uno de [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/es/api/schedulers/pndm#diffusers.PNDMScheduler). Pipeline para la generación de texto a video usando [AnimateDiff](https://huggingface.co/docs/diffusers/en/api/pipelines/animatediff) y [Perturbed Attention Guidance](https://huggingface.co/docs/diffusers/en/using-diffusers/pag). Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.). El pipeline también hereda los siguientes métodos de carga: - [load_textual_inversion()](/docs/diffusers/main/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual - [load_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA - [save_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA - [load_ip_adapter()](/docs/diffusers/main/es/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para cargar IP Adapters #### __call__[[diffusers.AnimateDiffPAGPipeline.__call__]] ```python __call__(prompt: str | list[str] | None = None, num_frames: int | None = 16, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, guidance_scale: float = 7.5, negative_prompt: str | list[str] | None = None, num_videos_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_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'], decode_chunk_size: int = 16, pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_animatediff.py#L575) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de imágenes. Si no se define, debe pasar `prompt_embeds`. height (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : La altura en píxeles del video generado. width (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : El ancho en píxeles del video generado. num_frames (`int`, *opcional*, valor predeterminado 16) : El número de fotogramas de video que se generan. El valor predeterminado es de 16 fotogramas, lo que a 8 fotogramas por segundo equivale a 2 segundos de video. num_inference_steps (`int`, *opcional*, valor predeterminado 50) : El número de pasos de desruido. Más pasos de desruido suelen conducir a videos de mayor calidad a costa de una inferencia más lenta. guidance_scale (`float`, *opcional*, valor predeterminado 7.5) : Un valor más alto de la escala de guía anima al modelo a generar imágenes estrechamente vinculadas al `prompt` de texto a costa de una menor calidad de imagen. La escala de guía se habilita cuando `guidance_scale > 1`. negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar lo que no debe incluirse en la generación de la imagen. Si no se define, debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale < 1`). num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de videos a generar por indicación. eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) del artículo [DDIM](https://huggingface.co/papers/2010.02502). Solo se aplica al [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler) y se ignora en otros programadores. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados muestreados de una distribución gaussiana, para usarse como entradas para la generación de video. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporcionan, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. Los latentes deben tener la forma `(batch_size, num_channel, num_frames, height, width)`. prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan 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 (`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)`. 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 del video generado. Elija entre `torch.Tensor`, `PIL.Image` o `np.array`. return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.text_to_video_synthesis.TextToVideoSDPipelineOutput` en lugar de una tupla simple. cross_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define en [`self.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. decode_chunk_size (`int`, *opcional*, valor predeterminado 16) : El número de fotogramas a decodificar a la vez al llamar al método `decode_latents`. pag_scale (`float`, *opcional*, valor predeterminado 3.0) : El factor de escala para la guía de atención perturbada. Si se establece en 0.0, no se utilizará la guía de atención perturbada. pag_adaptive_scale (`float`, *opcional*, valor predeterminado 0.0) : El factor de escala adaptativo para la guía de atención perturbada. Si se establece en 0.0, se utiliza `pag_scale`. **Devuelve:** [AnimateDiffPipelineOutput](/docs/diffusers/main/es/api/pipelines/animatediff#diffusers.pipelines.animatediff.AnimateDiffPipelineOutput) o `tuple` Si `return_dict` es `True`, se devuelve [AnimateDiffPipelineOutput](/docs/diffusers/main/es/api/pipelines/animatediff#diffusers.pipelines.animatediff.AnimateDiffPipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con los fotogramas generados. La función de llamada para el pipeline de generación. Ejemplos: ```py >>> import torch >>> from diffusers import AnimateDiffPAGPipeline, MotionAdapter, DDIMScheduler >>> from diffusers.utils import export_to_gif >>> model_id = "SG161222/Realistic_Vision_V5.1_noVAE" >>> motion_adapter_id = "guoyww/animatediff-motion-adapter-v1-5-2" >>> motion_adapter = MotionAdapter.from_pretrained(motion_adapter_id) >>> scheduler = DDIMScheduler.from_pretrained( ... model_id, subfolder="scheduler", beta_schedule="linear", steps_offset=1, clip_sample=False ... ) >>> pipe = AnimateDiffPAGPipeline.from_pretrained( ... model_id, ... motion_adapter=motion_adapter, ... scheduler=scheduler, ... pag_applied_layers=["mid"], ... torch_dtype=torch.float16, ... ).to("cuda") >>> video = pipe( ... prompt="car, futuristic cityscape with neon lights, street, no human", ... negative_prompt="low quality, bad quality", ... num_inference_steps=25, ... guidance_scale=6.0, ... pag_scale=3.0, ... generator=torch.Generator().manual_seed(42), ... ).frames[0] >>> export_to_gif(video, "animatediff_pag.gif") ``` #### encode_prompt[[diffusers.AnimateDiffPAGPipeline.encode_prompt]] ```python encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_animatediff.py#L165) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar 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`). prompt_embeds (`torch.Tensor`, *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.Tensor`, *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`. lora_scale (`float`, *opcional*) : Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA. 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. Codifica el prompt en estados ocultos del codificador de texto. ## HunyuanDiTPAGPipeline[[diffusers.HunyuanDiTPAGPipeline]] #### diffusers.HunyuanDiTPAGPipeline[[diffusers.HunyuanDiTPAGPipeline]] ```python diffusers.HunyuanDiTPAGPipeline(vae: AutoencoderKL, text_encoder: BertModel, tokenizer: BertTokenizer, transformer: HunyuanDiT2DModel, scheduler: DDPMScheduler, safety_checker: diffusers.pipelines.stable_diffusion.safety_checker.StableDiffusionSafetyChecker | None = None, feature_extractor: transformers.models.clip.image_processing_pil_clip.CLIPImageProcessorPil | None = None, requires_safety_checker: bool = True, text_encoder_2: transformers.models.t5.modeling_t5.T5EncoderModel | None = None, tokenizer_2: transformers.models.t5.tokenization_t5.T5Tokenizer | None = None, pag_applied_layers: str | list[str] = 'blocks.1') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_hunyuandit.py#L152) **Parámetros:** vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes. Utilizamos `sdxl-vae-fp16-fix`. text_encoder (`~transformers.BertModel`, `~transformers.CLIPTextModel` | None) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). HunyuanDiT utiliza un [CLIP bilingüe] afinado. tokenizer (`~transformers.BertTokenizer`, `~transformers.CLIPTokenizer` | None) : Un `BertTokenizer` o `CLIPTokenizer` para tokenizar el texto. transformer ([HunyuanDiT2DModel](/docs/diffusers/main/es/api/models/hunyuan_transformer2d#diffusers.HunyuanDiT2DModel)) : El modelo HunyuanDiT diseñado por Tencent Hunyuan. text_encoder_2 (`T5EncoderModel`) : El incrustador mT5. Específicamente, es 't5-v1_1-xxl'. tokenizer_2 (`T5Tokenizer`) : El tokenizador del incrustador mT5. scheduler ([DDPMScheduler](/docs/diffusers/main/es/api/schedulers/ddpm#diffusers.DDPMScheduler)) : Un programador para usar en combinación con HunyuanDiT para desruidar los latentes de imagen codificados. Pipeline para la generación de imágenes a partir de inglés/chino utilizando HunyuanDiT y [Perturbed Attention Guidance](https://huggingface.co/docs/diffusers/en/using-diffusers/pag). Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la ejecución en un dispositivo específico, etc.) HunyuanDiT utiliza dos codificadores de texto: [mT5](https://huggingface.co/google/mt5-base) y [CLIP bilingüe](fine-tuned by ourselves) #### __call__[[diffusers.HunyuanDiTPAGPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, guidance_scale: float = 5.0, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_2: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_2: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, prompt_attention_mask_2: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask_2: typing.Optional[torch.Tensor] = None, output_type: str = 'pil', return_dict: bool = True, callback_on_step_end: typing.Union[typing.Callable[[int, int, dict], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], guidance_rescale: float = 0.0, original_size: tuple[int, int] = (1024, 1024), target_size: tuple[int, int] = None, crops_coords_top_left: tuple[int, int] = (0, 0), use_resolution_binning: bool = True, pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_hunyuandit.py#L579) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de imágenes. Si no se define, debe pasar `prompt_embeds`. height (`int`) : La altura en píxeles de la imagen generada. width (`int`) : El ancho en píxeles de la imagen generada. 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. Este parámetro se modula por `strength`. guidance_scale (`float`, *opcional*, valor predeterminado 7.5) : Un valor más alto de la escala de guía anima al modelo a generar imágenes estrechamente vinculadas al `prompt` de texto a costa de una menor calidad de imagen. La escala de guía se habilita cuando `guidance_scale > 1`. negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar lo que no debe incluirse en la generación de la imagen. Si no se define, debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale < 1`). num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) del artículo [DDIM](https://huggingface.co/papers/2010.02502). Solo se aplica al [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler) y se ignora en otros programadores. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista. latents (`torch.Tensor`, *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. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`. prompt_embeds_2 (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan a partir del argumento de entrada `negative_prompt`. negative_prompt_embeds_2 (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan a partir del argumento de entrada `negative_prompt`. prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención para el prompt. Obligatorio cuando se pasa `prompt_embeds` directamente. prompt_attention_mask_2 (`torch.Tensor`, *opcional*) : Máscara de atención para el prompt. Obligatorio cuando se pasa `prompt_embeds_2` directamente. negative_prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención para el prompt negativo. Obligatorio cuando se pasa `negative_prompt_embeds` directamente. negative_prompt_attention_mask_2 (`torch.Tensor`, *opcional*) : Máscara de atención para el prompt negativo. Obligatorio cuando se pasa `negative_prompt_embeds_2` directamente. output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre `PIL.Image` o `np.array`. return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) en lugar de una tupla simple. callback_on_step_end (`Callable[[int, int], None]`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Una función de callback o una lista de funciones de callback que se llamarán al final de cada paso de denoising. callback_on_step_end_tensor_inputs (`list[str]`, *opcional*) : Una lista de entradas de tensor que deben pasarse a la función de callback. Si no se define, se pasarán todas las entradas de tensor. guidance_rescale (`float`, *opcional*, valor predeterminado 0.0) : Reescala el ruido_cfg según `guidance_rescale`. Basado en los hallazgos de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). Ver la sección 3.4 original_size (`tuple[int, int]`, *opcional*, valor predeterminado `(1024, 1024)`) : El tamaño original de la imagen. Se utiliza para calcular los ids de tiempo. target_size (`tuple[int, int]`, *opcional*) : El tamaño objetivo de la imagen. Se utiliza para calcular los ids de tiempo. crops_coords_top_left (`tuple[int, int]`, *opcional*, valor predeterminado `(0, 0)`) : Las coordenadas de la esquina superior izquierda del recorte. Se utiliza para calcular los ids de tiempo. use_resolution_binning (`bool`, *opcional*, valor predeterminado `True`) : Si se usa el agrupamiento por resolución o no. Si es `True`, la resolución de entrada se mapeará a la resolución estándar más cercana. Las resoluciones admitidas son 1024x1024, 1280x1280, 1024x768, 1152x864, 1280x960, 768x1024, 864x1152, 960x1280, 1280x768 y 768x1280. Se recomienda establecerlo en `True`. pag_scale (`float`, *opcional*, valor predeterminado 3.0) : El factor de escala para la guía de atención perturbada. Si se establece en 0.0, no se utilizará la guía de atención perturbada. pag_adaptive_scale (`float`, *opcional*, valor predeterminado 0.0) : El factor de escala adaptativo para la guía de atención perturbada. Si se establece en 0.0, se utiliza `pag_scale`. **Devuelve:** [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) o `tuple` Si `return_dict` es `True`, se devuelve [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw). La función de llamada a la pipeline para la generación con HunyuanDiT. Ejemplos: ```python >>> import torch >>> from diffusers import AutoPipelineForText2Image >>> pipe = AutoPipelineForText2Image.from_pretrained( ... "Tencent-Hunyuan/HunyuanDiT-v1.2-Diffusers", ... torch_dtype=torch.float16, ... enable_pag=True, ... pag_applied_layers=[14], ... ).to("cuda") >>> # prompt = "an astronaut riding a horse" >>> prompt = "一个宇航员在骑马" >>> image = pipe(prompt, guidance_scale=4, pag_scale=3).images[0] ``` #### encode_prompt[[diffusers.HunyuanDiTPAGPipeline.encode_prompt]] ```python encode_prompt(prompt: str, device: device = None, dtype: dtype = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int | None = None, text_encoder_index: int = 0) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_hunyuandit.py#L258) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar device : (`torch.device`): dispositivo de torch dtype (`torch.dtype`) : dtype 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`). prompt_embeds (`torch.Tensor`, *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.Tensor`, *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`. prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención para el prompt. Obligatorio cuando se pasa `prompt_embeds` directamente. negative_prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención para el prompt negativo. Obligatorio cuando se pasa `negative_prompt_embeds` directamente. max_sequence_length (`int`, *opcional*) : longitud máxima de la secuencia a utilizar para el prompt. text_encoder_index (`int`, *opcional*) : Índice del codificador de texto a utilizar. `0` para clip y `1` para T5. Codifica el prompt en estados ocultos del codificador de texto. ## KolorsPAGPipeline[[diffusers.KolorsPAGPipeline]] #### diffusers.KolorsPAGPipeline[[diffusers.KolorsPAGPipeline]] ```python diffusers.KolorsPAGPipeline(vae: AutoencoderKL, text_encoder: ChatGLMModel, tokenizer: ChatGLMTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None, force_zeros_for_empty_prompt: bool = False, pag_applied_layers: str | list[str] = 'mid') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_kolors.py#L128) **Parámetros:** vae ([AutoencoderKL](/docs/diffusers/main/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 (`ChatGLMModel`) : Codificador de texto congelado. Kolors utiliza [ChatGLM3-6B](https://huggingface.co/THUDM/chatglm3-6b). tokenizer (`ChatGLMTokenizer`) : Tokenizador de la clase [ChatGLMTokenizer](https://huggingface.co/THUDM/chatglm3-6b/blob/main/tokenization_chatglm.py). unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitectura de U-Net condicional para desruidar los latentes de imagen codificados. scheduler ([SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Puede ser uno de [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/es/api/schedulers/pndm#diffusers.PNDMScheduler). force_zeros_for_empty_prompt (`bool`, *opcional*, valor predeterminado `"False"`) : Si las incrustaciones del prompt negativo deben forzarse a establecerse siempre en 0. Consulte también la configuración de `Kwai-Kolors/Kolors-diffusers`. pag_applied_layers (`str` or `list[str]``, *optional*, defaults to `"mid"`) : Set the transformer attention layers where to apply the perturbed attention guidance. Can be a string or a list of strings with "down", "mid", "up", a whole transformer block or specific transformer block attention layers, e.g.: ["mid"] ["down", "mid"] ["down", "mid", "up.block_1"] ["down", "mid", "up.block_1.attentions_0", "up.block_1.attentions_1"] Pipeline para la generación de imágenes a partir de texto usando Kolors. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la ejecución en un dispositivo específico, etc.) El pipeline también hereda los siguientes métodos de carga: - [load_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA - [save_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA - [load_ip_adapter()](/docs/diffusers/main/es/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para cargar IP Adapters #### __call__[[diffusers.KolorsPAGPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, denoising_end: float | None = None, guidance_scale: float = 5.0, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, original_size: tuple[int, int] | None = None, crops_coords_top_left: tuple[int, int] = (0, 0), target_size: tuple[int, int] | None = None, negative_original_size: tuple[int, int] | None = None, negative_crops_coords_top_left: tuple[int, int] = (0, 0), negative_target_size: tuple[int, int] | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0, max_sequence_length: int = 256) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_kolors.py#L665) **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. 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. Cualquier valor inferior a 512 píxeles no funcionará bien con [Kwai-Kolors/Kolors-diffusers](https://huggingface.co/Kwai-Kolors/Kolors-diffusers) ni con puntos de control que no hayan sido ajustados específicamente para resoluciones bajas. 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. Cualquier valor inferior a 512 píxeles no funcionará bien con [Kwai-Kolors/Kolors-diffusers](https://huggingface.co/Kwai-Kolors/Kolors-diffusers) ni con puntos de control que no hayan sido ajustados específicamente para resoluciones bajas. 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. timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente. 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`. denoising_end (`float`, *opcional*) : Cuando se especifica, determina la fracción (entre 0.0 y 1.0) del proceso total de desruido que debe completarse antes de que se termine prematuramente de forma intencional. Como resultado, la muestra devuelta aún conservará una cantidad sustancial de ruido, tal como lo determinan los pasos discretos seleccionados por el programador. El parámetro denoising_end debería utilizarse idealmente cuando esta pipeline forma parte de una configuración multipipeline de "Mixture of Denoisers", como se detalla en [**Refining the Image Output**](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/stable_diffusion_xl#refining-the-image-output) 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. 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`). num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) en el artículo de DDIM: https://huggingface.co/papers/2010.02502. Solo se aplica a [schedulers.DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), se ignorará en los demás. 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.Tensor`, *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. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *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`. pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, los embeddings de texto agrupados se generarán a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *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`. negative_pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de 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 (`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)`. 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`) : Si se devuelve un `~pipelines.kolors.KolorsPipelineOutput` en lugar de una tupla simple. cross_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). original_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Si `original_size` no es igual a `target_size`, la imagen parecerá haber sido reescalada hacia abajo o hacia arriba. `original_size` tiene como valor predeterminado `(height, width)` si no se especifica. Parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). crops_coords_top_left (`tuple[int]`, *opcional*, valor predeterminado (0, 0)) : `crops_coords_top_left` se puede utilizar para generar una imagen que parezca "recortada" desde la posición `crops_coords_top_left` hacia abajo. Generalmente, se logran imágenes favorables y bien centradas estableciendo `crops_coords_top_left` en (0, 0). Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). target_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : En la mayoría de los casos, `target_size` debe establecerse en la altura y el ancho deseados de la imagen generada. Si no se especifica, el valor predeterminado será `(height, width)`. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). negative_original_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de una resolución de imagen específica. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. negative_crops_coords_top_left (`tuple[int]`, *opcional*, valor predeterminado (0, 0)) : Para condicionar negativamente el proceso de generación en función de unas coordenadas de recorte específicas. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. negative_target_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de la resolución de imagen objetivo. Debe ser igual que `target_size` en la mayoría de los casos. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, 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. pag_scale (`float`, *opcional*, valor predeterminado 3.0) : El factor de escala para la guía de atención perturbada. Si se establece en 0.0, no se utilizará la guía de atención perturbada. pag_adaptive_scale (`float`, *opcional*, valor predeterminado 0.0) : El factor de escala adaptativo para la guía de atención perturbada. Si se establece en 0.0, se utiliza `pag_scale`. max_sequence_length (`int` por defecto 256) : Longitud máxima de la secuencia a utilizar con el `prompt`. **Devuelve:** `~pipelines.kolors.KolorsPipelineOutput` o `tuple` `~pipelines.kolors.KolorsPipelineOutput` 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 AutoPipelineForText2Image >>> pipe = AutoPipelineForText2Image.from_pretrained( ... "Kwai-Kolors/Kolors-diffusers", ... variant="fp16", ... torch_dtype=torch.float16, ... enable_pag=True, ... pag_applied_layers=["down.block_2.attentions_1", "up.block_0.attentions_1"], ... ) >>> pipe = pipe.to("cuda") >>> prompt = ( ... "A photo of a ladybug, macro, zoom, high quality, film, holding a wooden sign with the text 'KOLORS'" ... ) >>> image = pipe(prompt, guidance_scale=5.5, pag_scale=1.5).images[0] ``` #### encode_prompt[[diffusers.KolorsPAGPipeline.encode_prompt]] ```python encode_prompt(prompt, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 256) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_kolors.py#L216) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar 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`). 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`. pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, los embeddings de texto agrupados 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`. negative_pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, los pooled negative_prompt_embeds se generarán a partir del argumento de entrada `negative_prompt`. max_sequence_length (`int` por defecto 256) : Longitud máxima de la secuencia a utilizar con el `prompt`. Codifica el prompt en estados ocultos del codificador de texto. #### get_guidance_scale_embedding[[diffusers.KolorsPAGPipeline.get_guidance_scale_embedding]] ```python get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_kolors.py#L608) **Parámetros:** w (`torch.Tensor`) : Genera vectores de incrustación con una escala de guía especificada para enriquecer posteriormente las incrustaciones de paso temporal. embedding_dim (`int`, *opcional*, valor predeterminado 512) : Dimensión de las incrustaciones a generar. dtype (`torch.dtype`, *opcional*, valor predeterminado `torch.float32`) : Tipo de datos de los embeddings generados. **Devuelve:** `torch.Tensor` Vectores de incrustación con forma `(len(w), embedding_dim)`. Ver https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298 ## StableDiffusionPAGInpaintPipeline[[diffusers.StableDiffusionPAGInpaintPipeline]] #### diffusers.StableDiffusionPAGInpaintPipeline[[diffusers.StableDiffusionPAGInpaintPipeline]] ```python diffusers.StableDiffusionPAGInpaintPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: CLIPVisionModelWithProjection = None, requires_safety_checker: bool = True, pag_applied_layers: str | list[str] = 'mid') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_inpaint.py#L184) **Parámetros:** vae ([AutoencoderKL](/docs/diffusers/main/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 ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` para tokenizar texto. unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Un `UNet2DConditionModel` para desruidar los latentes de imagen codificados. scheduler ([SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Puede ser uno de [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/es/api/schedulers/pndm#diffusers.PNDMScheduler). safety_checker (`StableDiffusionSafetyChecker`) : Módulo de clasificación que estima si las imágenes generadas podrían considerarse ofensivas o dañinas. Consulte la [ficha del modelo](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) para obtener más detalles sobre los posibles daños de un modelo. feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : Un `CLIPImageProcessor` para extraer características de las imágenes generadas; se utiliza como entrada para el `safety_checker`. Pipeline para la generación de imágenes a partir de texto usando Stable Diffusion. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.). El pipeline también hereda los siguientes métodos de carga: - [load_textual_inversion()](/docs/diffusers/main/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual - [load_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA - [save_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA - [from_single_file()](/docs/diffusers/main/es/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) para la carga de archivos `.ckpt` - [load_ip_adapter()](/docs/diffusers/main/es/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para cargar IP Adapters #### __call__[[diffusers.StableDiffusionPAGInpaintPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, masked_image_latents: Tensor = None, height: int | None = None, width: int | None = None, padding_mask_crop: int | None = None, strength: float = 0.9999, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, guidance_scale: float = 7.5, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, guidance_rescale: float = 0.0, 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'], pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_inpaint.py#L910) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de imágenes. Si no se define, debe pasar `prompt_embeds`. image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` o `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 `mask_image` y repintar según `prompt`). mask_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` o `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)`, `(B, H, W)`, `(1, H, W)` o `(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`, *opcional*) : Latente precodificado de la imagen enmascarada (para inpainting). height (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : La altura en píxeles de la imagen generada. width (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : El ancho en píxeles de la imagen generada. padding_mask_crop (`int`, *opcional*, valor predeterminado `None`) : El tamaño del margen en el recorte que se aplicará a la imagen y la máscara. Si es `None`, no se aplica ningún recorte a la imagen y a mask_image. Si `padding_mask_crop` no es `None`, primero se buscará una región rectangular con la misma relación de aspecto que la imagen y que contenga toda el área enmascarada, y luego se expandirá esa área en función de `padding_mask_crop`. A continuación, la imagen y mask_image se recortarán 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 0.9999) : Indica el grado en que se transforma la `image` de referencia. Debe estar entre 0 y 1. `image` se utiliza como punto de partida y se añade más ruido a medida que aumenta el `strength`. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuando `strength` es 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado en `num_inference_steps`. Un valor de 1 ignora esencialmente `image`. 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. timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente. 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 7.5) : Un valor más alto de la escala de guía anima al modelo a generar imágenes estrechamente vinculadas al `prompt` de texto a costa de una menor calidad de imagen. La escala de guía se habilita cuando `guidance_scale > 1`. negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar lo que no debe incluirse en la generación de la imagen. Si no se define, debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale < 1`). num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) del artículo [DDIM](https://huggingface.co/papers/2010.02502). Solo se aplica al [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler) y se ignora en otros programadores. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista. latents (`torch.Tensor`, *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. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan 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 (`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)`. 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.Image` o `np.array`. return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) en lugar de una tupla simple. cross_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define en [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). guidance_rescale (`float`, *opcional*, valor predeterminado 0.0) : Factor de reescalado de guía de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). El factor de reescalado de guía debe corregir la sobreexposición al usar SNR terminal cero. 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`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, 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. pag_scale (`float`, *opcional*, valor predeterminado 3.0) : El factor de escala para la guía de atención perturbada. Si se establece en 0.0, no se utilizará la guía de atención perturbada. pag_adaptive_scale (`float`, *opcional*, valor predeterminado 0.0) : El factor de escala adaptativo para la guía de atención perturbada. Si se establece en 0.0, se utiliza `pag_scale`. **Devuelve:** [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) o `tuple` Si `return_dict` es `True`, se devuelve [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw). La función de llamada para el pipeline de generación. Ejemplos: ```py >>> import torch >>> from diffusers import AutoPipelineForInpainting >>> pipe = AutoPipelineForInpainting.from_pretrained( ... "stable-diffusion-v1-5/stable-diffusion-v1-5", torch_dtype=torch.float16, enable_pag=True ... ) >>> pipe = pipe.to("cuda") >>> 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" >>> init_image = load_image(img_url).convert("RGB") >>> mask_image = load_image(mask_url).convert("RGB") >>> prompt = "A majestic tiger sitting on a bench" >>> image = pipe( ... prompt=prompt, ... image=init_image, ... mask_image=mask_image, ... strength=0.8, ... num_inference_steps=50, ... guidance_scale=guidance_scale, ... generator=generator, ... pag_scale=pag_scale, ... ).images[0] ``` #### encode_prompt[[diffusers.StableDiffusionPAGInpaintPipeline.encode_prompt]] ```python encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_inpaint.py#L334) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar 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`). prompt_embeds (`torch.Tensor`, *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.Tensor`, *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`. lora_scale (`float`, *opcional*) : Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA. 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. Codifica el prompt en estados ocultos del codificador de texto. #### get_guidance_scale_embedding[[diffusers.StableDiffusionPAGInpaintPipeline.get_guidance_scale_embedding]] ```python get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_inpaint.py#L849) **Parámetros:** w (`torch.Tensor`) : Genera vectores de incrustación con una escala de guía especificada para enriquecer posteriormente las incrustaciones de paso temporal. embedding_dim (`int`, *opcional*, valor predeterminado 512) : Dimensión de las incrustaciones a generar. dtype (`torch.dtype`, *opcional*, valor predeterminado `torch.float32`) : Tipo de datos de los embeddings generados. **Devuelve:** `torch.Tensor` Vectores de incrustación con forma `(len(w), embedding_dim)`. Ver https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298 ## StableDiffusionPAGPipeline[[diffusers.StableDiffusionPAGPipeline]] #### diffusers.StableDiffusionPAGPipeline[[diffusers.StableDiffusionPAGPipeline]] ```python diffusers.StableDiffusionPAGPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: CLIPVisionModelWithProjection = None, requires_safety_checker: bool = True, pag_applied_layers: str | list[str] = 'mid') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd.py#L157) **Parámetros:** vae ([AutoencoderKL](/docs/diffusers/main/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 ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` para tokenizar texto. unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Un `UNet2DConditionModel` para desruidar los latentes de imagen codificados. scheduler ([SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Puede ser uno de [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/es/api/schedulers/pndm#diffusers.PNDMScheduler). safety_checker (`StableDiffusionSafetyChecker`) : Módulo de clasificación que estima si las imágenes generadas podrían considerarse ofensivas o dañinas. Consulte la [ficha del modelo](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) para obtener más detalles sobre los posibles daños de un modelo. feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : Un `CLIPImageProcessor` para extraer características de las imágenes generadas; se utiliza como entrada para el `safety_checker`. Pipeline para la generación de imágenes a partir de texto usando Stable Diffusion. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.). El pipeline también hereda los siguientes métodos de carga: - [load_textual_inversion()](/docs/diffusers/main/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual - [load_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA - [save_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA - [from_single_file()](/docs/diffusers/main/es/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) para la carga de archivos `.ckpt` - [load_ip_adapter()](/docs/diffusers/main/es/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para cargar IP Adapters #### __call__[[diffusers.StableDiffusionPAGPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, guidance_scale: float = 7.5, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, guidance_rescale: float = 0.0, 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'], pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd.py#L745) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de imágenes. Si no se define, debe pasar `prompt_embeds`. height (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : La altura en píxeles de la imagen generada. width (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : El ancho en píxeles de la imagen generada. 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. timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente. 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 7.5) : Un valor más alto de la escala de guía anima al modelo a generar imágenes estrechamente vinculadas al `prompt` de texto a costa de una menor calidad de imagen. La escala de guía se habilita cuando `guidance_scale > 1`. negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar lo que no debe incluirse en la generación de la imagen. Si no se define, debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale < 1`). num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) del artículo [DDIM](https://huggingface.co/papers/2010.02502). Solo se aplica al [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler) y se ignora en otros programadores. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista. latents (`torch.Tensor`, *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. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan 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 (`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)`. 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.Image` o `np.array`. return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) en lugar de una tupla simple. cross_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define en [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). guidance_rescale (`float`, *opcional*, valor predeterminado 0.0) : Factor de reescalado de guía de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). El factor de reescalado de guía debe corregir la sobreexposición al usar SNR terminal cero. 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`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, 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. pag_scale (`float`, *opcional*, valor predeterminado 3.0) : El factor de escala para la guía de atención perturbada. Si se establece en 0.0, no se utilizará la guía de atención perturbada. pag_adaptive_scale (`float`, *opcional*, valor predeterminado 0.0) : El factor de escala adaptativo para la guía de atención perturbada. Si se establece en 0.0, se utiliza `pag_scale`. **Devuelve:** [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) o `tuple` Si `return_dict` es `True`, se devuelve [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw). La función de llamada para el pipeline de generación. Ejemplos: ```py >>> import torch >>> from diffusers import AutoPipelineForText2Image >>> pipe = AutoPipelineForText2Image.from_pretrained( ... "stable-diffusion-v1-5/stable-diffusion-v1-5", torch_dtype=torch.float16, enable_pag=True ... ) >>> pipe = pipe.to("cuda") >>> prompt = "a photo of an astronaut riding a horse on mars" >>> image = pipe(prompt, pag_scale=0.3).images[0] ``` #### encode_prompt[[diffusers.StableDiffusionPAGPipeline.encode_prompt]] ```python encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd.py#L304) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar 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`). prompt_embeds (`torch.Tensor`, *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.Tensor`, *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`. lora_scale (`float`, *opcional*) : Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA. 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. Codifica el prompt en estados ocultos del codificador de texto. #### get_guidance_scale_embedding[[diffusers.StableDiffusionPAGPipeline.get_guidance_scale_embedding]] ```python get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd.py#L684) **Parámetros:** w (`torch.Tensor`) : Genera vectores de incrustación con una escala de guía especificada para enriquecer posteriormente las incrustaciones de paso temporal. embedding_dim (`int`, *opcional*, valor predeterminado 512) : Dimensión de las incrustaciones a generar. dtype (`torch.dtype`, *opcional*, valor predeterminado `torch.float32`) : Tipo de datos de los embeddings generados. **Devuelve:** `torch.Tensor` Vectores de incrustación con forma `(len(w), embedding_dim)`. Ver https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298 ## StableDiffusionPAGImg2ImgPipeline[[diffusers.StableDiffusionPAGImg2ImgPipeline]] #### diffusers.StableDiffusionPAGImg2ImgPipeline[[diffusers.StableDiffusionPAGImg2ImgPipeline]] ```python diffusers.StableDiffusionPAGImg2ImgPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: CLIPVisionModelWithProjection = None, requires_safety_checker: bool = True, pag_applied_layers: str | list[str] = 'mid') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_img2img.py#L152) **Parámetros:** vae ([AutoencoderKL](/docs/diffusers/main/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 ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` para tokenizar texto. unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Un `UNet2DConditionModel` para desruidar los latentes de imagen codificados. scheduler ([SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Puede ser uno de [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/es/api/schedulers/pndm#diffusers.PNDMScheduler). safety_checker (`StableDiffusionSafetyChecker`) : Módulo de clasificación que estima si las imágenes generadas podrían considerarse ofensivas o dañinas. Consulte la [ficha del modelo](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) para obtener más detalles sobre los posibles daños de un modelo. feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : Un `CLIPImageProcessor` para extraer características de las imágenes generadas; se utiliza como entrada para el `safety_checker`. Pipeline para la generación de imagen a imagen guiada por texto usando Stable Diffusion. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.). El pipeline también hereda los siguientes métodos de carga: - [load_textual_inversion()](/docs/diffusers/main/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual - [load_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA - [save_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA - [from_single_file()](/docs/diffusers/main/es/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) para la carga de archivos `.ckpt` - [load_ip_adapter()](/docs/diffusers/main/es/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para cargar IP Adapters #### __call__[[diffusers.StableDiffusionPAGImg2ImgPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, strength: float = 0.8, num_inference_steps: int | None = 50, timesteps: list[int] = None, sigmas: list[float] = None, guidance_scale: float | None = 7.5, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float | None = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, clip_skip: int = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_img2img.py#L782) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de imágenes. Si no se define, debe pasar `prompt_embeds`. image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` o `list[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 como `image`, pero si se pasan latentes directamente, no se vuelven a codificar. strength (`float`, *opcional*, valor predeterminado 0.8) : Indica el grado en que se transforma la `image` de referencia. Debe estar entre 0 y 1. `image` se utiliza como punto de partida y se añade más ruido a medida que aumenta el `strength`. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuando `strength` es 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado en `num_inference_steps`. Un valor de 1 ignora esencialmente `image`. 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. Este parámetro se modula por `strength`. timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente. 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 7.5) : Un valor más alto de la escala de guía anima al modelo a generar imágenes estrechamente vinculadas al `prompt` de texto a costa de una menor calidad de imagen. La escala de guía se habilita cuando `guidance_scale > 1`. negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar lo que no debe incluirse en la generación de la imagen. Si no se define, debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale < 1`). num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) del artículo [DDIM](https://huggingface.co/papers/2010.02502). Solo se aplica al [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler) y se ignora en otros programadores. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista. prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan 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 (`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)`. 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.Image` o `np.array`. return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) en lugar de una tupla simple. cross_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define en [`self.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`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, 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. pag_scale (`float`, *opcional*, valor predeterminado 3.0) : El factor de escala para la guía de atención perturbada. Si se establece en 0.0, no se utilizará la guía de atención perturbada. pag_adaptive_scale (`float`, *opcional*, valor predeterminado 0.0) : El factor de escala adaptativo para la guía de atención perturbada. Si se establece en 0.0, se utiliza `pag_scale`. **Devuelve:** [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) o `tuple` Si `return_dict` es `True`, se devuelve [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw). La función de llamada para el pipeline de generación. Ejemplos: ```py >>> import torch >>> from diffusers import AutoPipelineForImage2Image >>> from diffusers.utils import load_image >>> pipe = AutoPipelineForImage2Image.from_pretrained( ... "stable-diffusion-v1-5/stable-diffusion-v1-5", ... torch_dtype=torch.float16, ... enable_pag=True, ... ) >>> pipe = pipe.to("cuda") >>> url = "https://huggingface.co/datasets/patrickvonplaten/images/resolve/main/aa_xl/000000009.png" >>> init_image = load_image(url).convert("RGB") >>> prompt = "a photo of an astronaut riding a horse on mars" >>> image = pipe(prompt, image=init_image, pag_scale=0.3).images[0] ``` #### encode_prompt[[diffusers.StableDiffusionPAGImg2ImgPipeline.encode_prompt]] ```python encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_img2img.py#L299) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar 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`). prompt_embeds (`torch.Tensor`, *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.Tensor`, *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`. lora_scale (`float`, *opcional*) : Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA. 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. Codifica el prompt en estados ocultos del codificador de texto. #### get_guidance_scale_embedding[[diffusers.StableDiffusionPAGImg2ImgPipeline.get_guidance_scale_embedding]] ```python get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_img2img.py#L725) **Parámetros:** w (`torch.Tensor`) : Genera vectores de incrustación con una escala de guía especificada para enriquecer posteriormente las incrustaciones de paso temporal. embedding_dim (`int`, *opcional*, valor predeterminado 512) : Dimensión de las incrustaciones a generar. dtype (`torch.dtype`, *opcional*, valor predeterminado `torch.float32`) : Tipo de datos de los embeddings generados. **Devuelve:** `torch.Tensor` Vectores de incrustación con forma `(len(w), embedding_dim)`. Ver https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298 ## StableDiffusionControlNetPAGPipeline[[diffusers.StableDiffusionControlNetPAGPipeline]] #### diffusers.StableDiffusionControlNetPAGPipeline[[diffusers.StableDiffusionControlNetPAGPipeline]] ```python diffusers.StableDiffusionControlNetPAGPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, controlnet: diffusers.models.controlnets.controlnet.ControlNetModel | list[diffusers.models.controlnets.controlnet.ControlNetModel] | tuple[diffusers.models.controlnets.controlnet.ControlNetModel] | diffusers.models.controlnets.multicontrolnet.MultiControlNetModel, scheduler: KarrasDiffusionSchedulers, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: CLIPVisionModelWithProjection = None, requires_safety_checker: bool = True, pag_applied_layers: str | list[str] = 'mid') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_controlnet_sd.py#L168) **Parámetros:** vae ([AutoencoderKL](/docs/diffusers/main/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 ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` para tokenizar texto. unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Un `UNet2DConditionModel` para desruidar los latentes de imagen codificados. controlnet ([ControlNetModel](/docs/diffusers/main/es/api/models/controlnet#diffusers.ControlNetModel) o `list[ControlNetModel]`) : Proporciona una condición adicional al `unet` durante el proceso de desruido. Si configuras varios ControlNet como una lista, las salidas de cada ControlNet se suman para crear una condición adicional combinada. scheduler ([SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Puede ser uno de [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/es/api/schedulers/pndm#diffusers.PNDMScheduler). safety_checker (`StableDiffusionSafetyChecker`) : Módulo de clasificación que estima si las imágenes generadas podrían considerarse ofensivas o dañinas. Consulte la [ficha del modelo](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) para obtener más detalles sobre los posibles daños de un modelo. feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : Un `CLIPImageProcessor` para extraer características de las imágenes generadas; se utiliza como entrada para el `safety_checker`. Pipeline para la generación de imágenes a partir de texto usando Stable Diffusion con la guía de ControlNet. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.). El pipeline también hereda los siguientes métodos de carga: - [load_textual_inversion()](/docs/diffusers/main/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual - [load_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA - [save_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA - [from_single_file()](/docs/diffusers/main/es/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) para la carga de archivos `.ckpt` - [load_ip_adapter()](/docs/diffusers/main/es/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para cargar IP Adapters #### encode_prompt[[diffusers.StableDiffusionControlNetPAGPipeline.encode_prompt]] ```python encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_controlnet_sd.py#L275) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar 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`). prompt_embeds (`torch.Tensor`, *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.Tensor`, *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`. lora_scale (`float`, *opcional*) : Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA. 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. Codifica el prompt en estados ocultos del codificador de texto. #### get_guidance_scale_embedding[[diffusers.StableDiffusionControlNetPAGPipeline.get_guidance_scale_embedding]] ```python get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_controlnet_sd.py#L810) **Parámetros:** w (`torch.Tensor`) : Genera vectores de incrustación con una escala de guía especificada para enriquecer posteriormente las incrustaciones de paso temporal. embedding_dim (`int`, *opcional*, valor predeterminado 512) : Dimensión de las incrustaciones a generar. dtype (`torch.dtype`, *opcional*, valor predeterminado `torch.float32`) : Tipo de datos de los embeddings generados. **Devuelve:** `torch.Tensor` Vectores de incrustación con forma `(len(w), embedding_dim)`. Ver https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298 ## StableDiffusionControlNetPAGInpaintPipeline[[diffusers.StableDiffusionControlNetPAGInpaintPipeline]] #### diffusers.StableDiffusionControlNetPAGInpaintPipeline[[diffusers.StableDiffusionControlNetPAGInpaintPipeline]] ```python diffusers.StableDiffusionControlNetPAGInpaintPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, controlnet: diffusers.models.controlnets.controlnet.ControlNetModel | list[diffusers.models.controlnets.controlnet.ControlNetModel] | tuple[diffusers.models.controlnets.controlnet.ControlNetModel] | diffusers.models.controlnets.multicontrolnet.MultiControlNetModel, scheduler: KarrasDiffusionSchedulers, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: CLIPVisionModelWithProjection = None, requires_safety_checker: bool = True, pag_applied_layers: str | list[str] = 'mid') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_controlnet_sd_inpaint.py#L134) **Parámetros:** vae ([AutoencoderKL](/docs/diffusers/main/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 ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` para tokenizar texto. unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Un `UNet2DConditionModel` para desruidar los latentes de imagen codificados. controlnet ([ControlNetModel](/docs/diffusers/main/es/api/models/controlnet#diffusers.ControlNetModel) o `list[ControlNetModel]`) : Proporciona una condición adicional al `unet` durante el proceso de desruido. Si configuras varios ControlNet como una lista, las salidas de cada ControlNet se suman para crear una condición adicional combinada. scheduler ([SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Puede ser uno de [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/es/api/schedulers/pndm#diffusers.PNDMScheduler). safety_checker (`StableDiffusionSafetyChecker`) : Módulo de clasificación que estima si las imágenes generadas podrían considerarse ofensivas o dañinas. Consulte la [ficha del modelo](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) para obtener más detalles sobre los posibles daños de un modelo. feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : Un `CLIPImageProcessor` para extraer características de las imágenes generadas; se utiliza como entrada para el `safety_checker`. Pipeline para el inpainting de imágenes usando Stable Diffusion con la guía de ControlNet. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.). El pipeline también hereda los siguientes métodos de carga: - [load_textual_inversion()](/docs/diffusers/main/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual - [load_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA - [save_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA - [from_single_file()](/docs/diffusers/main/es/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) para la carga de archivos `.ckpt` - [load_ip_adapter()](/docs/diffusers/main/es/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para cargar IP Adapters > [!TIP] > Este pipeline se puede utilizar con puntos de control que hayan sido específicamente afinados para inpainting > ([stable-diffusion-v1-5/stable-diffusion-inpainting](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-inpainting)) así como los puntos de control predeterminados de texto a imagen de Stable Diffusion ([stable-diffusion-v1-5/stable-diffusion-v1-5](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5)). Los puntos de control predeterminados de texto a imagen de Stable Diffusion podrían ser preferibles para ControlNets que hayan sido ajustados finamente sobre ellos, como [lllyasviel/control_v11p_sd15_inpaint](https://huggingface.co/lllyasviel/control_v11p_sd15_inpaint). #### __call__[[diffusers.StableDiffusionControlNetPAGInpaintPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, padding_mask_crop: int | None = None, strength: float = 1.0, num_inference_steps: int = 50, guidance_scale: float = 7.5, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, controlnet_conditioning_scale: float | list[float] = 0.5, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, clip_skip: int | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_controlnet_sd_inpaint.py#L972) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de imágenes. Si no se define, debe pasar `prompt_embeds`. image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, : `list[PIL.Image.Image]`, o `list[np.ndarray]`): `Image`, array de NumPy o tensor que representa un lote de imágenes para usarse como punto de partida. Tanto para el array de NumPy como para el tensor 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 como `image`, 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]`, o `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)`, `(B, H, W)`, `(1, H, W)`, `(H, W)`. Y para un array de NumPy, sería para `(B, H, W, 1)`, `(B, H, W)`, `(H, W, 1)`, o `(H, W)`. control_image (`torch.Tensor`, `PIL.Image.Image`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, : `list[list[torch.Tensor]]`, 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. height (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : La altura en píxeles de la imagen generada. width (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : El ancho en píxeles de la imagen generada. padding_mask_crop (`int`, *opcional*, valor predeterminado `None`) : El tamaño del margen en el recorte que se aplicará a la imagen y la máscara. Si es `None`, no se aplica ningún recorte a la imagen y a mask_image. Si `padding_mask_crop` no es `None`, primero se buscará una región rectangular con la misma relación de aspecto que la imagen y que contenga toda el área enmascarada, y luego se expandirá esa área en función de `padding_mask_crop`. A continuación, la imagen y mask_image se recortarán 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 la `image` de referencia. Debe estar entre 0 y 1. `image` se utiliza como punto de partida y se añade más ruido a medida que aumenta el `strength`. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuando `strength` es 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado en `num_inference_steps`. Un valor de 1 ignora esencialmente `image`. 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. guidance_scale (`float`, *opcional*, valor predeterminado 7.5) : Un valor más alto de la escala de guía anima al modelo a generar imágenes estrechamente vinculadas al `prompt` de texto a costa de una menor calidad de imagen. La escala de guía se habilita cuando `guidance_scale > 1`. negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar lo que no debe incluirse en la generación de la imagen. Si no se define, debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale < 1`). num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) del artículo [DDIM](https://huggingface.co/papers/2010.02502). Solo se aplica al [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler) y se ignora en otros programadores. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista. latents (`torch.Tensor`, *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. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan 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 (`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)`. 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.Image` o `np.array`. return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) en lugar de una tupla simple. cross_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define en [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). controlnet_conditioning_scale (`float` o `list[float]`, *opcional*, valor predeterminado 0.5) : 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. 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. 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`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, 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. pag_scale (`float`, *opcional*, valor predeterminado 3.0) : El factor de escala para la guía de atención perturbada. Si se establece en 0.0, no se utilizará la guía de atención perturbada. pag_adaptive_scale (`float`, *opcional*, valor predeterminado 0.0) : El factor de escala adaptativo para la guía de atención perturbada. Si se establece en 0.0, se utiliza `pag_scale`. **Devuelve:** [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) o `tuple` Si `return_dict` es `True`, se devuelve [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw). La función de llamada para el pipeline de generación. Ejemplos: ```py >>> # !pip install transformers accelerate >>> import cv2 >>> from diffusers import AutoPipelineForInpainting, ControlNetModel, DDIMScheduler >>> from diffusers.utils import load_image >>> import numpy as np >>> from PIL import Image >>> import torch >>> init_image = load_image( ... "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png" ... ) >>> init_image = init_image.resize((512, 512)) >>> generator = torch.Generator(device="cpu").manual_seed(1) >>> mask_image = load_image( ... "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png" ... ) >>> mask_image = mask_image.resize((512, 512)) >>> def make_canny_condition(image): ... image = np.array(image) ... image = cv2.Canny(image, 100, 200) ... image = image[:, :, None] ... image = np.concatenate([image, image, image], axis=2) ... image = Image.fromarray(image) ... return image >>> control_image = make_canny_condition(init_image) >>> controlnet = ControlNetModel.from_pretrained( ... "lllyasviel/control_v11p_sd15_inpaint", torch_dtype=torch.float16 ... ) >>> pipe = AutoPipelineForInpainting.from_pretrained( ... "stable-diffusion-v1-5/stable-diffusion-v1-5", ... controlnet=controlnet, ... torch_dtype=torch.float16, ... enable_pag=True, ... ) >>> pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config) >>> pipe.enable_model_cpu_offload() >>> # generate image >>> image = pipe( ... "a handsome man with ray-ban sunglasses", ... num_inference_steps=20, ... generator=generator, ... eta=1.0, ... image=init_image, ... mask_image=mask_image, ... control_image=control_image, ... pag_scale=0.3, ... ).images[0] ``` #### encode_prompt[[diffusers.StableDiffusionControlNetPAGInpaintPipeline.encode_prompt]] ```python encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_controlnet_sd_inpaint.py#L251) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar 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`). prompt_embeds (`torch.Tensor`, *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.Tensor`, *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`. lora_scale (`float`, *opcional*) : Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA. 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. Codifica el prompt en estados ocultos del codificador de texto. #### get_guidance_scale_embedding[[diffusers.StableDiffusionControlNetPAGInpaintPipeline.get_guidance_scale_embedding]] ```python get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_controlnet_sd_inpaint.py#L919) **Parámetros:** w (`torch.Tensor`) : Genera vectores de incrustación con una escala de guía especificada para enriquecer posteriormente las incrustaciones de paso temporal. embedding_dim (`int`, *opcional*, valor predeterminado 512) : Dimensión de las incrustaciones a generar. dtype (`torch.dtype`, *opcional*, valor predeterminado `torch.float32`) : Tipo de datos de los embeddings generados. **Devuelve:** `torch.Tensor` Vectores de incrustación con forma `(len(w), embedding_dim)`. Ver https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298 ## StableDiffusionXLPAGPipeline[[diffusers.StableDiffusionXLPAGPipeline]] #### diffusers.StableDiffusionXLPAGPipeline[[diffusers.StableDiffusionXLPAGPipeline]] ```python diffusers.StableDiffusionXLPAGPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, text_encoder_2: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, tokenizer_2: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None, force_zeros_for_empty_prompt: bool = True, add_watermarker: bool | None = None, pag_applied_layers: str | list[str] = 'mid') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_xl.py#L172) **Parámetros:** vae ([AutoencoderKL](/docs/diffusers/main/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 (`CLIPTextModel`) : Codificador de texto congelado. Stable Diffusion XL utiliza la parte de texto de [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), específicamente la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14). text_encoder_2 (` CLIPTextModelWithProjection`) : Segundo codificador de texto congelado. Stable Diffusion XL utiliza la parte de texto y pool de [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). 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). unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitectura de U-Net condicional para desruidar los latentes de imagen codificados. scheduler ([SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Puede ser uno de [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/es/api/schedulers/pndm#diffusers.PNDMScheduler). force_zeros_for_empty_prompt (`bool`, *opcional*, valor predeterminado `"True"`) : Si las incrustaciones del prompt negativo deben forzarse a establecerse siempre en 0. Consulte también la configuración de `stabilityai/stable-diffusion-xl-base-1-0`. add_watermarker (`bool`, *opcional*) : Si se debe usar la [invisible_watermark library](https://github.com/ShieldMnt/invisible-watermark/) para aplicar marcas de agua a las imágenes de salida. Si no se define, el valor predeterminado será True si el paquete está instalado; de lo contrario, no se usará ninguna marca de agua. Pipeline para la generación de imágenes a partir de texto usando Stable Diffusion XL. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la ejecución en un dispositivo específico, etc.) El pipeline también hereda los siguientes métodos de carga: - [load_textual_inversion()](/docs/diffusers/main/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual - [from_single_file()](/docs/diffusers/main/es/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) para la carga de archivos `.ckpt` - [load_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA - [save_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA - [load_ip_adapter()](/docs/diffusers/main/es/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para cargar IP Adapters #### __call__[[diffusers.StableDiffusionXLPAGPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, denoising_end: float | None = None, guidance_scale: float = 5.0, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, guidance_rescale: float = 0.0, original_size: tuple[int, int] | None = None, crops_coords_top_left: tuple[int, int] = (0, 0), target_size: tuple[int, int] | None = None, negative_original_size: tuple[int, int] | None = None, negative_crops_coords_top_left: tuple[int, int] = (0, 0), negative_target_size: tuple[int, int] | 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'], pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_xl.py#L836) **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 al `tokenizer_2` y al `text_encoder_2`. Si no se define, se utiliza `prompt` en ambos text-encoders 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. Cualquier valor inferior a 512 píxeles no funcionará bien con [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) ni con puntos de control que no estén específicamente afinados en resoluciones bajas. 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. Cualquier valor inferior a 512 píxeles no funcionará bien con [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) ni con puntos de control que no estén específicamente afinados en resoluciones bajas. 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. timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente. 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`. denoising_end (`float`, *opcional*) : Cuando se especifica, determina la fracción (entre 0.0 y 1.0) del proceso total de desruido que debe completarse antes de que se termine prematuramente de forma intencional. Como resultado, la muestra devuelta aún conservará una cantidad sustancial de ruido, tal como lo determinan los pasos discretos seleccionados por el programador. El parámetro denoising_end debería utilizarse idealmente cuando esta pipeline forma parte de una configuración multipipeline de "Mixture of Denoisers", como se detalla en [**Refining the Image Output**](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/stable_diffusion_xl#refining-the-image-output) 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. 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 ambos text-encoders num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) en el artículo de DDIM: https://huggingface.co/papers/2010.02502. Solo se aplica a [schedulers.DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), se ignorará en los demás. 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.Tensor`, *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. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *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.Tensor`, *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.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado 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.Tensor`, *opcional*) : Embeddings de texto negativo agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de 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 (`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)`. 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. cross_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). guidance_rescale (`float`, *opcional*, valor predeterminado 0.0) : Factor de reescalado de guía propuesto por [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) `guidance_scale` se define como `φ` en la ecuación 16. de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). El factor de reescalado de guía debe corregir la sobreexposición al usar SNR terminal cero. original_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Si `original_size` no es igual a `target_size`, la imagen parecerá haber sido reescalada hacia abajo o hacia arriba. `original_size` tiene como valor predeterminado `(height, width)` si no se especifica. Parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). crops_coords_top_left (`tuple[int]`, *opcional*, valor predeterminado (0, 0)) : `crops_coords_top_left` se puede utilizar para generar una imagen que parezca "recortada" desde la posición `crops_coords_top_left` hacia abajo. Generalmente, se logran imágenes favorables y bien centradas estableciendo `crops_coords_top_left` en (0, 0). Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). target_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : En la mayoría de los casos, `target_size` debe establecerse en la altura y el ancho deseados de la imagen generada. Si no se especifica, el valor predeterminado será `(height, width)`. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). negative_original_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de una resolución de imagen específica. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. negative_crops_coords_top_left (`tuple[int]`, *opcional*, valor predeterminado (0, 0)) : Para condicionar negativamente el proceso de generación en función de unas coordenadas de recorte específicas. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. negative_target_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de la resolución de imagen objetivo. Debe ser igual que `target_size` en la mayoría de los casos. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. 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. pag_scale (`float`, *opcional*, valor predeterminado 3.0) : El factor de escala para la guía de atención perturbada. Si se establece en 0.0, no se utilizará la guía de atención perturbada. pag_adaptive_scale (`float`, *opcional*, valor predeterminado 0.0) : El factor de escala adaptativo para la guía de atención perturbada. Si se establece en 0.0, se utiliza `pag_scale`. **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 AutoPipelineForText2Image >>> pipe = AutoPipelineForText2Image.from_pretrained( ... "stabilityai/stable-diffusion-xl-base-1.0", ... torch_dtype=torch.float16, ... enable_pag=True, ... ) >>> pipe = pipe.to("cuda") >>> prompt = "a photo of an astronaut riding a horse on mars" >>> image = pipe(prompt, pag_scale=0.3).images[0] ``` #### encode_prompt[[diffusers.StableDiffusionXLPAGPipeline.encode_prompt]] ```python encode_prompt(prompt: str, prompt_2: str | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | None = None, negative_prompt_2: str | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_xl.py#L293) **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 ambos 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 ambos text-encoders prompt_embeds (`torch.Tensor`, *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.Tensor`, *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.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado 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.Tensor`, *opcional*) : Embeddings de texto negativo agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, los pooled negative_prompt_embeds se generarán a partir del argumento de entrada `negative_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. 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. Codifica el prompt en estados ocultos del codificador de texto. #### get_guidance_scale_embedding[[diffusers.StableDiffusionXLPAGPipeline.get_guidance_scale_embedding]] ```python get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_xl.py#L771) **Parámetros:** w (`torch.Tensor`) : Genera vectores de incrustación con una escala de guía especificada para enriquecer posteriormente las incrustaciones de paso temporal. embedding_dim (`int`, *opcional*, valor predeterminado 512) : Dimensión de las incrustaciones a generar. dtype (`torch.dtype`, *opcional*, valor predeterminado `torch.float32`) : Tipo de datos de los embeddings generados. **Devuelve:** `torch.Tensor` Vectores de incrustación con forma `(len(w), embedding_dim)`. Ver https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298 ## StableDiffusionXLPAGImg2ImgPipeline[[diffusers.StableDiffusionXLPAGImg2ImgPipeline]] #### diffusers.StableDiffusionXLPAGImg2ImgPipeline[[diffusers.StableDiffusionXLPAGImg2ImgPipeline]] ```python diffusers.StableDiffusionXLPAGImg2ImgPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, text_encoder_2: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, tokenizer_2: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None, requires_aesthetics_score: bool = False, force_zeros_for_empty_prompt: bool = True, add_watermarker: bool | None = None, pag_applied_layers: str | list[str] = 'mid') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_xl_img2img.py#L191) **Parámetros:** vae ([AutoencoderKL](/docs/diffusers/main/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 (`CLIPTextModel`) : Codificador de texto congelado. Stable Diffusion XL utiliza la parte de texto de [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), específicamente la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14). text_encoder_2 (` CLIPTextModelWithProjection`) : Segundo codificador de texto congelado. Stable Diffusion XL utiliza la parte de texto y pool de [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). 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). unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitectura de U-Net condicional para desruidar los latentes de imagen codificados. scheduler ([SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Puede ser uno de [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/es/api/schedulers/pndm#diffusers.PNDMScheduler). requires_aesthetics_score (`bool`, *opcional*, valor predeterminado `"False"`) : Indica si el `unet` requiere que se pase una condición `aesthetic_score` durante la inferencia. Consulte también la configuración de `stabilityai/stable-diffusion-xl-refiner-1-0`. force_zeros_for_empty_prompt (`bool`, *opcional*, valor predeterminado `"True"`) : Si las incrustaciones del prompt negativo deben forzarse a establecerse siempre en 0. Consulte también la configuración de `stabilityai/stable-diffusion-xl-base-1-0`. add_watermarker (`bool`, *opcional*) : Si se debe usar la [invisible_watermark library](https://github.com/ShieldMnt/invisible-watermark/) para aplicar marcas de agua a las imágenes de salida. Si no se define, el valor predeterminado será True si el paquete está instalado; de lo contrario, no se usará ninguna marca de agua. Pipeline para la generación de imágenes a partir de texto usando Stable Diffusion XL. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la ejecución en un dispositivo específico, etc.) El pipeline también hereda los siguientes métodos de carga: - [load_textual_inversion()](/docs/diffusers/main/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual - [from_single_file()](/docs/diffusers/main/es/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) para la carga de archivos `.ckpt` - [load_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA - [save_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA - [load_ip_adapter()](/docs/diffusers/main/es/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para cargar IP Adapters #### __call__[[diffusers.StableDiffusionXLPAGImg2ImgPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, strength: float = 0.3, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, denoising_start: float | None = None, denoising_end: float | None = None, guidance_scale: float = 5.0, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, guidance_rescale: float = 0.0, original_size: tuple[int, int] = None, crops_coords_top_left: tuple[int, int] = (0, 0), target_size: tuple[int, int] = None, negative_original_size: tuple[int, int] | None = None, negative_crops_coords_top_left: tuple[int, int] = (0, 0), negative_target_size: tuple[int, int] | None = None, aesthetic_score: float = 6.0, negative_aesthetic_score: float = 2.5, clip_skip: int | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_xl_img2img.py#L989) **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 al `tokenizer_2` y al `text_encoder_2`. Si no se define, se utiliza `prompt` en ambos text-encoders image (`torch.Tensor` o `PIL.Image.Image` o `np.ndarray` o `list[torch.Tensor]` o `list[PIL.Image.Image]` o `list[np.ndarray]`) : La(s) imagen(es) que se modificarán con el pipeline. strength (`float`, *opcional*, valor predeterminado 0.3) : Conceptualmente, indica cuánto transformar la `image` de referencia. Debe estar entre 0 y 1. `image` se utilizará como punto de partida, añadiendo más ruido a medida que aumenta el `strength`. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuando `strength` es 1, el ruido añadido será máximo y el proceso de desruido se ejecutará durante el número completo de iteraciones especificado en `num_inference_steps`. Un valor de 1, por lo tanto, ignora esencialmente `image`. Tenga en cuenta que, en el caso de que `denoising_start` se declare como un entero, el valor de `strength` se ignorará. 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. timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente. 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`. denoising_start (`float`, *opcional*) : Cuando se especifica, indica la fracción (entre 0.0 y 1.0) del proceso total de desruido que se omitirá antes de iniciarlo. En consecuencia, se omite la parte inicial del proceso de desruido y se asume que la `image` pasada es una imagen parcialmente desruidada. Tenga en cuenta que, cuando se especifica esto, la strength se ignorará. El parámetro `denoising_start` resulta especialmente beneficioso cuando este pipeline se integra en una configuración multipipeline de "Mixture of Denoisers", tal como se detalla en [**Refine Image Quality**](https://huggingface.co/docs/diffusers/using-diffusers/sdxl#refine-image-quality). denoising_end (`float`, *opcional*) : Cuando se especifica, determina la fracción (entre 0.0 y 1.0) del proceso total de desruido que debe completarse antes de que se termine prematuramente de forma intencional. Como resultado, la muestra devuelta aún conservará una cantidad sustancial de ruido (aprox. se necesitan los últimos 20% de los pasos de tiempo) y debe desrudiarse mediante un pipeline sucesor que tenga `denoising_start` establecido en 0.8 para que solo desruidice el 20% final del programador. El parámetro denoising_end debería utilizarse idealmente cuando este pipeline forma parte de una configuración multipipeline de "Mixture of Denoisers", como se detalla en [**Refine Image Quality**](https://huggingface.co/docs/diffusers/using-diffusers/sdxl#refine-image-quality). guidance_scale (`float`, *opcional*, valor predeterminado 7.5) : 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. 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 ambos text-encoders num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) en el artículo de DDIM: https://huggingface.co/papers/2010.02502. Solo se aplica a [schedulers.DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), se ignorará en los demás. 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.Tensor`, *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. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *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.Tensor`, *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.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado 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.Tensor`, *opcional*) : Embeddings de texto negativo agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de 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 (`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)`. 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.StableDiffusionXLPipelineOutput` en lugar de una tupla simple. cross_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). guidance_rescale (`float`, *opcional*, valor predeterminado 0.0) : Factor de reescalado de guía propuesto por [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) `guidance_scale` se define como `φ` en la ecuación 16. de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). El factor de reescalado de guía debe corregir la sobreexposición al usar SNR terminal cero. original_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Si `original_size` no es igual a `target_size`, la imagen parecerá haber sido reescalada hacia abajo o hacia arriba. `original_size` tiene como valor predeterminado `(height, width)` si no se especifica. Parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). crops_coords_top_left (`tuple[int]`, *opcional*, valor predeterminado (0, 0)) : `crops_coords_top_left` se puede utilizar para generar una imagen que parezca "recortada" desde la posición `crops_coords_top_left` hacia abajo. Generalmente, se logran imágenes favorables y bien centradas estableciendo `crops_coords_top_left` en (0, 0). Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). target_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : En la mayoría de los casos, `target_size` debe establecerse en la altura y el ancho deseados de la imagen generada. Si no se especifica, el valor predeterminado será `(height, width)`. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). negative_original_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de una resolución de imagen específica. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. negative_crops_coords_top_left (`tuple[int]`, *opcional*, valor predeterminado (0, 0)) : Para condicionar negativamente el proceso de generación en función de unas coordenadas de recorte específicas. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. negative_target_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de la resolución de imagen objetivo. Debe ser igual que `target_size` en la mayoría de los casos. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. aesthetic_score (`float`, *opcional*, valor predeterminado 6.0) : Se utiliza para simular una puntuación estética de la imagen generada influyendo en la condición de texto positiva. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). negative_aesthetic_score (`float`, *opcional*, valor predeterminado 2.5) : Parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Puede utilizarse para simular una puntuación estética de la imagen generada influyendo en la condición de texto negativo. 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`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, 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. pag_scale (`float`, *opcional*, valor predeterminado 3.0) : El factor de escala para la guía de atención perturbada. Si se establece en 0.0, no se utilizará la guía de atención perturbada. pag_adaptive_scale (`float`, *opcional*, valor predeterminado 0.0) : El factor de escala adaptativo para la guía de atención perturbada. Si se establece en 0.0, se utiliza `pag_scale`. **Devuelve:** `~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput` o `tuple` `~pipelines.stable_diffusion.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 AutoPipelineForImage2Image >>> from diffusers.utils import load_image >>> pipe = AutoPipelineForImage2Image.from_pretrained( ... "stabilityai/stable-diffusion-xl-refiner-1.0", ... torch_dtype=torch.float16, ... enable_pag=True, ... ) >>> pipe = pipe.to("cuda") >>> url = "https://huggingface.co/datasets/patrickvonplaten/images/resolve/main/aa_xl/000000009.png" >>> init_image = load_image(url).convert("RGB") >>> prompt = "a photo of an astronaut riding a horse on mars" >>> image = pipe(prompt, image=init_image, pag_scale=0.3).images[0] ``` #### encode_prompt[[diffusers.StableDiffusionXLPAGImg2ImgPipeline.encode_prompt]] ```python encode_prompt(prompt: str, prompt_2: str | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | None = None, negative_prompt_2: str | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_xl_img2img.py#L311) **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 ambos 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 ambos text-encoders prompt_embeds (`torch.Tensor`, *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.Tensor`, *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.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado 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.Tensor`, *opcional*) : Embeddings de texto negativo agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, los pooled negative_prompt_embeds se generarán a partir del argumento de entrada `negative_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. 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. Codifica el prompt en estados ocultos del codificador de texto. #### get_guidance_scale_embedding[[diffusers.StableDiffusionXLPAGImg2ImgPipeline.get_guidance_scale_embedding]] ```python get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_xl_img2img.py#L920) **Parámetros:** w (`torch.Tensor`) : Genera vectores de incrustación con una escala de guía especificada para enriquecer posteriormente las incrustaciones de paso temporal. embedding_dim (`int`, *opcional*, valor predeterminado 512) : Dimensión de las incrustaciones a generar. dtype (`torch.dtype`, *opcional*, valor predeterminado `torch.float32`) : Tipo de datos de los embeddings generados. **Devuelve:** `torch.Tensor` Vectores de incrustación con forma `(len(w), embedding_dim)`. Ver https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298 ## StableDiffusionXLPAGInpaintPipeline[[diffusers.StableDiffusionXLPAGInpaintPipeline]] #### diffusers.StableDiffusionXLPAGInpaintPipeline[[diffusers.StableDiffusionXLPAGInpaintPipeline]] ```python diffusers.StableDiffusionXLPAGInpaintPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, text_encoder_2: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, tokenizer_2: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None, requires_aesthetics_score: bool = False, force_zeros_for_empty_prompt: bool = True, add_watermarker: bool | None = None, pag_applied_layers: str | list[str] = 'mid') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_xl_inpaint.py#L204) **Parámetros:** vae ([AutoencoderKL](/docs/diffusers/main/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 (`CLIPTextModel`) : Codificador de texto congelado. Stable Diffusion XL utiliza la parte de texto de [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), específicamente la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14). text_encoder_2 (` CLIPTextModelWithProjection`) : Segundo codificador de texto congelado. Stable Diffusion XL utiliza la parte de texto y pool de [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). 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). unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitectura de U-Net condicional para desruidar los latentes de imagen codificados. scheduler ([SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Puede ser uno de [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/es/api/schedulers/pndm#diffusers.PNDMScheduler). requires_aesthetics_score (`bool`, *opcional*, valor predeterminado `"False"`) : Indica si el `unet` requiere que se pase una condición de aesthetic_score durante la inferencia. Consulte también la configuración de `stabilityai/stable-diffusion-xl-refiner-1-0`. force_zeros_for_empty_prompt (`bool`, *opcional*, valor predeterminado `"True"`) : Si las incrustaciones del prompt negativo deben forzarse a establecerse siempre en 0. Consulte también la configuración de `stabilityai/stable-diffusion-xl-base-1-0`. add_watermarker (`bool`, *opcional*) : Si se debe usar la [invisible_watermark library](https://github.com/ShieldMnt/invisible-watermark/) para aplicar marcas de agua a las imágenes de salida. Si no se define, el valor predeterminado será True si el paquete está instalado; de lo contrario, no se usará ninguna marca de agua. Pipeline para la generación de imágenes a partir de texto usando Stable Diffusion XL. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la ejecución en un dispositivo específico, etc.) El pipeline también hereda los siguientes métodos de carga: - [load_textual_inversion()](/docs/diffusers/main/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual - [from_single_file()](/docs/diffusers/main/es/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) para la carga de archivos `.ckpt` - [load_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA - [save_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA - [load_ip_adapter()](/docs/diffusers/main/es/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para cargar IP Adapters #### __call__[[diffusers.StableDiffusionXLPAGInpaintPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, masked_image_latents: Tensor = None, height: int | None = None, width: int | None = None, padding_mask_crop: int | None = None, strength: float = 0.9999, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, denoising_start: float | None = None, denoising_end: float | None = None, guidance_scale: float = 7.5, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, guidance_rescale: float = 0.0, original_size: tuple[int, int] = None, crops_coords_top_left: tuple[int, int] = (0, 0), target_size: tuple[int, int] = None, negative_original_size: tuple[int, int] | None = None, negative_crops_coords_top_left: tuple[int, int] = (0, 0), negative_target_size: tuple[int, int] | None = None, aesthetic_score: float = 6.0, negative_aesthetic_score: float = 2.5, clip_skip: int | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_xl_inpaint.py#L1080) **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 al `tokenizer_2` y al `text_encoder_2`. Si no se define, se utiliza `prompt` en ambos text-encoders image (`PIL.Image.Image`) : `Image`, o tensor que representa un lote de imágenes que se someterán a inpainting, *es decir*, partes de la imagen se enmascararán con `mask_image` y se repintarán según `prompt`. mask_image (`PIL.Image.Image`) : `Image`, o tensor que representa un lote de imágenes, para enmascarar `image`. Los píxeles blancos de la máscara se repintarán, mientras que los píxeles negros se conservarán. Si `mask_image` es una imagen PIL, se convertirá a un solo canal (luminancia) antes de su uso. Si es un tensor, debe contener un solo canal de color (L) en lugar de 3, por lo que la forma esperada sería `(B, H, W, 1)`. masked_image_latents (`torch.Tensor`, *opcional*) : Latente precodificado de la imagen enmascarada (para inpainting). 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. Cualquier valor inferior a 512 píxeles no funcionará bien con [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) ni con puntos de control que no estén específicamente afinados en resoluciones bajas. 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. Cualquier valor inferior a 512 píxeles no funcionará bien con [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) ni con puntos de control que no estén específicamente afinados en resoluciones bajas. padding_mask_crop (`int`, *opcional*, valor predeterminado `None`) : El tamaño del margen en el recorte que se aplicará a la imagen y la máscara. Si es `None`, no se aplica ningún recorte a la imagen y a mask_image. Si `padding_mask_crop` no es `None`, primero se buscará una región rectangular con la misma relación de aspecto que la imagen y que contenga toda el área enmascarada, y luego se expandirá esa área en función de `padding_mask_crop`. A continuación, la imagen y mask_image se recortarán 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 0.9999) : Conceptualmente, indica cuánto se debe transformar la parte enmascarada de la `image` de referencia. Debe estar entre 0 y 1. Se utilizará `image` como punto de partida, añadiendo más ruido a medida que aumenta el `strength`. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuando `strength` es 1, el ruido añadido será máximo y el proceso de desruido se ejecutará durante el número completo de iteraciones especificado en `num_inference_steps`. Por lo tanto, un valor de 1 ignora esencialmente la parte enmascarada de la `image` de referencia. Tenga en cuenta que, en el caso de que `denoising_start` se declare como un entero, se ignorará el valor de `strength`. 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. timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente. 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`. denoising_start (`float`, *opcional*) : Cuando se especifica, indica la fracción (entre 0.0 y 1.0) del proceso total de desruido que se omitirá antes de iniciarlo. En consecuencia, se omite la parte inicial del proceso de desruido y se asume que la `image` pasada es una imagen parcialmente desruidada. Tenga en cuenta que, cuando se especifica esto, la strength se ignorará. El parámetro `denoising_start` resulta especialmente beneficioso cuando este pipeline se integra en una configuración multipipeline de "Mixture of Denoisers", tal como se detalla en [**Refining the Image Output**](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/stable_diffusion_xl#refining-the-image-output). denoising_end (`float`, *opcional*) : Cuando se especifica, determina la fracción (entre 0.0 y 1.0) del proceso total de desruido que debe completarse antes de que se termine prematuramente de forma intencional. Como resultado, la muestra devuelta aún conservará una cantidad sustancial de ruido (aprox. se necesitan los últimos 20% de los pasos de tiempo) y debe desrudiarse mediante un pipeline sucesor que tenga `denoising_start` establecido en 0.8 para que solo desruidice el 20% final del programador. El parámetro denoising_end debería utilizarse idealmente cuando este pipeline forma parte de una configuración multipipeline de "Mixture of Denoisers", como se detalla en [**Refining the Image Output**](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/stable_diffusion_xl#refining-the-image-output). guidance_scale (`float`, *opcional*, valor predeterminado 7.5) : 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. 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 ambos text-encoders prompt_embeds (`torch.Tensor`, *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.Tensor`, *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.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado 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.Tensor`, *opcional*) : Embeddings de texto negativo agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de 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 (`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)`. 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`. num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) en el artículo de DDIM: https://huggingface.co/papers/2010.02502. Solo se aplica a [schedulers.DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), se ignorará en los demás. generator (`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.Tensor`, *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. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. 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 [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) en lugar de una tupla simple. cross_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). original_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Si `original_size` no es igual a `target_size`, la imagen parecerá haber sido reescalada hacia abajo o hacia arriba. `original_size` tiene como valor predeterminado `(height, width)` si no se especifica. Parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). crops_coords_top_left (`tuple[int]`, *opcional*, valor predeterminado (0, 0)) : `crops_coords_top_left` se puede utilizar para generar una imagen que parezca "recortada" desde la posición `crops_coords_top_left` hacia abajo. Generalmente, se logran imágenes favorables y bien centradas estableciendo `crops_coords_top_left` en (0, 0). Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). target_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : En la mayoría de los casos, `target_size` debe establecerse en la altura y el ancho deseados de la imagen generada. Si no se especifica, el valor predeterminado será `(height, width)`. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). negative_original_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de una resolución de imagen específica. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. negative_crops_coords_top_left (`tuple[int]`, *opcional*, valor predeterminado (0, 0)) : Para condicionar negativamente el proceso de generación en función de unas coordenadas de recorte específicas. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. negative_target_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de la resolución de imagen objetivo. Debe ser igual que `target_size` en la mayoría de los casos. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. aesthetic_score (`float`, *opcional*, valor predeterminado 6.0) : Se utiliza para simular una puntuación estética de la imagen generada influyendo en la condición de texto positiva. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). negative_aesthetic_score (`float`, *opcional*, valor predeterminado 2.5) : Parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Puede utilizarse para simular una puntuación estética de la imagen generada influyendo en la condición de texto negativo. guidance_rescale (`float`, *opcional*, valor predeterminado 0.0) : Factor de reescalado de la guía desde [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://arxiv.org/pdf/2305.08891.pdf). 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`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, 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. pag_scale (`float`, *opcional*, valor predeterminado 3.0) : El factor de escala para la guía de atención perturbada. Si se establece en 0.0, no se utilizará la guía de atención perturbada. pag_adaptive_scale (`float`, *opcional*, valor predeterminado 0.0) : El factor de escala adaptativo para la guía de atención perturbada. Si se establece en 0.0, se utiliza `pag_scale`. **Devuelve:** `~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput` o `tuple` `~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput` si `return_dict` es True, de lo contrario una `tuple. `tuple. Al devolver una tuple, 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 AutoPipelineForInpainting >>> from diffusers.utils import load_image >>> pipe = AutoPipelineForInpainting.from_pretrained( ... "stabilityai/stable-diffusion-xl-base-1.0", ... torch_dtype=torch.float16, ... variant="fp16", ... enable_pag=True, ... ) >>> pipe.to("cuda") >>> 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" >>> init_image = load_image(img_url).convert("RGB") >>> mask_image = load_image(mask_url).convert("RGB") >>> prompt = "A majestic tiger sitting on a bench" >>> image = pipe( ... prompt=prompt, ... image=init_image, ... mask_image=mask_image, ... num_inference_steps=50, ... strength=0.80, ... pag_scale=0.3, ... ).images[0] ``` #### encode_prompt[[diffusers.StableDiffusionXLPAGInpaintPipeline.encode_prompt]] ```python encode_prompt(prompt: str, prompt_2: str | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | None = None, negative_prompt_2: str | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_xl_inpaint.py#L401) **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 ambos 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 ambos text-encoders prompt_embeds (`torch.Tensor`, *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.Tensor`, *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.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado 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.Tensor`, *opcional*) : Embeddings de texto negativo agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, los pooled negative_prompt_embeds se generarán a partir del argumento de entrada `negative_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. 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. Codifica el prompt en estados ocultos del codificador de texto. #### get_guidance_scale_embedding[[diffusers.StableDiffusionXLPAGInpaintPipeline.get_guidance_scale_embedding]] ```python get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_xl_inpaint.py#L1011) **Parámetros:** w (`torch.Tensor`) : Genera vectores de incrustación con una escala de guía especificada para enriquecer posteriormente las incrustaciones de paso temporal. embedding_dim (`int`, *opcional*, valor predeterminado 512) : Dimensión de las incrustaciones a generar. dtype (`torch.dtype`, *opcional*, valor predeterminado `torch.float32`) : Tipo de datos de los embeddings generados. **Devuelve:** `torch.Tensor` Vectores de incrustación con forma `(len(w), embedding_dim)`. Ver https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298 ## StableDiffusionXLControlNetPAGPipeline[[diffusers.StableDiffusionXLControlNetPAGPipeline]] #### diffusers.StableDiffusionXLControlNetPAGPipeline[[diffusers.StableDiffusionXLControlNetPAGPipeline]] ```python diffusers.StableDiffusionXLControlNetPAGPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, text_encoder_2: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, tokenizer_2: CLIPTokenizer, unet: UNet2DConditionModel, controlnet: diffusers.models.controlnets.controlnet.ControlNetModel | list[diffusers.models.controlnets.controlnet.ControlNetModel] | tuple[diffusers.models.controlnets.controlnet.ControlNetModel] | diffusers.models.controlnets.multicontrolnet.MultiControlNetModel, scheduler: KarrasDiffusionSchedulers, force_zeros_for_empty_prompt: bool = True, add_watermarker: bool | None = None, feature_extractor: CLIPImageProcessorPil = None, image_encoder: CLIPVisionModelWithProjection = None, pag_applied_layers: str | list[str] = 'mid') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_controlnet_sd_xl.py#L185) **Parámetros:** vae ([AutoencoderKL](/docs/diffusers/main/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 ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). text_encoder_2 ([CLIPTextModelWithProjection](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModelWithProjection)) : Segundo codificador de texto congelado ([laion/CLIP-ViT-bigG-14-laion2B-39B-b160k](https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k)). tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` para tokenizar texto. tokenizer_2 ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` para tokenizar texto. unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Un `UNet2DConditionModel` para desruidar los latentes de imagen codificados. controlnet ([ControlNetModel](/docs/diffusers/main/es/api/models/controlnet#diffusers.ControlNetModel) o `list[ControlNetModel]`) : Proporciona una condición adicional al `unet` durante el proceso de desruido. Si configuras varios ControlNet como una lista, las salidas de cada ControlNet se suman para crear una condición adicional combinada. scheduler ([SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Puede ser uno de [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/es/api/schedulers/pndm#diffusers.PNDMScheduler). force_zeros_for_empty_prompt (`bool`, *opcional*, valor predeterminado `"True"`) : Si las incrustaciones del prompt negativo deben establecerse siempre en 0. Consulte también la configuración de `stabilityai/stable-diffusion-xl-base-1-0`. add_watermarker (`bool`, *opcional*) : Si se debe usar la biblioteca [invisible_watermark](https://github.com/ShieldMnt/invisible-watermark/) para aplicar marcas de agua a las imágenes de salida. Si no se define, el valor predeterminado es `True` si el paquete está instalado; de lo contrario, no se utiliza ninguna marca de agua. Pipeline para la generación de imágenes a partir de texto usando Stable Diffusion XL con guía de ControlNet. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.). El pipeline también hereda los siguientes métodos de carga: - [load_textual_inversion()](/docs/diffusers/main/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual - [load_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA - [save_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA - [from_single_file()](/docs/diffusers/main/es/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) para la carga de archivos `.ckpt` - [load_ip_adapter()](/docs/diffusers/main/es/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para cargar IP Adapters #### __call__[[diffusers.StableDiffusionXLControlNetPAGPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, denoising_end: float | None = None, guidance_scale: float = 5.0, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, controlnet_conditioning_scale: float | list[float] = 1.0, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, original_size: tuple[int, int] = None, crops_coords_top_left: tuple[int, int] = (0, 0), target_size: tuple[int, int] = None, negative_original_size: tuple[int, int] | None = None, negative_crops_coords_top_left: tuple[int, int] = (0, 0), negative_target_size: tuple[int, int] | None = None, clip_skip: int | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_controlnet_sd_xl.py#L1003) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de imágenes. Si no se define, debe pasar `prompt_embeds`. 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 utiliza `prompt` en ambos text-encoders. 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. height (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : La altura en píxeles de la imagen generada. Cualquier valor inferior a 512 píxeles no funcionará bien con [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) ni con puntos de control que no estén específicamente afinados en resoluciones bajas. width (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : El ancho en píxeles de la imagen generada. Cualquier valor inferior a 512 píxeles no funcionará bien con [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) ni con puntos de control que no estén específicamente afinados en resoluciones bajas. 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. timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente. 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`. denoising_end (`float`, *opcional*) : Cuando se especifica, determina la fracción (entre 0.0 y 1.0) del proceso total de desruido que debe completarse antes de que se termine prematuramente de forma intencional. Como resultado, la muestra devuelta aún conservará una cantidad sustancial de ruido, tal como lo determinan los pasos discretos seleccionados por el programador. El parámetro denoising_end debería utilizarse idealmente cuando esta pipeline forma parte de una configuración multipipeline de "Mixture of Denoisers", como se detalla en [**Refining the Image Output**](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/stable_diffusion_xl#refining-the-image-output) guidance_scale (`float`, *opcional*, valor predeterminado 5.0) : Un valor más alto de la escala de guía anima al modelo a generar imágenes estrechamente vinculadas al `prompt` de texto a costa de una menor calidad de imagen. La escala de guía se habilita cuando `guidance_scale > 1`. negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar lo que no debe incluirse en la generación de la imagen. Si no se define, debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale < 1`). negative_prompt_2 (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar lo que no debe incluirse en la generación de la imagen. Esto se envía a `tokenizer_2` y `text_encoder_2`. Si no está definido, se utiliza `negative_prompt` en ambos text-encoders. num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) del artículo [DDIM](https://huggingface.co/papers/2010.02502). Solo se aplica al [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler) y se ignora en otros programadores. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista. latents (`torch.Tensor`, *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. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan a partir del argumento de entrada `negative_prompt`. pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, los embeddings de texto agrupados se generan a partir del argumento de entrada `prompt`. negative_pooled_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo ya generados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación de prompts). Si no se proporcionan, los `negative_prompt_embeds` se generan 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 (`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)`. 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.Image` o `np.array`. return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) en lugar de una tupla simple. cross_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define en [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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. 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. original_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Si `original_size` no es igual a `target_size`, la imagen parecerá haber sido reescalada hacia abajo o hacia arriba. `original_size` tiene como valor predeterminado `(height, width)` si no se especifica. Parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). crops_coords_top_left (`tuple[int]`, *opcional*, valor predeterminado (0, 0)) : `crops_coords_top_left` se puede utilizar para generar una imagen que parezca "recortada" desde la posición `crops_coords_top_left` hacia abajo. Generalmente, se logran imágenes favorables y bien centradas estableciendo `crops_coords_top_left` en (0, 0). Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). target_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : En la mayoría de los casos, `target_size` debe establecerse en la altura y el ancho deseados de la imagen generada. Si no se especifica, el valor predeterminado será `(height, width)`. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). negative_original_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de una resolución de imagen específica. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. negative_crops_coords_top_left (`tuple[int]`, *opcional*, valor predeterminado (0, 0)) : Para condicionar negativamente el proceso de generación en función de unas coordenadas de recorte específicas. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. negative_target_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de la resolución de imagen objetivo. Debe ser igual que `target_size` en la mayoría de los casos. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. 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`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, 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. pag_scale (`float`, *opcional*, valor predeterminado 3.0) : El factor de escala para la guía de atención perturbada. Si se establece en 0.0, no se utilizará la guía de atención perturbada. pag_adaptive_scale (`float`, *opcional*, valor predeterminado 0.0) : El factor de escala adaptativo para la guía de atención perturbada. Si se establece en 0.0, se utiliza `pag_scale`. **Devuelve:** [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) o `tuple` Si `return_dict` es `True`, se devuelve [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput); en caso contrario, se devuelve una `tuple` que contiene las imágenes de salida. La función de llamada para el pipeline de generación. Ejemplos: ```py >>> # !pip install opencv-python transformers accelerate >>> from diffusers import AutoPipelineForText2Image, ControlNetModel, AutoencoderKL >>> from diffusers.utils import load_image >>> import numpy as np >>> import torch >>> import cv2 >>> from PIL import Image >>> prompt = "aerial view, a futuristic research complex in a bright foggy jungle, hard lighting" >>> negative_prompt = "low quality, bad quality, sketches" >>> # download an image >>> image = load_image( ... "https://hf.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/hf-logo.png" ... ) >>> # initialize the models and pipeline >>> controlnet_conditioning_scale = 0.5 # recommended for good generalization >>> controlnet = ControlNetModel.from_pretrained( ... "diffusers/controlnet-canny-sdxl-1.0", torch_dtype=torch.float16 ... ) >>> vae = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16) >>> pipe = AutoPipelineForText2Image.from_pretrained( ... "stabilityai/stable-diffusion-xl-base-1.0", ... controlnet=controlnet, ... vae=vae, ... torch_dtype=torch.float16, ... enable_pag=True, ... ) >>> pipe.enable_model_cpu_offload() >>> # get canny image >>> image = np.array(image) >>> image = cv2.Canny(image, 100, 200) >>> image = image[:, :, None] >>> image = np.concatenate([image, image, image], axis=2) >>> canny_image = Image.fromarray(image) >>> # generate image >>> image = pipe( ... prompt, controlnet_conditioning_scale=controlnet_conditioning_scale, image=canny_image, pag_scale=0.3 ... ).images[0] ``` #### encode_prompt[[diffusers.StableDiffusionXLControlNetPAGPipeline.encode_prompt]] ```python encode_prompt(prompt: str, prompt_2: str | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | None = None, negative_prompt_2: str | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_controlnet_sd_xl.py#L306) **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 ambos 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 ambos text-encoders prompt_embeds (`torch.Tensor`, *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.Tensor`, *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.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado 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.Tensor`, *opcional*) : Embeddings de texto negativo agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, los pooled negative_prompt_embeds se generarán a partir del argumento de entrada `negative_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. 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. Codifica el prompt en estados ocultos del codificador de texto. #### get_guidance_scale_embedding[[diffusers.StableDiffusionXLControlNetPAGPipeline.get_guidance_scale_embedding]] ```python get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_controlnet_sd_xl.py#L946) **Parámetros:** w (`torch.Tensor`) : Genera vectores de incrustación con una escala de guía especificada para enriquecer posteriormente las incrustaciones de paso temporal. embedding_dim (`int`, *opcional*, valor predeterminado 512) : Dimensión de las incrustaciones a generar. dtype (`torch.dtype`, *opcional*, valor predeterminado `torch.float32`) : Tipo de datos de los embeddings generados. **Devuelve:** `torch.Tensor` Vectores de incrustación con forma `(len(w), embedding_dim)`. Ver https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298 ## StableDiffusionXLControlNetPAGImg2ImgPipeline[[diffusers.StableDiffusionXLControlNetPAGImg2ImgPipeline]] #### diffusers.StableDiffusionXLControlNetPAGImg2ImgPipeline[[diffusers.StableDiffusionXLControlNetPAGImg2ImgPipeline]] ```python diffusers.StableDiffusionXLControlNetPAGImg2ImgPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, text_encoder_2: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, tokenizer_2: CLIPTokenizer, unet: UNet2DConditionModel, controlnet: diffusers.models.controlnets.controlnet.ControlNetModel | list[diffusers.models.controlnets.controlnet.ControlNetModel] | tuple[diffusers.models.controlnets.controlnet.ControlNetModel] | diffusers.models.controlnets.multicontrolnet.MultiControlNetModel, scheduler: KarrasDiffusionSchedulers, requires_aesthetics_score: bool = False, force_zeros_for_empty_prompt: bool = True, add_watermarker: bool | None = None, feature_extractor: CLIPImageProcessorPil = None, image_encoder: CLIPVisionModelWithProjection = None, pag_applied_layers: str | list[str] = 'mid') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_controlnet_sd_xl_img2img.py#L163) **Parámetros:** vae ([AutoencoderKL](/docs/diffusers/main/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 (`CLIPTextModel`) : Codificador de texto congelado. Stable Diffusion utiliza la parte de texto de [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), específicamente la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14). text_encoder_2 (` CLIPTextModelWithProjection`) : Segundo codificador de texto congelado. Stable Diffusion XL utiliza la parte de texto y pool de [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). 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). unet ([UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitectura de U-Net condicional para desruidar los latentes de imagen codificados. controlnet ([ControlNetModel](/docs/diffusers/main/es/api/models/controlnet#diffusers.ControlNetModel) o `list[ControlNetModel]`) : 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. scheduler ([SchedulerMixin](/docs/diffusers/main/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Puede ser uno de [DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) o [PNDMScheduler](/docs/diffusers/main/es/api/schedulers/pndm#diffusers.PNDMScheduler). requires_aesthetics_score (`bool`, *opcional*, valor predeterminado `"False"`) : Indica si el `unet` requiere que se pase una condición `aesthetic_score` durante la inferencia. Consulte también la configuración de `stabilityai/stable-diffusion-xl-refiner-1-0`. force_zeros_for_empty_prompt (`bool`, *opcional*, valor predeterminado `"True"`) : Si las incrustaciones del prompt negativo deben forzarse a establecerse siempre en 0. Consulte también la configuración de `stabilityai/stable-diffusion-xl-base-1-0`. add_watermarker (`bool`, *opcional*) : Si se debe usar la [invisible_watermark library](https://github.com/ShieldMnt/invisible-watermark/) para aplicar marcas de agua a las imágenes de salida. Si no se define, el valor predeterminado será True si el paquete está instalado; de lo contrario, no se usará ninguna marca de agua. feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : Un `CLIPImageProcessor` para extraer características de las imágenes generadas; se utiliza como entrada para el `safety_checker`. Pipeline para la generación de imagen a imagen usando Stable Diffusion XL con guía de ControlNet. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la ejecución en un dispositivo específico, etc.) El pipeline también hereda los siguientes métodos de carga: - [load_textual_inversion()](/docs/diffusers/main/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual - [load_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA - [save_lora_weights()](/docs/diffusers/main/es/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA - [load_ip_adapter()](/docs/diffusers/main/es/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para cargar IP Adapters #### __call__[[diffusers.StableDiffusionXLControlNetPAGImg2ImgPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, strength: float = 0.8, num_inference_steps: int = 50, guidance_scale: float = 5.0, negative_prompt: str | list[str] | None = None, negative_prompt_2: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, controlnet_conditioning_scale: float | list[float] = 0.8, guess_mode: bool = False, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, original_size: tuple[int, int] = None, crops_coords_top_left: tuple[int, int] = (0, 0), target_size: tuple[int, int] = None, negative_original_size: tuple[int, int] | None = None, negative_crops_coords_top_left: tuple[int, int] = (0, 0), negative_target_size: tuple[int, int] | None = None, aesthetic_score: float = 6.0, negative_aesthetic_score: float = 2.5, clip_skip: int | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_controlnet_sd_xl_img2img.py#L1079) **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 al `tokenizer_2` y al `text_encoder_2`. Si no se define, se utiliza `prompt` en ambos text-encoders 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 imagen inicial se utilizará como punto de partida para el proceso de generación de imágenes. También puede aceptar latentes de imagen como `image`; si se pasan latentes directamente, no se codificarán de nuevo. 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. ControlNet utiliza esta condición de entrada para generar la guía para Unet. 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 según ellos. 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 único controlnet. height (`int`, *opcional*, por defecto el tamaño de control_image) : La altura en píxeles de la imagen generada. Cualquier valor inferior a 512 píxeles no funcionará bien con [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) ni con puntos de control que no estén específicamente afinados en resoluciones bajas. width (`int`, *opcional*, por defecto el tamaño de control_image) : El ancho en píxeles de la imagen generada. Cualquier valor inferior a 512 píxeles no funcionará bien con [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) ni con puntos de control que no estén específicamente afinados en resoluciones bajas. strength (`float`, *opcional*, valor predeterminado 0.8) : Indica el grado en que se transforma la `image` de referencia. Debe estar entre 0 y 1. `image` se utiliza como punto de partida y se añade más ruido a medida que aumenta el `strength`. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuando `strength` es 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado en `num_inference_steps`. Un valor de 1 ignora esencialmente `image`. 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. guidance_scale (`float`, *opcional*, valor predeterminado 7.5) : 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. 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 ambos text-encoders num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) en el artículo de DDIM: https://huggingface.co/papers/2010.02502. Solo se aplica a [schedulers.DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), se ignorará en los demás. 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.Tensor`, *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. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *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.Tensor`, *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.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado 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.Tensor`, *opcional*) : Embeddings de texto negativo agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de 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 (`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)`. 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 [StableDiffusionPipelineOutput](/docs/diffusers/main/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) en lugar de una tupla simple. cross_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). 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. guess_mode (`bool`, *opcional*, valor predeterminado `False`) : En este modo, el codificador de ControlNet intentará reconocer el contenido de la imagen de entrada incluso si eliminas todos los prompts. Se recomienda un `guidance_scale` entre 3.0 y 5.0. 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. original_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Si `original_size` no es igual a `target_size`, la imagen parecerá haber sido reescalada hacia abajo o hacia arriba. `original_size` tiene como valor predeterminado `(height, width)` si no se especifica. Parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). crops_coords_top_left (`tuple[int]`, *opcional*, valor predeterminado (0, 0)) : `crops_coords_top_left` se puede utilizar para generar una imagen que parezca "recortada" desde la posición `crops_coords_top_left` hacia abajo. Generalmente, se logran imágenes favorables y bien centradas estableciendo `crops_coords_top_left` en (0, 0). Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). target_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : En la mayoría de los casos, `target_size` debe establecerse en la altura y el ancho deseados de la imagen generada. Si no se especifica, el valor predeterminado será `(height, width)`. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). negative_original_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de una resolución de imagen específica. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. negative_crops_coords_top_left (`tuple[int]`, *opcional*, valor predeterminado (0, 0)) : Para condicionar negativamente el proceso de generación en función de unas coordenadas de recorte específicas. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. negative_target_size (`tuple[int]`, *opcional*, valor predeterminado (1024, 1024)) : Para condicionar negativamente el proceso de generación en función de la resolución de imagen objetivo. Debe ser igual que `target_size` en la mayoría de los casos. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para obtener más información, consulte este hilo de problemas: https://github.com/huggingface/diffusers/issues/4208. aesthetic_score (`float`, *opcional*, valor predeterminado 6.0) : Se utiliza para simular una puntuación estética de la imagen generada influyendo en la condición de texto positiva. Forma parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). negative_aesthetic_score (`float`, *opcional*, valor predeterminado 2.5) : Parte del micro-condicionamiento de SDXL, tal como se explica en la sección 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Puede utilizarse para simular una puntuación estética de la imagen generada influyendo en la condición de texto negativo. 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`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, 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. pag_scale (`float`, *opcional*, valor predeterminado 3.0) : El factor de escala para la guía de atención perturbada. Si se establece en 0.0, no se utilizará la guía de atención perturbada. pag_adaptive_scale (`float`, *opcional*, valor predeterminado 0.0) : El factor de escala adaptativo para la guía de atención perturbada. Si se establece en 0.0, se utiliza `pag_scale`. **Devuelve:** `~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput` o `tuple` `~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput` si `return_dict` es True, de lo contrario una `tuple` que contiene las imágenes de salida. Función invocada al llamar a la pipeline para la generación. Ejemplos: ```py >>> # pip install accelerate transformers safetensors diffusers >>> import torch >>> import numpy as np >>> from PIL import Image >>> from transformers import DPTFeatureExtractor, DPTForDepthEstimation >>> from diffusers import ControlNetModel, StableDiffusionXLControlNetPAGImg2ImgPipeline, AutoencoderKL >>> from diffusers.utils import load_image >>> depth_estimator = DPTForDepthEstimation.from_pretrained("Intel/dpt-hybrid-midas").to("cuda") >>> feature_extractor = DPTFeatureExtractor.from_pretrained("Intel/dpt-hybrid-midas") >>> controlnet = ControlNetModel.from_pretrained( ... "diffusers/controlnet-depth-sdxl-1.0-small", ... variant="fp16", ... use_safetensors="True", ... torch_dtype=torch.float16, ... ) >>> vae = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16) >>> pipe = StableDiffusionXLControlNetPAGImg2ImgPipeline.from_pretrained( ... "stabilityai/stable-diffusion-xl-base-1.0", ... controlnet=controlnet, ... vae=vae, ... variant="fp16", ... use_safetensors=True, ... torch_dtype=torch.float16, ... enable_pag=True, ... ) >>> pipe.enable_model_cpu_offload() >>> def get_depth_map(image): ... image = feature_extractor(images=image, return_tensors="pt").pixel_values.to("cuda") ... with torch.no_grad(), torch.autocast("cuda"): ... depth_map = depth_estimator(image).predicted_depth ... depth_map = torch.nn.functional.interpolate( ... depth_map.unsqueeze(1), ... size=(1024, 1024), ... mode="bicubic", ... align_corners=False, ... ) ... depth_min = torch.amin(depth_map, dim=[1, 2, 3], keepdim=True) ... depth_max = torch.amax(depth_map, dim=[1, 2, 3], keepdim=True) ... depth_map = (depth_map - depth_min) / (depth_max - depth_min) ... image = torch.cat([depth_map] * 3, dim=1) ... image = image.permute(0, 2, 3, 1).cpu().numpy()[0] ... image = Image.fromarray((image * 255.0).clip(0, 255).astype(np.uint8)) ... return image >>> prompt = "A robot, 4k photo" >>> image = load_image( ... "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinsky/cat.png" ... ).resize((1024, 1024)) >>> controlnet_conditioning_scale = 0.5 # recommended for good generalization >>> depth_image = get_depth_map(image) >>> images = pipe( ... prompt, ... image=image, ... control_image=depth_image, ... strength=0.99, ... num_inference_steps=50, ... controlnet_conditioning_scale=controlnet_conditioning_scale, ... ).images >>> images[0].save(f"robot_cat.png") ``` #### encode_prompt[[diffusers.StableDiffusionXLControlNetPAGImg2ImgPipeline.encode_prompt]] ```python encode_prompt(prompt: str, prompt_2: str | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | None = None, negative_prompt_2: str | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_controlnet_sd_xl_img2img.py#L296) **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 ambos 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 ambos text-encoders prompt_embeds (`torch.Tensor`, *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.Tensor`, *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.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado 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.Tensor`, *opcional*) : Embeddings de texto negativo agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, los pooled negative_prompt_embeds se generarán a partir del argumento de entrada `negative_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. 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. Codifica el prompt en estados ocultos del codificador de texto. ## StableDiffusion3PAGPipeline[[diffusers.StableDiffusion3PAGPipeline]] #### diffusers.StableDiffusion3PAGPipeline[[diffusers.StableDiffusion3PAGPipeline]] ```python diffusers.StableDiffusion3PAGPipeline(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, pag_applied_layers: str | list[str] = 'blocks.1') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_3.py#L136) **Parámetros:** transformer ([SD3Transformer2DModel](/docs/diffusers/main/es/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/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/main/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). [pipeline PAG](https://huggingface.co/docs/diffusers/main/en/using-diffusers/pag) para la generación de imágenes a partir de texto usando Stable Diffusion 3. #### __call__[[diffusers.StableDiffusion3PAGPipeline.__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, 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, 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, pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_3.py#L684) **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 7.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. 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`. 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`. pag_scale (`float`, *opcional*, valor predeterminado 3.0) : El factor de escala para la guía de atención perturbada. Si se establece en 0.0, no se utilizará la guía de atención perturbada. pag_adaptive_scale (`float`, *opcional*, valor predeterminado 0.0) : El factor de escala adaptativo para la guía de atención perturbada. Si se establece en 0.0, se utiliza `pag_scale`. **Devuelve:** `~pipelines.stable_diffusion_3.StableDiffusion3PipelineOutput` o `tuple` `~pipelines.stable_diffusion_3.StableDiffusion3PipelineOutput` 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 AutoPipelineForText2Image >>> pipe = AutoPipelineForText2Image.from_pretrained( ... "stabilityai/stable-diffusion-3-medium-diffusers", ... torch_dtype=torch.float16, ... enable_pag=True, ... pag_applied_layers=["blocks.13"], ... ) >>> pipe.to("cuda") >>> prompt = "A cat holding a sign that says hello world" >>> image = pipe(prompt, guidance_scale=5.0, pag_scale=0.7).images[0] >>> image.save("sd3_pag.png") ``` #### encode_prompt[[diffusers.StableDiffusion3PAGPipeline.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/main/src/diffusers/pipelines/pag/pipeline_pag_sd_3.py#L335) **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. ## StableDiffusion3PAGImg2ImgPipeline[[diffusers.StableDiffusion3PAGImg2ImgPipeline]] #### diffusers.StableDiffusion3PAGImg2ImgPipeline[[diffusers.StableDiffusion3PAGImg2ImgPipeline]] ```python diffusers.StableDiffusion3PAGImg2ImgPipeline(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, pag_applied_layers: str | list[str] = 'blocks.1') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_3_img2img.py#L152) **Parámetros:** transformer ([SD3Transformer2DModel](/docs/diffusers/main/es/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/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/main/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). [Pipeline PAG](https://huggingface.co/docs/diffusers/main/en/using-diffusers/pag) para la generación de imagen a imagen usando Stable Diffusion 3. #### __call__[[diffusers.StableDiffusion3PAGImg2ImgPipeline.__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, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, strength: float = 0.6, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float = 7.0, 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, 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, pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_sd_3_img2img.py#L735) **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.default_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.default_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. image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` o `list[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 como `image`, pero si se pasan latentes directamente, no se vuelven a codificar. strength (`float`, *opcional*, valor predeterminado 0.8) : Indica el grado en que se transforma la `image` de referencia. Debe estar entre 0 y 1. `image` se utiliza como punto de partida y se añade más ruido a medida que aumenta el `strength`. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuando `strength` es 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado en `num_inference_steps`. Un valor de 1 ignora esencialmente `image`. 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 7.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. 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`. 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`. pag_scale (`float`, *opcional*, valor predeterminado 3.0) : El factor de escala para la guía de atención perturbada. Si se establece en 0.0, no se utilizará la guía de atención perturbada. pag_adaptive_scale (`float`, *opcional*, valor predeterminado 0.0) : El factor de escala adaptativo para la guía de atención perturbada. Si se establece en 0.0, se utiliza `pag_scale`. **Devuelve:** `~pipelines.stable_diffusion_3.StableDiffusion3PipelineOutput` o `tuple` `~pipelines.stable_diffusion_3.StableDiffusion3PipelineOutput` 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 StableDiffusion3PAGImg2ImgPipeline >>> from diffusers.utils import load_image >>> pipe = StableDiffusion3PAGImg2ImgPipeline.from_pretrained( ... "stabilityai/stable-diffusion-3-medium-diffusers", ... torch_dtype=torch.float16, ... pag_applied_layers=["blocks.13"], ... ) >>> pipe.to("cuda") >>> prompt = "a photo of an astronaut riding a horse on mars" >>> url = "https://huggingface.co/datasets/patrickvonplaten/images/resolve/main/aa_xl/000000009.png" >>> init_image = load_image(url).convert("RGB") >>> image = pipe(prompt, image=init_image, guidance_scale=5.0, pag_scale=0.7).images[0] ``` #### encode_prompt[[diffusers.StableDiffusion3PAGImg2ImgPipeline.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/main/src/diffusers/pipelines/pag/pipeline_pag_sd_3_img2img.py#L351) **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. ## PixArtSigmaPAGPipeline[[diffusers.PixArtSigmaPAGPipeline]] #### diffusers.PixArtSigmaPAGPipeline[[diffusers.PixArtSigmaPAGPipeline]] ```python diffusers.PixArtSigmaPAGPipeline(tokenizer: T5Tokenizer, text_encoder: T5EncoderModel, vae: AutoencoderKL, transformer: PixArtTransformer2DModel, scheduler: KarrasDiffusionSchedulers, pag_applied_layers: str | list[str] = 'blocks.1') ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_pixart_sigma.py#L144) [Flujo de trabajo PAG](https://huggingface.co/docs/diffusers/main/en/using-diffusers/pag) para la generación de imágenes a partir de texto usando PixArt-Sigma. #### __call__[[diffusers.PixArtSigmaPAGPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, negative_prompt: str = '', num_inference_steps: int = 20, timesteps: list[int] = None, sigmas: list[float] = None, guidance_scale: float = 4.5, num_images_per_prompt: int | None = 1, height: int | None = None, width: int | None = None, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, clean_caption: bool = True, use_resolution_binning: bool = True, max_sequence_length: int = 300, pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_pixart_sigma.py#L574) **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. 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`). num_inference_steps (`int`, *opcional*, valor predeterminado 100) : 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. timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente. 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 4.5) : 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. num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. height (`int`, *opcional*, valor predeterminado: self.unet.config.sample_size) : La altura en píxeles de la imagen generada. width (`int`, *opcional*, predeterminado a self.unet.config.sample_size) : El ancho en píxeles de la imagen generada. eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) en el artículo de DDIM: https://huggingface.co/papers/2010.02502. Solo se aplica a [schedulers.DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), se ignorará en los demás. 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.Tensor`, *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. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *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`. prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Para PixArt-Sigma, este prompt negativo debe ser "". Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`. negative_prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto negativos. 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*, por defecto `True`) : Si se devuelve un `~pipelines.stable_diffusion.IFPipelineOutput` en lugar de una tupla simple. callback (`Callable`, *opcional*) : Una función que se llamará cada `callback_steps` pasos durante la inferencia. La función se llamará con los siguientes argumentos: `callback(step: int, timestep: int, latents: torch.Tensor)`. callback_steps (`int`, *opcional*, valor predeterminado 1) : La frecuencia con la que se llamará a la función `callback`. Si no se especifica, la callback se llamará en cada paso. clean_caption (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe limpiar la descripción antes de crear los embeddings. Requiere que `beautifulsoup4` y `ftfy` estén instalados. Si las dependencias no están instaladas, los embeddings se crearán a partir del prompt sin procesar. use_resolution_binning (`bool` por defecto `True`) : Si se establece en `True`, la altura y el ancho solicitados se mapean primero a las resoluciones más cercanas usando `ASPECT_RATIO_1024_BIN`. Después de que los latentes generados se decodifican en imágenes, se redimensionan de nuevo a la resolución solicitada. Útil para generar imágenes que no son cuadradas. max_sequence_length (`int` por defecto 300) : Longitud máxima de la secuencia a utilizar con el `prompt`. pag_scale (`float`, *opcional*, valor predeterminado 3.0) : El factor de escala para la guía de atención perturbada. Si se establece en 0.0, no se utilizará la guía de atención perturbada. pag_adaptive_scale (`float`, *opcional*, valor predeterminado 0.0) : El factor de escala adaptativo para la guía de atención perturbada. Si se establece en 0.0, se utiliza `pag_scale`. **Devuelve:** [ImagePipelineOutput](/docs/diffusers/main/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) o `tuple` Si `return_dict` es `True`, se devuelve [ImagePipelineOutput](/docs/diffusers/main/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput); en caso contrario, se devuelve una `tuple` cuyo 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 AutoPipelineForText2Image >>> pipe = AutoPipelineForText2Image.from_pretrained( ... "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS", ... torch_dtype=torch.float16, ... pag_applied_layers=["blocks.14"], ... enable_pag=True, ... ) >>> pipe = pipe.to("cuda") >>> prompt = "A small cactus with a happy face in the Sahara desert" >>> image = pipe(prompt, pag_scale=4.0, guidance_scale=1.0).images[0] ``` #### encode_prompt[[diffusers.PixArtSigmaPAGPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, negative_prompt: str = '', num_images_per_prompt: int = 1, device: typing.Optional[torch.device] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, clean_caption: bool = False, max_sequence_length: int = 300, **kwargs) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pag/pipeline_pag_pixart_sigma.py#L190) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar negative_prompt (`str` o `list[str]`, *opcional*) : El prompt que no debe 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`). Para PixArt-Alpha, esto debería ser "". do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : si se debe usar classifier free guidance o no num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : número de imágenes que deben generarse por indicación device : (`torch.device`, *opcional*): dispositivo de torch en el que colocar las incrustaciones resultantes prompt_embeds (`torch.Tensor`, *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.Tensor`, *opcional*) : Embeddings de texto negativo pregenerados. Para PixArt-Alpha, deben ser los embeddings de la cadena "". clean_caption (`bool`, por defecto `False`) : Si `True`, la función preprocesará y limpiará la descripción proporcionada antes de codificarla. max_sequence_length (`int`, por defecto 300) : Longitud máxima de la secuencia a utilizar para el prompt. Codifica el prompt en estados ocultos del codificador de texto.