Diffusers documentation

LoRA

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

LoRA

LoRA es un método de entrenamiento rápido y ligero que inserta y entrena un número significativamente menor de parámetros en lugar de todos los parámetros del modelo. Esto genera un archivo más pequeño (~100 MB) y facilita entrenar rápidamente un modelo para que aprenda un nuevo concepto. Los pesos de LoRA suelen cargarse en el denoiser, el codificador de texto o en ambos. El denoiser suele corresponder a un UNet (por ejemplo, UNet2DConditionModel) o a un Transformer (por ejemplo, SD3Transformer2DModel). Hay varias clases para cargar los pesos de LoRA:

  • StableDiffusionLoraLoaderMixin proporciona funciones para cargar y descargar, fusionar y desfusionar, habilitar y deshabilitar, y otras funciones para gestionar los pesos de LoRA. Esta clase se puede utilizar con cualquier modelo.
  • StableDiffusionXLLoraLoaderMixin es una versión de Stable Diffusion (SDXL) de la clase StableDiffusionLoraLoaderMixin para cargar y guardar pesos de LoRA. Solo se puede usar con el modelo SDXL.
  • SD3LoraLoaderMixin proporciona funciones similares para Stable Diffusion 3.
  • FluxLoraLoaderMixin proporciona funciones similares para Flux.
  • CogVideoXLoraLoaderMixin proporciona funciones similares para CogVideoX.
  • Mochi1LoraLoaderMixin proporciona funciones similares para Mochi.
  • AuraFlowLoraLoaderMixin proporciona funciones similares para AuraFlow.
  • LTXVideoLoraLoaderMixin proporciona funciones similares para LTX-Video.
  • SanaLoraLoaderMixin proporciona funciones similares para Sana.
  • HeliosLoraLoaderMixin proporciona funciones similares para HunyuanVideo.
  • HunyuanVideoLoraLoaderMixin proporciona funciones similares para HunyuanVideo.
  • Lumina2LoraLoaderMixin proporciona funciones similares para Lumina2.
  • WanLoraLoaderMixin proporciona funciones similares para Wan.
  • SkyReelsV2LoraLoaderMixin proporciona funciones similares para SkyReels-V2.
  • CogView4LoraLoaderMixin proporciona funciones similares para CogView4.
  • AmusedLoraLoaderMixin es para AmusedPipeline.
  • AnimaLoraLoaderMixin proporciona funciones similares para Anima.
  • AceStepLoraLoaderMixin proporciona funciones similares para ACE-Step.
  • HiDreamImageLoraLoaderMixin proporciona funciones similares para HiDream Image
  • QwenImageLoraLoaderMixin proporciona funciones similares para Qwen Image.
  • ZImageLoraLoaderMixin proporciona funciones similares para Z-Image.
  • Flux2LoraLoaderMixin proporciona funciones similares para Flux2.
  • ErnieImageLoraLoaderMixin proporciona funciones similares para Ernie-Image.
  • LTX2LoraLoaderMixin proporciona funciones similares para Flux2.
  • MiniMaxH3LoraLoaderMixin proporciona funciones similares para MiniMax-H3.
  • PikaH3FlexLoraLoaderMixin proporciona funciones similares para Pika H3 Flex.
  • RFD4ProteinaLoraLoaderMixin proporciona funciones similares para RFD4-Proteína.
  • BriaFibo2LoraLoaderMixin proporciona funciones similares para fibo-2.
  • LoraBaseMixin proporciona una clase base con varios métodos de utilidad para fusionar, desfusionar, descargar, LoRAs y más.

Para obtener más información sobre cómo cargar los pesos de LoRA, consulte la guía de carga de LoRA.

RFD4ProteinaLoraLoaderMixin

clase diffusers.loaders.RFD4ProteinaLoraLoaderMixin

< >

( )

Carga las capas LoRA en RFD4ProteinaTransformer.

El autoencoder se empareja con el punto de control del desruidor y no se adapta, por lo que el transformador es el único módulo que se puede cargar.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

LoraBaseMixin

clase diffusers.loaders.lora_base.LoraBaseMixin

< >

( )

Clase de utilidad para gestionar LoRAs.

delete_adapters

< >

( adapter_names: list[str] | str )

Parámetros

  • adapter_names (list[str, str]) — Los nombres de los adaptadores que se van a eliminar.

Eliminar las capas LoRA de un adaptador de la canalización.

Ejemplo:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_names="cinematic"
)
pipeline.delete_adapters("cinematic")

disable_lora

< >

( )

Desactiva las capas LoRA activas del pipeline.

Ejemplo:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_name="cinematic"
)
pipeline.disable_lora()

enable_lora

< >

( )

Habilita las capas LoRA activas del pipeline.

Ejemplo:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_name="cinematic"
)
pipeline.enable_lora()

enable_lora_hotswap

< >

( **kwargs )

Parámetros

  • target_rank (int) — El rango más alto entre todos los adaptadores que se cargarán.
  • check_compiled (str, opcional, por defecto "error") — Cómo manejar un modelo que ya está compilado. La comprobación puede devolver los siguientes mensajes:
    • “error” (predeterminado): lanza un error
    • “warn”: emitir una advertencia
    • “ignore”: no hacer nada

Intercambia adaptadores sin provocar la recompilación de un modelo o si los rangos de los adaptadores cargados son diferentes.

fuse_lora

< >

