Diffusers documentation
Imagen a imagen
Imagen a imagen
El modelo Stable Diffusion también se puede aplicar a la generación de imagen a imagen pasando un prompt de texto y una imagen inicial para condicionar la generación de nuevas imágenes.
El StableDiffusionImg2ImgPipeline utiliza el mecanismo de difusión y eliminación de ruido propuesto en SDEdit: Guided Image Synthesis and Editing with Stochastic Differential Equations de Chenlin Meng, Yutong He, Yang Song, Jiaming Song, Jiajun Wu, Jun-Yan Zhu, Stefano Ermon.
El resumen del artículo es:
La síntesis de imágenes guiada permite a los usuarios habituales crear y editar imágenes fotorrealistas con un esfuerzo mínimo. El principal desafío es equilibrar la fidelidad a la entrada del usuario (p. ej., trazos coloreados dibujados a mano) y el realismo de la imagen sintetizada. Los métodos basados en GAN existentes intentan lograr dicho equilibrio utilizando GAN condicionales o inversiones de GAN, lo cual resulta complejo y a menudo requiere datos de entrenamiento adicionales o funciones de pérdida para aplicaciones individuales. Para abordar estos problemas, presentamos un nuevo método de síntesis y edición de imágenes, Stochastic Differential Editing (SDEdit), basado en un generativo previo de un modelo de difusión, que sintetiza imágenes realistas mediante la desruidado iterativo a través de una ecuación diferencial estocástica (SDE). Dada una imagen de entrada con una guía de usuario de cualquier tipo, SDEdit primero añade ruido a la entrada y, a continuación, desruidado la imagen resultante a través del previo SDE para aumentar su realismo. SDEdit no requiere entrenamiento específico de la tarea ni inversiones y puede lograr de forma natural el equilibrio entre realismo y fidelidad. SDEdit supera significativamente a los métodos basados en GAN del estado del arte en hasta un 98,09 % en realismo y un 91,72 % en las puntuaciones de satisfacción general, según un estudio de percepción humana, en múltiples tareas, que incluyen la síntesis y edición de imágenes basadas en trazos, así como la composición de imágenes.
Asegúrate de consultar la sección Consejos de Stable Diffusion para aprender a explorar el equilibrio entre la velocidad y la calidad del programador, y a reutilizar los componentes del pipeline de manera eficiente.
StableDiffusionImg2ImgPipeline
clase diffusers.StableDiffusionImg2ImgPipeline
< source >( vae: AutoencoderKLtext_encoder: CLIPTextModeltokenizer: CLIPTokenizerunet: UNet2DConditionModelscheduler: KarrasDiffusionSchedulerssafety_checker: StableDiffusionSafetyCheckerfeature_extractor: CLIPImageProcessorPilimage_encoder: CLIPVisionModelWithProjection = Nonerequires_safety_checker: bool = True )
Parámetros
- vae (AutoencoderKL) — Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes a partir de y hacia representaciones latentes.
- text_encoder (CLIPTextModel) — Codificador de texto congelado (clip-vit-large-patch14).
- tokenizer (CLIPTokenizer) —
Un
CLIPTokenizerpara tokenizar texto. - unet (UNet2DConditionModel) —
Un
UNet2DConditionModelpara desruidar los latentes de la imagen codificada. - scheduler (SchedulerMixin) —
Un scheduler para usar en combinación con
unetpara desruidar los latentes de la imagen codificada. Puede ser uno de DDIMScheduler, LMSDiscreteScheduler o 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 para obtener más detalles sobre los posibles daños de un modelo. - feature_extractor (CLIPImageProcessor) —
Un
CLIPImageProcessorpara extraer características de las imágenes generadas; se utiliza como entrada para elsafety_checker.
Pipeline para la generación de imagen a imagen guiada por texto usando Stable Diffusion.
Este modelo hereda de 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() para cargar incrustaciones de inversión textual
- load_lora_weights() para cargar los pesos de LoRA
- save_lora_weights() para guardar los pesos de LoRA
- from_single_file() para la carga de archivos
.ckpt - load_ip_adapter() para cargar IP Adapters
__call__
< source >( prompt: str | list[str] = Noneimage: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = Nonestrength: float = 0.8num_inference_steps: int | None = 50timesteps: list = Nonesigmas: list = Noneguidance_scale: float | None = 7.5negative_prompt: str | list[str] | None = Nonenum_images_per_prompt: int | None = 1eta: float | None = 0.0generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Noneip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Noneip_adapter_image_embeds: list[torch.Tensor] | None = Noneoutput_type: str | None = 'pil'return_dict: bool = Truecross_attention_kwargs: dict[str, typing.Any] | None = Noneclip_skip: int = Nonecallback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = Nonecallback_on_step_end_tensor_inputs: list = ['latents']**kwargs ) → StableDiffusionPipelineOutput or tuple
Parámetros
- prompt (
strolist[str], opcional) — El prompt o prompts para guiar la generación de imágenes. Si no se define, debe pasarprompt_embeds. - image (
torch.Tensor,PIL.Image.Image,np.ndarray,list[torch.Tensor],list[PIL.Image.Image]olist[np.ndarray]) —Image, array de numpy o tensor que representa un lote de imágenes para usarse como punto de partida. Tanto para arrays de numpy como para tensors de pytorch, el rango de valores esperado está entre[0, 1]Si es un tensor o una lista de tensors, la forma esperada debe ser(B, C, H, W)o(C, H, W). Si es un array de numpy o una lista de arrays, la forma esperada debe ser(B, H, W, C)o(H, W, C)También puede aceptar latentes de imagen comoimage, pero si se pasan latentes directamente, no se vuelven a codificar. - strength (
float, opcional, valor predeterminado 0.8) — Indica el grado en que se transforma laimagede referencia. Debe estar entre 0 y 1.imagese utiliza como punto de partida y se añade más ruido a medida que aumenta elstrength. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuandostrengthes 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado ennum_inference_steps. Un valor de 1 ignora esencialmenteimage. - num_inference_steps (
int, opcional, valor predeterminado 50) — El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta. Este parámetro se modula porstrength. - timesteps (
list[int], opcional) — Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumentotimestepsen su métodoset_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pasenum_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 argumentosigmasen su métodoset_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pasenum_inference_steps. - guidance_scale (
float, opcional, valor predeterminado 7.5) — Un valor de escala de guía más alto anima al modelo a generar imágenes estrechamente vinculadas alpromptde texto a costa de una menor calidad de imagen. La escala de guía se habilita cuandoguidance_scale > 1. - negative_prompt (
strolist[str], opcional) — El prompt o los prompts para guiar lo que no debe incluirse en la generación de imágenes. Si no se define, es necesario pasarnegative_prompt_embedsen 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 que se generarán por indicación. - eta (
float, opcional, valor predeterminado 0.0) — Corresponde al parámetro eta (η) del artículo DDIM. Solo se aplica al DDIMScheduler y se ignora en otros programadores. - generator (
torch.Generatorolist[torch.Generator], opcional) — Untorch.Generatorpara hacer que la generación sea 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 entradaprompt. - negative_prompt_embeds (
torch.Tensor, opcional) — Incrustaciones de texto negativo pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan,negative_prompt_embedsse generan a partir del argumento de entradanegative_prompt. - ip_adapter_image — (
PipelineImageInput, opcional): Entrada de imagen opcional para trabajar con IP Adapters. - ip_adapter_image_embeds (
list[torch.Tensor], opcional) — Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma(batch_size, num_images, emb_dim). Debe contener la incrustación de imagen negativa sido_classifier_free_guidanceestá establecido enTrue. Si no se proporciona, las incrustaciones se calculan a partir del argumento de entradaip_adapter_image. - output_type (
str, opcional, por defecto"pil") — El formato de salida de la imagen generada. Elija entrePIL.Imageonp.array. - return_dict (
bool, opcional, valor predeterminadoTrue) — Indica si se debe devolver un StableDiffusionPipelineOutput en lugar de una tupla simple. - cross_attention_kwargs (
dict, opcional) — Un diccionario de kwargs que, si se especifica, se pasa alAttentionProcessortal como se define enself.processor. - 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 penúltima capa para calcular los embeddings del prompt. - callback_on_step_end (
Callable,PipelineCallback,MultiPipelineCallbacks, opcional) — Una función o una subclase dePipelineCallbackoMultiPipelineCallbacksque se llama al final de cada paso de desruido durante la inferencia, con los siguientes argumentos:callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict).callback_kwargsincluirá una lista de todos los tensores especificados porcallback_on_step_end_tensor_inputs. - callback_on_step_end_tensor_inputs (
list, opcional) — La lista de entradas de tensor para la funcióncallback_on_step_end. Los tensores especificados en la lista se pasarán como argumentocallback_kwargs. Solo podrás incluir variables listadas en el atributo._callback_tensor_inputsde tu clase de pipeline.
Devuelve
StableDiffusionPipelineOutput o tuple
Si return_dict es True, se devuelve StableDiffusionPipelineOutput,
en caso contrario se devuelve una tuple cuyo primer elemento es una lista con las imágenes generadas y el
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:
>>> import requests
>>> import torch
>>> from PIL import Image
>>> from io import BytesIO
>>> from diffusers import StableDiffusionImg2ImgPipeline
>>> device = "cuda"
>>> model_id_or_path = "stable-diffusion-v1-5/stable-diffusion-v1-5"
>>> pipe = StableDiffusionImg2ImgPipeline.from_pretrained(model_id_or_path, torch_dtype=torch.float16)
>>> pipe = pipe.to(device)
>>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
>>> response = requests.get(url)
>>> init_image = Image.open(BytesIO(response.content)).convert("RGB")
>>> init_image = init_image.resize((768, 512))
>>> prompt = "A fantasy landscape, trending on artstation"
>>> images = pipe(prompt=prompt, image=init_image, strength=0.75, guidance_scale=7.5).images
>>> images[0].save("fantasy_landscape.png")enable_attention_slicing
< source >( slice_size: str | int = 'auto' )
Parámetros
- slice_size (
stroint, opcional, valor predeterminado"auto") — Cuando es"auto", se divide a la mitad la entrada de las cabezas de atención, de modo que la atención se calcula en dos pasos. Si es"max", se ahorra la máxima cantidad de memoria al ejecutar solo una porción a la vez. Si se proporciona un número, se usan tantas porciones comoattention_head_dim // slice_size. En este caso,attention_head_dimdebe ser un múltiplo deslice_size.
Habilita el cálculo de atención segmentada. Cuando esta opción está habilitada, el módulo de atención divide el tensor de entrada en fragmentos para calcular la atención en varios pasos. Para más de una cabeza de atención, el cálculo se realiza secuencialmente sobre cada cabeza. Esto es útil para ahorrar algo de memoria a cambio de una pequeña disminución en la velocidad.
> ⚠️ No actives el *slicing* de atención si ya estás usando
scaled_dot_product_attention(SDPA) de PyTorch > 2.0 o xFormers. Estos cálculos de atención ya son muy eficientes en memoria, por lo que no necesitarás activar > esta función. Si activas el *slicing* de atención con SDPA o xFormers, ¡puede provocar ralentizamientos significativos!
Ejemplos:
>>> import torch
>>> from diffusers import StableDiffusionPipeline
>>> pipe = StableDiffusionPipeline.from_pretrained(
... "stable-diffusion-v1-5/stable-diffusion-v1-5",
... dtype=torch.float16,
... use_safetensors=True,
... )
>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> pipe.enable_attention_slicing()
>>> image = pipe(prompt).images[0]Desactiva el cálculo de atención segmentada. Si enable_attention_slicing se llamó previamente, la atención se calcula en un solo paso.
enable_xformers_memory_efficient_attention
< source >( attention_op: typing.Optional[typing.Callable] = None )
Parámetros
- attention_op (
Callable, opcional) — Sustituye el operador predeterminadoNonepara usarlo como argumentoopde la funciónmemory_efficient_attention()de xFormers.
Habilita la atención eficiente en memoria desde xFormers. Cuando esta opción está habilitada, debería observar un menor uso de memoria de GPU y una posible aceleración durante la inferencia. No se garantiza una aceleración durante el entrenamiento.
> ⚠️ Cuando la atención eficiente en memoria y la atención segmentada están ambas habilitadas, la atención eficiente en memoria tiene > precedencia.
Ejemplos:
>>> import torch
>>> from diffusers import DiffusionPipeline
>>> from xformers.ops import MemoryEfficientAttentionFlashAttentionOp
>>> pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1", dtype=torch.float16)
>>> pipe = pipe.to("cuda")
>>> pipe.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)
>>> # Workaround for not accepting attention shape using VAE for Flash Attention
>>> pipe.vae.enable_xformers_memory_efficient_attention(attention_op=None)Desactivar la atención eficiente en memoria de xFormers.
load_textual_inversion
< source >( pretrained_model_name_or_path: str | list[str] | dict[str, torch.Tensor] | list[dict[str, torch.Tensor]]token: str | list[str] | None = Nonetokenizer: 'PreTrainedTokenizer' | None = Nonetext_encoder: 'PreTrainedModel' | None = None**kwargs )
Parámetros
- pretrained_model_name_or_path (
stroos.PathLikeolist[str or os.PathLike]oDictolist[Dict]) — Puede ser cualquiera de los siguientes o una lista de ellos:- Una cadena de texto, el model id (por ejemplo,
sd-concepts-library/low-poly-hd-logos-icons) de un modelo preentrenado alojado en el Hub. - Una ruta a un directorio (por ejemplo,
./my_text_inversion_directory/) que contenga los pesos de la inversión textual. - Una ruta a un archivo (por ejemplo,
./my_text_inversions.pt) que contiene los pesos de inversión textual. - Un diccionario de estado de torch.
- Una cadena de texto, el model id (por ejemplo,
- token (
strolist[str], opcional) — Sobrescribe el token que se usará para los pesos de inversión textual. Sipretrained_model_name_or_pathes una lista, entoncestokentambién debe ser una lista de la misma longitud. - text_encoder (CLIPTextModel, opcional) — Codificador de texto congelado (clip-vit-large-patch14). Si no se especifica, la función tomará self.tokenizer.
- tokenizer (CLIPTokenizer, opcional) —
Un
CLIPTokenizerpara tokenizar texto. Si no se especifica, la función tomará self.tokenizer. - weight_name (
str, opcional) — Nombre de un archivo de pesos personalizado. Esto debe usarse cuando:- El archivo de inversión textual guardado está en formato de 🤗 Diffusers, pero se guardó con un nombre de peso específico, como
text_inv.bin. - El archivo de inversión textual guardado está en el formato de Automatic1111.
- El archivo de inversión textual guardado está en formato de 🤗 Diffusers, pero se guardó con un nombre de peso específico, como
- cache_dir (
str | os.PathLike, opcional) — Ruta a un directorio donde se almacena en caché la configuración de un modelo preentrenado descargado si no se utiliza la caché estándar. - force_download (
bool, opcional, valor predeterminadoFalse) — Indica si se debe forzar la (re)descarga de los pesos del modelo y los archivos de configuración, ignorando las versiones en caché si existen. - proxies (
dict[str, str], opcional) — Un diccionario de servidores proxy a utilizar por protocolo o punto de acceso, por ejemplo,{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. Los proxies se utilizan en cada solicitud. - local_files_only (
bool, opcional, valor predeterminadoFalse) — Indica si se deben cargar únicamente los pesos y archivos de configuración del modelo locales. Si se establece enTrue, el modelo no se descargará desde el Hub. - hf_token (
stro bool, opcional) — El token que se usará como autorización HTTP bearer para los archivos remotos. Si esTrue, se utiliza el token generado desdediffusers-cli login(almacenado en~/.huggingface). - revision (
str, opcional, valor predeterminado"main") — La versión específica del modelo que se va a utilizar. Puede ser el nombre de una rama, el nombre de una etiqueta, un id de commit o cualquier identificador permitido por Git. - subfolder (
str, opcional, por defecto"") — La ubicación de la subcarpeta de un archivo de modelo dentro de un repositorio de modelos más grande en el Hub o localmente. - mirror (
str, opcional) — Origen de espejo para resolver problemas de accesibilidad si estás descargando un modelo en China. No garantizamos la oportunidad ni la seguridad de la fuente, y debes consultar el sitio del espejo para obtener más información.
Carga los embeddings de Textual Inversion en el codificador de texto de StableDiffusionPipeline (se admiten tanto el formato de 🤗 Diffusers como el de Automatic1111).
Ejemplo:
Para cargar un vector de incrustación de Textual Inversion en formato 🤗 Diffusers:
from diffusers import StableDiffusionPipeline
import torch
model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")
pipe.load_textual_inversion("sd-concepts-library/cat-toy")
prompt = "A <cat-toy> backpack"
image = pipe(prompt, num_inference_steps=50).images[0]
image.save("cat-backpack.png")Para cargar un vector de incrustación de Textual Inversion en formato Automatic1111, asegúrese de descargar primero el vector (por ejemplo, desde civitAI) y luego cargar el vector
localmente:
from diffusers import StableDiffusionPipeline
import torch
model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")
pipe.load_textual_inversion("./charturnerv2.pt", token="charturnerv2")
prompt = "charturnerv2, multiple views of the same character in the same outfit, a character turnaround of a woman wearing a black jacket and red shirt, best quality, intricate details."
image = pipe(prompt, num_inference_steps=50).images[0]
image.save("character.png")from_single_file
< source >( pretrained_model_link_or_path**kwargs )
Parámetros
- pretrained_model_link_or_path (
stroos.PathLike, opcional) — Puede ser:- Un enlace al archivo
.ckpt(por ejemplo"https://huggingface.co/<repo_id>/blob/main/<path_to_file>.ckpt") en el Hub. - Una ruta a un archivo que contiene todos los pesos del pipeline.
- Un enlace al archivo
- dtype (
strotorch.dtype, opcional) — Sobrescribe eltorch.dtypepredeterminado y carga el modelo con otro dtype. - force_download (
bool, opcional, valor predeterminadoFalse) — Indica si se debe forzar la (re)descarga de los pesos del modelo y los archivos de configuración, ignorando las versiones en caché si existen. - cache_dir (
str | os.PathLike, opcional) — Ruta a un directorio donde se almacena en caché la configuración de un modelo preentrenado descargado si no se utiliza la caché estándar. - proxies (
dict[str, str], opcional) — Un diccionario de servidores proxy a utilizar por protocolo o punto de acceso, por ejemplo,{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. Los proxies se utilizan en cada solicitud. - local_files_only (
bool, opcional, valor predeterminadoFalse) — Indica si se deben cargar únicamente los pesos y archivos de configuración del modelo locales. Si se establece enTrue, el modelo no se descargará desde el Hub. - token (
stro bool, opcional) — El token que se usará como autorización HTTP bearer para los archivos remotos. SiTrue, se utiliza el token generado desdediffusers-cli login(almacenado en~/.huggingface). - revision (
str, opcional, valor predeterminado"main") — La versión específica del modelo que se va a utilizar. Puede ser el nombre de una rama, el nombre de una etiqueta, un id de commit o cualquier identificador permitido por Git. - original_config_file (
str, opcional) — La ruta al archivo de configuración original que se utilizó para entrenar el modelo. Si no se proporciona, el archivo de configuración se inferirá a partir del archivo de checkpoint. - config (
str, opcional) — Puede ser:- Una cadena de caracteres, el repo id (por ejemplo,
CompVis/ldm-text2im-large-256) de un pipeline preentrenado alojado en el Hub. - Una ruta a un directorio (por ejemplo,
./my_pipeline_directory/) que contiene las configuraciones de los componentes del pipeline en formato Diffusers.
- Una cadena de caracteres, el repo id (por ejemplo,
- disable_mmap (‘bool’, opcional, valor predeterminado ‘False’) — Si se deshabilita mmap al cargar un modelo de Safetensors. Esta opción puede ofrecer un mejor rendimiento cuando el modelo se encuentra en una unidad de red o en un disco duro.
- kwargs (diccionario restante de argumentos de palabra clave, opcional) —
Se puede usar para sobrescribir las variables de carga y guardado (los componentes de pipeline de la clase de pipeline específica). Los componentes sobrescritos se pasan directamente al método
__init__de los pipelines. Consulte el ejemplo siguiente para obtener más información.
Instancia un DiffusionPipeline a partir de pesos de pipeline preentrenados guardados en el formato .ckpt o .safetensors. El pipeline se establece en modo de evaluación (model.eval()) de forma predeterminada.
Ejemplos:
>>> from diffusers import StableDiffusionPipeline
>>> # Download pipeline from huggingface.co and cache.
>>> pipeline = StableDiffusionPipeline.from_single_file(
... "https://huggingface.co/WarriorMama777/OrangeMixs/blob/main/Models/AbyssOrangeMix/AbyssOrangeMix.safetensors"
... )
>>> # Download pipeline from local file
>>> # file is downloaded under ./v1-5-pruned-emaonly.ckpt
>>> pipeline = StableDiffusionPipeline.from_single_file("./v1-5-pruned-emaonly.ckpt")
>>> # Enable float16 and move to GPU
>>> pipeline = StableDiffusionPipeline.from_single_file(
... "https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5/blob/main/v1-5-pruned-emaonly.ckpt",
... torch_dtype=torch.float16,
... )
>>> pipeline.to("cuda")load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Parámetros
- pretrained_model_name_or_path_or_dict (
stroos.PathLikeodict) — Vea lora_state_dict(). - adapter_name (
str, opcional) — Nombre del adaptador que se usará para referenciar el modelo de adaptador cargado. Si no se especifica, se usarádefault_{i}, donde i es el número total de adaptadores que se están cargando. - low_cpu_mem_usage (
bool, opcional) — Acelera la carga del modelo cargando solo los pesos LoRA preentrenados y no inicializando los pesos aleatorios. - hotswap (
bool, opcional) — Por defecto esFalse. Si se debe sustituir un adaptador (LoRA) existente por el adaptador recién cargado en su lugar. Esto significa que, en lugar de cargar un adaptador adicional, se tomarán los pesos del adaptador existente y se reemplazarán con los pesos del nuevo adaptador. Esto puede ser más rápido y eficiente en memoria. Sin embargo, la principal ventaja del hotswapping es que, cuando el modelo se compila con torch.compile, la carga del nuevo adaptador no requiere recompilar el modelo. Al usar hotswapping, eladapter_namedebe ser el nombre de un adaptador ya cargado.Si el nuevo adaptador y el antiguo tienen rangos y/o alfas LoRA (es decir, escalado) diferentes, necesitas llamar a un método adicional antes de cargar el adaptador:
Carga los pesos de LoRA especificados en pretrained_model_name_or_path_or_dict en self.unet y self.text_encoder.
Todos los kwargs se reenvían a self.lora_state_dict.
Consulte lora_state_dict() para obtener más detalles sobre cómo se carga el state dict.
Consulte load_lora_into_unet() para obtener más detalles sobre cómo se carga el state dict en self.unet.
Consulte load_lora_into_text_encoder() para obtener más detalles sobre cómo se carga el state dict en self.text_encoder.
save_lora_weights
< source >( save_directory: str | os.PathLikeunet_lora_layers: dict = Nonetext_encoder_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Trueunet_lora_adapter_metadata = Nonetext_encoder_lora_adapter_metadata = None )
Parámetros
- save_directory (
stroos.PathLike) — Directorio donde se guardarán los parámetros de LoRA. Se creará si no existe. - unet_lora_layers (
dict[str, torch.nn.Module]odict[str, torch.Tensor]) — State dict de las capas LoRA correspondientes alunet. - text_encoder_lora_layers (
dict[str, torch.nn.Module]odict[str, torch.Tensor]) — State dict de las capas LoRA correspondientes altext_encoder. Debe pasar explícitamente el state dict de LoRA del codificador de texto, ya que proviene de 🤗 Transformers. - is_main_process (
bool, opcional, valor predeterminadoTrue) — Indica si el proceso que realiza esta llamada es el proceso principal o no. Útil durante el entrenamiento distribuido cuando es necesario llamar a esta función en todos los procesos. En este caso, establezcais_main_process=Truesolo en el proceso principal para evitar condiciones de carrera. - save_function (
Callable) — La función que se utilizará para guardar el diccionario de estado. Útil durante el entrenamiento distribuido cuando se necesita reemplazartorch.savecon otro método. Puede configurarse con la variable de entornoDIFFUSERS_SAVE_MODE. - safe_serialization (
bool, opcional, valor predeterminadoTrue) — Si se guarda el modelo usandosafetensorso de la forma tradicional de PyTorch conpickle. - unet_lora_adapter_metadata — Metadatos del adaptador LoRA asociados con el unet que se serializarán con el state dict.
- text_encoder_lora_adapter_metadata — Metadatos del adaptador LoRA asociados con el codificador de texto que se serializarán con el state dict.
Guarde los parámetros de LoRA correspondientes al UNet y al codificador de texto.
encode_prompt
< source >( promptdevicenum_images_per_promptdo_classifier_free_guidancenegative_prompt = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonelora_scale: float | None = Noneclip_skip: int | None = None )
Parámetros
- prompt (
strolist[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 classifier free guidance o no - negative_prompt (
strolist[str], opcional) — El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasarnegative_prompt_embedsen su lugar. Se ignora cuando no se usa guía (es decir, se ignora siguidance_scalees menor que1). - prompt_embeds (
torch.Tensor, opcional) — Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporcionan, las incrustaciones de texto se generarán a partir del argumento de entradaprompt. - negative_prompt_embeds (
torch.Tensor, opcional) — Incrustaciones de texto negativo pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entradanegative_prompt. - 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 penúltima capa para calcular los embeddings del prompt.
Codifica el prompt en estados ocultos del codificador de texto.
get_guidance_scale_embedding
< source >( w: Tensorembedding_dim: int = 512dtype: dtype = torch.float32 ) → torch.Tensor
Parámetros
- w (
torch.Tensor) — Genera vectores de incrustación con una escala de orientación especificada para enriquecer posteriormente las incrustaciones de paso temporal. - embedding_dim (
int, opcional, valor predeterminado 512) — Dimensión de los embeddings a generar. - dtype (
torch.dtype, opcional, valor predeterminadotorch.float32) — Tipo de datos de los embeddings generados.
Devuelve
torch.Tensor
Vectores de incrustación con forma (len(w), embedding_dim).
StableDiffusionPipelineOutput
clase diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput
< source >( images: list[PIL.Image.Image] | numpy.ndarraynsfw_content_detected: list[bool] | None )
Parámetros
- images (
list[PIL.Image.Image]onp.ndarray) — lista de imágenes PIL desruidadas de longitudbatch_sizeo array de NumPy de forma(batch_size, height, width, num_channels). - nsfw_content_detected (
list[bool]) — lista que indica si la imagen generada correspondiente contiene contenido “no apto para el trabajo” (nsfw) oNonesi no se pudo realizar la verificación de seguridad.
Clase de salida para las tuberías de Stable Diffusion.