( components: list[str] | None = Nonelora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Parámetros

  • components — (list[str]): lista de componentes inyectables con LoRA en los que fusionar los LoRAs.
  • lora_scale (float, por defecto 1.0) — Controla cuánto influyen los parámetros de LoRA en las salidas.
  • safe_fusing (bool, por defecto False) — Si se deben comprobar los pesos fusionados en busca de valores NaN antes de fusionarlos y, si los valores son NaN, no fusionarlos.
  • adapter_names (list[str], opcional) — Nombres de los adaptadores que se usarán para la fusión. Si no se pasa nada, se fusionarán todos los adaptadores activos.

Fusiona los parámetros de LoRA en los parámetros originales de los bloques correspondientes.

Ejemplo:

from diffusers import DiffusionPipeline
import torch

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights("nerijs/pixel-art-xl", weight_name="pixel-art-xl.safetensors", adapter_name="pixel")
pipeline.fuse_lora(lora_scale=0.7)

get_active_adapters

< >

( )

Obtiene la lista de los adaptadores activos actuales.

Ejemplo:

from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
).to("cuda")
pipeline.load_lora_weights("CiroN2022/toy-face", weight_name="toy_face_sdxl.safetensors", adapter_name="toy")
pipeline.get_active_adapters()

get_list_adapters

< >

( )

Obtiene la lista actual de todos los adaptadores disponibles en el pipeline.

set_adapters

< >

( adapter_names: list[str] | stradapter_weights: float | dict[str, float | dict | None] | list[float | dict[str, float | dict | None] | None] | None = None )

Parámetros

  • adapter_names (list[str] o str) — Los nombres de los adaptadores a utilizar.
  • adapter_weights (float, dict o list, opcional) — Pesos para los adaptadores. Un escalar escala todos los componentes compatibles con LoRA. Un diccionario asigna nombres de componentes (p. ej. "unet", "transformer" o "text_encoder") a pesos; el peso de un componente UNet también puede ser un diccionario anidado de escalas de bloques. Un solo escalar o diccionario se aplica a cada adaptador. Una lista debe contener un escalar, diccionario o None por adaptador, en el orden de adapter_names. None toma por defecto 1.0, incluidas las entradas de la lista y los pesos de los componentes. Los componentes no especificados y los bloques de UNet también toman por defecto 1.0.

Establece los adaptadores actualmente activos para su uso en la tubería.

Ejemplo:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_name="cinematic"
)
pipeline.load_lora_weights(
    "troveski/sdxl-lora", weight_name="pytorch_lora_weights.safetensors", adapter_name="illustration"
)
pipeline.set_adapters(["cinematic", "illustration"], adapter_weights=[0.5, 0.5])
pipeline.set_adapters(
    ["cinematic", "illustration"],
    adapter_weights=[{"unet": 0.5}, {"unet": 0.8, "text_encoder": 0.6}],
)

set_lora_device

< >

( adapter_names: list[str]device: torch.device | str | int )

Parámetros

  • adapter_names (list[str]) — lista de adaptadores para enviar al dispositivo.
  • device (torch.device | str | int) — Dispositivo al que se enviarán los adaptadores. Puede ser un dispositivo de torch, un str o un entero.

Mueve los LoRA enumerados en adapter_names a un dispositivo de destino. Útil para descargar el LoRA a la CPU en caso de que quieras cargar varios adaptadores y liberar algo de memoria de GPU.

Tras descargar los adaptadores LoRA a la CPU, mientras el resto del modelo siga en la GPU, los adaptadores LoRA ya no pueden usarse para inferencia, ya que eso causaría una incompatibilidad de dispositivos. Recuerde establecer el dispositivo de nuevo en la GPU antes de usar esos adaptadores LoRA para inferencia.

>>> pipe.load_lora_weights(path_1, adapter_name="adapter-1")
>>> pipe.load_lora_weights(path_2, adapter_name="adapter-2")
>>> pipe.set_adapters("adapter-1")
>>> image_1 = pipe(**kwargs)
>>> # switch to adapter-2, offload adapter-1
>>> pipeline.set_lora_device(adapter_names=["adapter-1"], device="cpu")
>>> pipeline.set_lora_device(adapter_names=["adapter-2"], device="cuda:0")
>>> pipe.set_adapters("adapter-2")
>>> image_2 = pipe(**kwargs)
>>> # switch back to adapter-1, offload adapter-2
>>> pipeline.set_lora_device(adapter_names=["adapter-2"], device="cpu")
>>> pipeline.set_lora_device(adapter_names=["adapter-1"], device="cuda:0")
>>> pipe.set_adapters("adapter-1")
>>> ...

unfuse_lora

< >

( components: list[str] | None = None**kwargs )

Parámetros

  • components (list[str]) — lista de componentes inyectables con LoRA desde los que desvincular LoRA.
  • unfuse_unet (bool, por defecto True) — Si se deben desfusionar los parámetros LoRA del UNet.
  • unfuse_text_encoder (bool, por defecto True) — Si se deben desfusionar los parámetros LoRA del codificador de texto. Si el codificador de texto no fue parcheado con los parámetros LoRA, no tendrá ningún efecto.

Revierte el efecto de pipe.fuse_lora().

unload_lora_weights

< >

( )

Descarga los parámetros de LoRA.

Ejemplos:

>>> # Assuming `pipeline` is already loaded with the LoRA parameters.
>>> pipeline.unload_lora_weights()
>>> ...

write_lora_layers

< >

( state_dict: dict[str, torch.Tensor]save_directory: stris_main_process: boolweight_name: strsave_function: Callablesafe_serialization: boollora_adapter_metadata: dict | None = None )

Escribe el state dict de las capas LoRA (opcionalmente con metadatos) en el disco.

StableDiffusionLoraLoaderMixin

clase diffusers.loaders.StableDiffusionLoraLoaderMixin

< >

( )

Carga las capas LoRA en el UNet2DConditionModel y el CLIPTextModel de Stable Diffusion.

load_lora_into_text_encoder

< >

( state_dictnetwork_alphastext_encoderprefix = Nonelora_scale = 1.0adapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Parámetros

  • state_dict (dict) — Un state dict estándar que contiene los parámetros de las capas lora. La clave debe tener un prefijo adicional de text_encoder para distinguirlas de las capas lora de unet.
  • network_alphas (dict[str, float]) — El valor de la alfa de la red utilizado para un aprendizaje estable y para evitar el underflow. Este valor tiene el mismo significado que la opción --network_alpha en el script de entrenamiento de kohya-ss. Consulte este enlace.
  • text_encoder (CLIPTextModel) — El modelo de codificador de texto en el que se cargarán las capas LoRA.
  • prefix (str) — Prefijo esperado del text_encoder en el state_dict.
  • lora_scale (float) — En qué medida se escala la salida de la capa lineal lora antes de sumarla a la salida de la capa lora regular.
  • 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) — Vea load_lora_weights().
  • metadata (dict) — Metadatos opcionales del adaptador LoRA. Si se proporcionan, los argumentos de LoraConfig de peft no se derivarán del state dict.

Esto cargará las capas LoRA especificadas en state_dict en text_encoder

load_lora_into_unet

< >

( state_dictnetwork_alphasunetadapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Parámetros

  • state_dict (dict) — Un state dict estándar que contiene los parámetros de las capas lora. Las claves pueden indexarse directamente en el unet o tener un prefijo adicional unet, que se puede usar para distinguir entre las capas lora del codificador de texto.
  • network_alphas (dict[str, float]) — El valor de la alfa de la red utilizado para un aprendizaje estable y para evitar el underflow. Este valor tiene el mismo significado que la opción --network_alpha en el script de entrenamiento de kohya-ss. Consulte este enlace.
  • unet (UNet2DConditionModel) — El modelo UNet en el que se cargarán las capas LoRA.
  • 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 sin inicializar los pesos aleatorios.
  • hotswap (bool, opcional) — Vea load_lora_weights().
  • metadata (dict) — Metadatos opcionales del adaptador LoRA. Si se proporcionan, los argumentos de LoraConfig de peft no se derivarán del state dict.

Esto cargará las capas LoRA especificadas en state_dict en unet.

load_lora_weights

< >

( 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 (str o os.PathLike o dict) — 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 es False. 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 hotswap es que, cuando el modelo se compila con torch.compile, la carga del nuevo adaptador no requiere recompilar el modelo. Al usar hotswap, el adapter_name debe ser el nombre de un adaptador ya cargado. Si el nuevo adaptador y el antiguo tienen rangos y/o alphas de LoRA (es decir, escalado) diferentes, es necesario llamar a un método adicional antes de cargar el adaptador: pipeline = ... # carga el pipeline de diffusers max_rank = ... # el rango más alto entre todos los LoRAs que se desean cargar # llamar *antes* de compilar y cargar el adaptador LoRA pipeline.enable_lora_hotswap(target_rank=max_rank) pipeline.load_lora_weights(file_name) # opcionalmente, compilar el modelo ahora Tenga en cuenta que el hotswap de adaptadores del codificador de texto aún no se admite. Esta técnica tiene algunas limitaciones adicionales, documentadas aquí: https://huggingface.co/docs/peft/main/en/package_reference/hotswap

    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:

    pipeline = ...  # load diffusers pipeline
    max_rank = ...  # the highest rank among all LoRAs that you want to load
    # call *before* compiling and loading the LoRA adapter
    pipeline.enable_lora_hotswap(target_rank=max_rank)
    pipeline.load_lora_weights(file_name)
    # optionally compile the model now

    Tenga en cuenta que el intercambio en caliente de adaptadores del codificador de texto aún no es compatible. Esta técnica tiene algunas limitaciones adicionales, que se documentan aquí: https://huggingface.co/docs/peft/main/en/package_reference/hotswap

  • kwargs (dict, opcional) — Vea lora_state_dict().

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.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Parámetros

  • pretrained_model_name_or_path_or_dict (str o os.PathLike o dict) — Puede ser:
    • Una cadena de texto, el model id (por ejemplo, google/ddpm-celebahq-256) de un modelo preentrenado alojado en el Hub.
    • Una ruta a un directorio (por ejemplo, ./my_model_directory) que contiene los pesos del modelo guardados con ModelMixin.save_pretrained().
    • Un diccionario de estado de torch.
  • 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 predeterminado False) — 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 predeterminado False) — Indica si se deben cargar únicamente los pesos y archivos de configuración del modelo locales. Si se establece en True, el modelo no se descargará desde el Hub.
  • token (str o bool, opcional) — El token que se usará como autorización HTTP bearer para los archivos remotos. Si True, se utiliza el token generado desde diffusers-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.
  • weight_name (str, opcional, predeterminado a None) — Nombre del archivo de state dict serializado.
  • return_lora_metadata (bool, opcional, predeterminado en False) — Cuando está habilitado, devuelve además los metadatos del adaptador LoRA, que normalmente se encuentran en el state dict.

Devuelve el diccionario de estado para los pesos de lora y las alfas de la red.

> Admitimos la carga de puntos de control LoRA con formato A1111 de forma limitada. > > Esta función es experimental y podría cambiar en el futuro.

save_lora_weights

< >

( save_directory: str | os.PathLikeunet_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Nonetext_encoder_lora_layers: dict[str, torch.nn.Module] = 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 (str o os.PathLike) — Directorio donde se guardarán los parámetros de LoRA. Se creará si no existe.
  • unet_lora_layers (dict[str, torch.nn.Module] o dict[str, torch.Tensor]) — State dict de las capas LoRA correspondientes al unet.
  • text_encoder_lora_layers (dict[str, torch.nn.Module] o dict[str, torch.Tensor]) — State dict de las capas LoRA correspondientes al text_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 predeterminado True) — 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, establezca is_main_process=True solo 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 reemplazar torch.save con otro método. Puede configurarse con la variable de entorno DIFFUSERS_SAVE_MODE.
  • safe_serialization (bool, opcional, valor predeterminado True) — Si se guarda el modelo usando safetensors o de la forma tradicional de PyTorch con pickle.
  • 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.

StableDiffusionXLLoraLoaderMixin

clase diffusers.loaders.StableDiffusionXLLoraLoaderMixin

< >

( )

Carga las capas LoRA en el UNet2DConditionModel, el CLIPTextModel y el CLIPTextModelWithProjection de Stable Diffusion XL.

fuse_lora

< >

( components: list[str] = ['unet', 'text_encoder', 'text_encoder_2']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_text_encoder

< >

( state_dictnetwork_alphastext_encoderprefix = Nonelora_scale = 1.0adapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Parámetros

  • state_dict (dict) — Un state dict estándar que contiene los parámetros de las capas lora. La clave debe tener un prefijo adicional de text_encoder para distinguirlas de las capas lora de unet.
  • network_alphas (dict[str, float]) — El valor de la alfa de la red utilizado para un aprendizaje estable y para evitar el underflow. Este valor tiene el mismo significado que la opción --network_alpha en el script de entrenamiento de kohya-ss. Consulte este enlace.
  • text_encoder (CLIPTextModel) — El modelo de codificador de texto en el que se cargarán las capas LoRA.
  • prefix (str) — Prefijo esperado del text_encoder en el state_dict.
  • lora_scale (float) — En qué medida se escala la salida de la capa lineal lora antes de sumarla a la salida de la capa lora regular.
  • 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) — Vea load_lora_weights().
  • metadata (dict) — Metadatos opcionales del adaptador LoRA. Si se proporcionan, los argumentos de LoraConfig de peft no se derivarán del state dict.

Esto cargará las capas LoRA especificadas en state_dict en text_encoder

load_lora_into_unet

< >

( state_dictnetwork_alphasunetadapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Parámetros

  • state_dict (dict) — Un state dict estándar que contiene los parámetros de las capas lora. Las claves pueden indexarse directamente en el unet o tener un prefijo adicional unet, que se puede usar para distinguir entre las capas lora del codificador de texto.
  • network_alphas (dict[str, float]) — El valor de la alfa de la red utilizado para un aprendizaje estable y para evitar el underflow. Este valor tiene el mismo significado que la opción --network_alpha en el script de entrenamiento de kohya-ss. Consulte este enlace.
  • unet (UNet2DConditionModel) — El modelo UNet en el que se cargarán las capas LoRA.
  • 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 sin inicializar los pesos aleatorios.
  • hotswap (bool, opcional) — Vea load_lora_weights().
  • metadata (dict) — Metadatos opcionales del adaptador LoRA. Si se proporcionan, los argumentos de LoraConfig de peft no se derivarán del state dict.

Esto cargará las capas LoRA especificadas en state_dict en unet.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Parámetros

  • pretrained_model_name_or_path_or_dict (str o os.PathLike o dict) — Puede ser:
    • Una cadena de texto, el model id (por ejemplo, google/ddpm-celebahq-256) de un modelo preentrenado alojado en el Hub.
    • Una ruta a un directorio (por ejemplo, ./my_model_directory) que contiene los pesos del modelo guardados con ModelMixin.save_pretrained().
    • Un diccionario de estado de torch.
  • 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 predeterminado False) — 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 predeterminado False) — Indica si se deben cargar únicamente los pesos y archivos de configuración del modelo locales. Si se establece en True, el modelo no se descargará desde el Hub.
  • token (str o bool, opcional) — El token que se usará como autorización HTTP bearer para los archivos remotos. Si True, se utiliza el token generado desde diffusers-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.
  • weight_name (str, opcional, predeterminado a None) — Nombre del archivo de state dict serializado.
  • return_lora_metadata (bool, opcional, predeterminado en False) — Cuando está habilitado, devuelve además los metadatos del adaptador LoRA, que normalmente se encuentran en el state dict.

Devuelve el diccionario de estado para los pesos de lora y las alfas de la red.

> Admitimos la carga de puntos de control LoRA con formato A1111 de forma limitada. > > Esta función es experimental y podría cambiar en el futuro.

save_lora_weights

< >

( save_directory: str | os.PathLikeunet_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Nonetext_encoder_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Nonetext_encoder_2_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Trueunet_lora_adapter_metadata = Nonetext_encoder_lora_adapter_metadata = Nonetext_encoder_2_lora_adapter_metadata = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['unet', 'text_encoder', 'text_encoder_2']**kwargs )

Consulte unfuse_lora() para más detalles.

SD3LoraLoaderMixin

clase diffusers.loaders.SD3LoraLoaderMixin

< >

( )

Carga las capas LoRA en SD3Transformer2DModel, CLIPTextModel y CLIPTextModelWithProjection.

Específico de StableDiffusion3Pipeline.

fuse_lora

< >

( components: list[str] = ['transformer', 'text_encoder', 'text_encoder_2']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_text_encoder

< >

( state_dictnetwork_alphastext_encoderprefix = Nonelora_scale = 1.0adapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Parámetros

  • state_dict (dict) — Un state dict estándar que contiene los parámetros de las capas lora. La clave debe tener un prefijo adicional de text_encoder para distinguirlas de las capas lora de unet.
  • network_alphas (dict[str, float]) — El valor de la alfa de la red utilizado para un aprendizaje estable y para evitar el underflow. Este valor tiene el mismo significado que la opción --network_alpha en el script de entrenamiento de kohya-ss. Consulte este enlace.
  • text_encoder (CLIPTextModel) — El modelo de codificador de texto en el que se cargarán las capas LoRA.
  • prefix (str) — Prefijo esperado del text_encoder en el state_dict.
  • lora_scale (float) — En qué medida se escala la salida de la capa lineal lora antes de sumarla a la salida de la capa lora regular.
  • 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) — Vea load_lora_weights().
  • metadata (dict) — Metadatos opcionales del adaptador LoRA. Si se proporcionan, los argumentos de LoraConfig de peft no se derivarán del state dict.

Esto cargará las capas LoRA especificadas en state_dict en text_encoder

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Nonetext_encoder_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Nonetext_encoder_2_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata = Nonetext_encoder_lora_adapter_metadata = Nonetext_encoder_2_lora_adapter_metadata = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer', 'text_encoder', 'text_encoder_2']**kwargs )

Consulte unfuse_lora() para más detalles.

FluxLoraLoaderMixin

clase diffusers.loaders.FluxLoraLoaderMixin

< >

( )

Carga las capas LoRA en FluxTransformer2DModel, CLIPTextModel.

Específico de FluxPipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte lora_state_dict() para obtener más detalles.

load_lora_into_text_encoder

< >

( state_dictnetwork_alphastext_encoderprefix = Nonelora_scale = 1.0adapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Parámetros

  • state_dict (dict) — Un state dict estándar que contiene los parámetros de las capas lora. La clave debe tener un prefijo adicional de text_encoder para distinguirlas de las capas lora de unet.
  • network_alphas (dict[str, float]) — El valor de la alfa de la red utilizado para un aprendizaje estable y para evitar el underflow. Este valor tiene el mismo significado que la opción --network_alpha en el script de entrenamiento de kohya-ss. Consulte este enlace.
  • text_encoder (CLIPTextModel) — El modelo de codificador de texto en el que se cargarán las capas LoRA.
  • prefix (str) — Prefijo esperado del text_encoder en el state_dict.
  • lora_scale (float) — En qué medida se escala la salida de la capa lineal lora antes de sumarla a la salida de la capa lora regular.
  • 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) — Vea load_lora_weights().
  • metadata (dict) — Metadatos opcionales del adaptador LoRA. Si se proporcionan, los argumentos de LoraConfig de peft no se derivarán del state dict.

Esto cargará las capas LoRA especificadas en state_dict en text_encoder

load_lora_into_transformer

< >

( state_dictnetwork_alphastransformeradapter_name = Nonemetadata = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = False )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]return_alphas: bool = False**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Nonetext_encoder_lora_layers: dict[str, torch.nn.Module] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata = Nonetext_encoder_lora_adapter_metadata = None )

Parámetros

  • save_directory (str o os.PathLike) — Directorio donde se guardarán los parámetros de LoRA. Se creará si no existe.
  • transformer_lora_layers (dict[str, torch.nn.Module] o dict[str, torch.Tensor]) — State dict de las capas LoRA correspondientes al transformer.
  • text_encoder_lora_layers (dict[str, torch.nn.Module] o dict[str, torch.Tensor]) — State dict de las capas LoRA correspondientes al text_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 predeterminado True) — 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, establezca is_main_process=True solo 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 reemplazar torch.save con otro método. Puede configurarse con la variable de entorno DIFFUSERS_SAVE_MODE.
  • safe_serialization (bool, opcional, valor predeterminado True) — Si se guarda el modelo usando safetensors o de la forma tradicional de PyTorch con pickle.
  • transformer_lora_adapter_metadata — Metadatos del adaptador LoRA asociados con el transformer que se serializarán junto 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.

unfuse_lora

< >

( components: list[str] = ['transformer', 'text_encoder']**kwargs )

Parámetros

  • components (list[str]) — lista de componentes inyectables con LoRA desde los que desvincular LoRA.

Revierte el efecto de pipe.fuse_lora().

unload_lora_weights

< >

( reset_to_overwritten_params = False )

Parámetros

  • reset_to_overwritten_params (bool, por defecto False) — Si se deben restablecer los módulos cargados con LoRA a sus parámetros originales. Consulte la documentación de Flux para obtener más información.

Descarga los parámetros de LoRA.

Ejemplos:

>>> # Assuming `pipeline` is already loaded with the LoRA parameters.
>>> pipeline.unload_lora_weights()
>>> ...

Flux2LoraLoaderMixin

clase diffusers.loaders.Flux2LoraLoaderMixin

< >

( )

Carga las capas LoRA en Flux2Transformer2DModel. Específico de Flux2Pipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

Flux3LoraLoaderMixin

clase diffusers.loaders.Flux3LoraLoaderMixin

< >

( )

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

BriaFibo2LoraLoaderMixin

clase diffusers.loaders.BriaFibo2LoraLoaderMixin

< >

( )

Carga las capas LoRA en BriaFibo2Transformer2DModel. Específico de BriaFibo2Pipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

ErnieImageLoraLoaderMixin

clase diffusers.loaders.ErnieImageLoraLoaderMixin

< >

( )

Carga las capas LoRA en ErnieImageTransformer2DModel. Específico de ErnieImagePipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

LTX2LoraLoaderMixin

clase diffusers.loaders.LTX2LoraLoaderMixin

< >

( )

Carga las capas LoRA en LTX2VideoTransformer3DModel. Específico de LTX2Pipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = Noneprefix: str = 'transformer' )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

CogVideoXLoraLoaderMixin

clase diffusers.loaders.CogVideoXLoraLoaderMixin

< >

( )

Carga las capas LoRA en CogVideoXTransformer3DModel. Específico de CogVideoXPipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

Mochi1LoraLoaderMixin

clase diffusers.loaders.Mochi1LoraLoaderMixin

< >

( )

Carga las capas LoRA en MochiTransformer3DModel. Específico de MochiPipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

AuraFlowLoraLoaderMixin

clase diffusers.loaders.AuraFlowLoraLoaderMixin

< >

( )

Carga las capas LoRA en AuraFlowTransformer2DModel Específico de AuraFlowPipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer', 'text_encoder']**kwargs )

Consulte unfuse_lora() para más detalles.

LTXVideoLoraLoaderMixin

clase diffusers.loaders.LTXVideoLoraLoaderMixin

< >

( )

Carga las capas LoRA en LTXVideoTransformer3DModel. Específico de LTXPipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

SanaLoraLoaderMixin

clase diffusers.loaders.SanaLoraLoaderMixin

< >

( )

Carga las capas LoRA en SanaTransformer2DModel. Específico de SanaPipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

HeliosLoraLoaderMixin

clase diffusers.loaders.HeliosLoraLoaderMixin

< >

( )

Carga las capas LoRA en HeliosTransformer3DModel. Específico de HeliosPipeline y HeliosPyramidPipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

HunyuanVideoLoraLoaderMixin

clase diffusers.loaders.HunyuanVideoLoraLoaderMixin

< >

( )

Carga las capas LoRA en HunyuanVideoTransformer3DModel. Específico de HunyuanVideoPipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

Lumina2LoraLoaderMixin

clase diffusers.loaders.Lumina2LoraLoaderMixin

< >

( )

Carga las capas LoRA en Lumina2Transformer2DModel. Específico de Lumina2Pipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

CogView4LoraLoaderMixin

clase diffusers.loaders.CogView4LoraLoaderMixin

< >

( )

Carga las capas LoRA en WanTransformer3DModel. Específico de CogView4Pipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

WanLoraLoaderMixin

clase diffusers.loaders.WanLoraLoaderMixin

< >

( )

Carga las capas LoRA en WanTransformer3DModel. Específico de WanPipeline y [WanImageToVideoPipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

SkyReelsV2LoraLoaderMixin

clase diffusers.loaders.SkyReelsV2LoraLoaderMixin

< >

( )

Carga las capas LoRA en SkyReelsV2Transformer3DModel.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

AmusedLoraLoaderMixin

clase diffusers.loaders.AmusedLoraLoaderMixin

< >

( )

load_lora_into_transformer

< >

( state_dictnetwork_alphastransformeradapter_name = Nonemetadata = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = False )

Consulte load_lora_into_unet() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketext_encoder_lora_layers: dict[str, torch.nn.Module] = Nonetransformer_lora_layers: dict[str, torch.nn.Module] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = True )

Parámetros

  • save_directory (str o os.PathLike) — Directorio donde se guardarán los parámetros de LoRA. Se creará si no existe.
  • unet_lora_layers (dict[str, torch.nn.Module] o dict[str, torch.Tensor]) — State dict de las capas LoRA correspondientes al unet.
  • text_encoder_lora_layers (dict[str, torch.nn.Module] o dict[str, torch.Tensor]) — State dict de las capas LoRA correspondientes al text_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 predeterminado True) — 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, establezca is_main_process=True solo 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 reemplazar torch.save con otro método. Puede configurarse con la variable de entorno DIFFUSERS_SAVE_MODE.
  • safe_serialization (bool, opcional, valor predeterminado True) — Si se guarda el modelo usando safetensors o de la forma tradicional de PyTorch con pickle.

Guarde los parámetros de LoRA correspondientes al UNet y al codificador de texto.

AnimaLoraLoaderMixin

clase diffusers.loaders.AnimaLoraLoaderMixin

< >

( )

Carga las capas LoRA en CosmosTransformer3DModel y AnimaTextConditioner.

fuse_lora

< >

( components: list[str] = ['transformer', 'text_conditioner']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

unfuse_lora

< >

( components: list[str] = ['transformer', 'text_conditioner']**kwargs )

Consulte unfuse_lora() para más detalles.

AceStepLoraLoaderMixin

clase diffusers.loaders.AceStepLoraLoaderMixin

< >

( )

Carga las capas LoRA en AceStepTransformer1DModel. Específico de AceStepPipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

HiDreamImageLoraLoaderMixin

clase diffusers.loaders.HiDreamImageLoraLoaderMixin

< >

( )

Carga las capas LoRA en HiDreamImageTransformer2DModel. Específico de HiDreamImagePipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

QwenImageLoraLoaderMixin

clase diffusers.loaders.QwenImageLoraLoaderMixin

< >

( )

Carga las capas LoRA en QwenImageTransformer2DModel. Específico de QwenImagePipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

ZImageLoraLoaderMixin

clase diffusers.loaders.ZImageLoraLoaderMixin

< >

( )

Carga las capas LoRA en ZImageTransformer2DModel. Específico de ZImagePipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

CosmosLoraLoaderMixin

clase diffusers.loaders.CosmosLoraLoaderMixin

< >

( )

Carga las capas LoRA en CosmosTransformer3DModel, específico de Cosmos2_5_PredictBasePipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

KandinskyLoraLoaderMixin

clase diffusers.loaders.KandinskyLoraLoaderMixin

< >

( )

Carga las capas LoRA en Kandinsky5Transformer3DModel,

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

Ideogram4LoraLoaderMixin

clase diffusers.loaders.Ideogram4LoraLoaderMixin

< >

( )

Carga las capas LoRA en Ideogram4Transformer2DModel. Específico de Ideogram4Pipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

Krea2LoraLoaderMixin

clase diffusers.loaders.Krea2LoraLoaderMixin

< >

( )

Carga las capas LoRA en Krea2Transformer2DModel. Específico de Krea2Pipeline.

fuse_lora

< >

( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )

Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer']**kwargs )

Consulte unfuse_lora() para más detalles.

MiniMaxH3LoraLoaderMixin

clase diffusers.loaders.MiniMaxH3LoraLoaderMixin

< >

( )

Carga las capas LoRA en MiniMaxH3Transformer3DModel. Específico de MiniMaxH3ModularPipeline.

MiniMax-H3 incluye dos particiones DiT independientes con nombres de módulo idénticos (un LoRA para una se carga en la otra y degrada la salida), por lo que la enrutación es explícita: los state dicts convertidos apuntan a transformer.; se accede a transformer_ref con un archivo con el prefijo transformer_ref. o load_into_transformer_ref=True.

Los LoRA de DiffSynth-Studio (p. ej. DiffSynth-Studio/MiniMax-H3-LoRA-LineartAnime) se entrenan contra el QKV fusionado con intercalado por cabeza del checkpoint original y se desintercalan durante la conversión. Sus factores fp32 hacen que la ruta de LoRA no fusionada calcule en fp32; aplicar .to(torch.bfloat16) al modelo después de cargarlo restaura el presupuesto de memoria en bf16.

Los LoRAs entrenados contra un checkpoint podado (los archivos *_pruned_* en Comfy-Org/MiniMax-H3; joyfox/MiniMax-H3-Turbo es uno de ellos) fallan con un error de tamaño no coincidente. Los archivos sin alpha == rank se cargan con alpha == rank (escala 1.0, la convención declarada por, por ejemplo, larryvrh/MiniMax-H3-Turbo-Lora); una entrada de __metadata__ alpha (por ejemplo, el archivo de 8 pasos de lightx2v/Minimax-h3-Turbo), si está presente, se respeta en su lugar.

fuse_lora

< >

( components: list[str] = ['transformer', 'transformer_ref']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Consulte fuse_lora() para más detalles.

load_lora_into_transformer

< >

( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_into_transformer_ref

< >

( state_dicttransformer_refprefixadapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )

Carga las capas LoRA en la partición transformer_ref. prefix es el nombre del componente que llevan las claves, que es transformer_ref para un archivo que nombra la partición y transformer para uno enrutado aquí por load_into_transformer_ref=True. Consulta load_lora_into_unet() para más detalles.

load_lora_weights

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = Falseload_into_transformer_ref: bool = False**kwargs )

Parámetros

  • load_into_transformer_ref (bool, por defecto False) — Carga las capas con el prefijo transformer. en la partición transformer_ref, la que utiliza el flujo de trabajo ref2va para el denoising, en lugar de transformer. Solo es necesario cuando se cargan ambas particiones: un pipeline que solo mantiene transformer_ref enruta allí por sí solo.

Carga las capas LoRA en transformer o, con load_into_transformer_ref=True, en transformer_ref. Consulta load_lora_weights() para más detalles.

lora_state_dict

< >

( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights

< >

( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Nonetransformer_ref_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = Nonetransformer_ref_lora_adapter_metadata: dict | None = None )

Guarde las capas LoRA de una o ambas particiones de MiniMax-H3. No es posible determinar a qué partición pertenece un LoRA a partir de sus claves, por lo que esta es la única forma de publicar un LoRA de H3 que lo registre. Consulte save_lora_weights() para obtener más información.

unfuse_lora

< >

( components: list[str] = ['transformer', 'transformer_ref']**kwargs )

Consulte unfuse_lora() para más detalles.

PikaH3FlexLoraLoaderMixin

clase diffusers.loaders.PikaH3FlexLoraLoaderMixin

< >

( )

Carga las capas LoRA en MiniMaxH3Transformer3DModel. Específico de PikaH3FlexModularPipeline.

La versión Pika H3 Flex es un par de adaptadores de rango 128 sobre las dos particiones de transformador de MiniMax-H3, publicadas como volcados PEFT planos de los nombres de módulos de diffusers (fl2va/adapter.safetensors para transformer, ref2va/adapter.safetensors para transformer_ref). Los archivos sin alfa se cargan con alpha == rank (escala 1.0), el propio contrato de los adaptadores, y la carga, el enrutamiento y el guardado son los de MiniMaxH3LoraLoaderMixin: el adaptador fl2va va en transformer, y el adaptador ref2va en transformer_ref — por sí solo cuando el pipeline mantiene esa partición por separado (workflow="ref2va"), con load_into_transformer_ref=True cuando mantiene ambas.

pipe.load_lora_weights("Pika-Labs/Pika-H3-Flex", weight_name="fl2va/adapter.safetensors")

LoraBaseMixin

clase diffusers.loaders.lora_base.LoraBaseMixin

< >

( )

Clase de utilidad para gestionar LoRAs.

delete_adapters

< >

( adapter_names: list[str] | str )

Parámetros

  • adapter_names (list[str, str]) — Los nombres de los adaptadores que se van a eliminar.

Eliminar las capas LoRA de un adaptador de la canalización.

Ejemplo:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_names="cinematic"
)
pipeline.delete_adapters("cinematic")

disable_lora

< >

( )

Desactiva las capas LoRA activas del pipeline.

Ejemplo:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_name="cinematic"
)
pipeline.disable_lora()

enable_lora

< >

( )

Habilita las capas LoRA activas del pipeline.

Ejemplo:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_name="cinematic"
)
pipeline.enable_lora()

enable_lora_hotswap

< >

( **kwargs )

Parámetros

  • target_rank (int) — El rango más alto entre todos los adaptadores que se cargarán.
  • check_compiled (str, opcional, por defecto "error") — Cómo manejar un modelo que ya está compilado. La comprobación puede devolver los siguientes mensajes:
    • “error” (predeterminado): lanza un error
    • “warn”: emitir una advertencia
    • “ignore”: no hacer nada

Intercambia adaptadores sin provocar la recompilación de un modelo o si los rangos de los adaptadores cargados son diferentes.

fuse_lora

< >

( components: list[str] | None = Nonelora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )

Parámetros

  • components — (list[str]): lista de componentes inyectables con LoRA en los que fusionar los LoRAs.
  • lora_scale (float, por defecto 1.0) — Controla cuánto influyen los parámetros de LoRA en las salidas.
  • safe_fusing (bool, por defecto False) — Si se deben comprobar los pesos fusionados en busca de valores NaN antes de fusionarlos y, si los valores son NaN, no fusionarlos.
  • adapter_names (list[str], opcional) — Nombres de los adaptadores que se usarán para la fusión. Si no se pasa nada, se fusionarán todos los adaptadores activos.

Fusiona los parámetros de LoRA en los parámetros originales de los bloques correspondientes.

Ejemplo:

from diffusers import DiffusionPipeline
import torch

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights("nerijs/pixel-art-xl", weight_name="pixel-art-xl.safetensors", adapter_name="pixel")
pipeline.fuse_lora(lora_scale=0.7)

get_active_adapters

< >

( )

Obtiene la lista de los adaptadores activos actuales.

Ejemplo:

from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
).to("cuda")
pipeline.load_lora_weights("CiroN2022/toy-face", weight_name="toy_face_sdxl.safetensors", adapter_name="toy")
pipeline.get_active_adapters()

get_list_adapters

< >

( )

Obtiene la lista actual de todos los adaptadores disponibles en el pipeline.

set_adapters

< >

( adapter_names: list[str] | stradapter_weights: float | dict[str, float | dict | None] | list[float | dict[str, float | dict | None] | None] | None = None )

Parámetros

  • adapter_names (list[str] o str) — Los nombres de los adaptadores a utilizar.
  • adapter_weights (float, dict o list, opcional) — Pesos para los adaptadores. Un escalar escala todos los componentes compatibles con LoRA. Un diccionario asigna nombres de componentes (p. ej. "unet", "transformer" o "text_encoder") a pesos; el peso de un componente UNet también puede ser un diccionario anidado de escalas de bloques. Un solo escalar o diccionario se aplica a cada adaptador. Una lista debe contener un escalar, diccionario o None por adaptador, en el orden de adapter_names. None toma por defecto 1.0, incluidas las entradas de la lista y los pesos de los componentes. Los componentes no especificados y los bloques de UNet también toman por defecto 1.0.

Establece los adaptadores actualmente activos para su uso en la tubería.

Ejemplo:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_name="cinematic"
)
pipeline.load_lora_weights(
    "troveski/sdxl-lora", weight_name="pytorch_lora_weights.safetensors", adapter_name="illustration"
)
pipeline.set_adapters(["cinematic", "illustration"], adapter_weights=[0.5, 0.5])
pipeline.set_adapters(
    ["cinematic", "illustration"],
    adapter_weights=[{"unet": 0.5}, {"unet": 0.8, "text_encoder": 0.6}],
)

set_lora_device

< >

( adapter_names: list[str]device: torch.device | str | int )

Parámetros

  • adapter_names (list[str]) — lista de adaptadores para enviar al dispositivo.
  • device (torch.device | str | int) — Dispositivo al que se enviarán los adaptadores. Puede ser un dispositivo de torch, un str o un entero.

Mueve los LoRA enumerados en adapter_names a un dispositivo de destino. Útil para descargar el LoRA a la CPU en caso de que quieras cargar varios adaptadores y liberar algo de memoria de GPU.

Tras descargar los adaptadores LoRA a la CPU, mientras el resto del modelo siga en la GPU, los adaptadores LoRA ya no pueden usarse para inferencia, ya que eso causaría una incompatibilidad de dispositivos. Recuerde establecer el dispositivo de nuevo en la GPU antes de usar esos adaptadores LoRA para inferencia.

>>> pipe.load_lora_weights(path_1, adapter_name="adapter-1")
>>> pipe.load_lora_weights(path_2, adapter_name="adapter-2")
>>> pipe.set_adapters("adapter-1")
>>> image_1 = pipe(**kwargs)
>>> # switch to adapter-2, offload adapter-1
>>> pipeline.set_lora_device(adapter_names=["adapter-1"], device="cpu")
>>> pipeline.set_lora_device(adapter_names=["adapter-2"], device="cuda:0")
>>> pipe.set_adapters("adapter-2")
>>> image_2 = pipe(**kwargs)
>>> # switch back to adapter-1, offload adapter-2
>>> pipeline.set_lora_device(adapter_names=["adapter-2"], device="cpu")
>>> pipeline.set_lora_device(adapter_names=["adapter-1"], device="cuda:0")
>>> pipe.set_adapters("adapter-1")
>>> ...

unfuse_lora

< >

( components: list[str] | None = None**kwargs )

Parámetros

  • components (list[str]) — lista de componentes inyectables con LoRA desde los que desvincular LoRA.
  • unfuse_unet (bool, por defecto True) — Si se deben desfusionar los parámetros LoRA del UNet.
  • unfuse_text_encoder (bool, por defecto True) — Si se deben desfusionar los parámetros LoRA del codificador de texto. Si el codificador de texto no fue parcheado con los parámetros LoRA, no tendrá ningún efecto.

Revierte el efecto de pipe.fuse_lora().

unload_lora_weights

< >

( )

Descarga los parámetros de LoRA.

Ejemplos:

>>> # Assuming `pipeline` is already loaded with the LoRA parameters.
>>> pipeline.unload_lora_weights()
>>> ...

write_lora_layers

< >

( state_dict: dict[str, torch.Tensor]save_directory: stris_main_process: boolweight_name: strsave_function: Callablesafe_serialization: boollora_adapter_metadata: dict | None = None )

Escribe el state dict de las capas LoRA (opcionalmente con metadatos) en el disco.

Update on GitHub