diffusers/v0.43.0/es/api/loaders/lora.md

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[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin]]

diffusers.loaders.RFD4ProteinaLoraLoaderMixin[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin]]

diffusers.loaders.RFD4ProteinaLoraLoaderMixin()

Fuente

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 cargable.

fuse_lora[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]

diffusers.loaders.lora_base.LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]

diffusers.loaders.lora_base.LoraBaseMixin()

Fuente

Clase de utilidad para gestionar LoRAs.

delete_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.delete_adapters]]

delete_adapters(adapter_names: list[str] | str)

Fuente

Parámetros:

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

Eliminar las capas LoRA de un adaptador 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_names="cinematic"
)
pipeline.delete_adapters("cinematic")

disable_lora[[diffusers.loaders.lora_base.LoraBaseMixin.disable_lora]]

disable_lora()

Fuente

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[[diffusers.loaders.lora_base.LoraBaseMixin.enable_lora]]

enable_lora()

Fuente

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[[diffusers.loaders.lora_base.LoraBaseMixin.enable_lora_hotswap]]

enable_lora_hotswap(**kwargs)

Fuente

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" (por defecto): lanza un error - "warn": emite una advertencia - "ignore": no hace nada

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

fuse_lora[[diffusers.loaders.lora_base.LoraBaseMixin.fuse_lora]]

fuse_lora(components: list[str] | None = None, lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Fuente

Parámetros:

components : (list[str]): lista de componentes inyectables con LoRA en los que fusionar los LoRA.

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[[diffusers.loaders.lora_base.LoraBaseMixin.get_active_adapters]]

get_active_adapters()

Fuente

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[[diffusers.loaders.lora_base.LoraBaseMixin.get_list_adapters]]

get_list_adapters()

Fuente

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

set_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.set_adapters]]

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

Fuente

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, un 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 y bloques UNet no especificados 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[[diffusers.loaders.lora_base.LoraBaseMixin.set_lora_device]]

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

Fuente

Parámetros:

adapter_names (list[str]) : lista de adaptadores a los que enviar el 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 si deseas 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 provocarí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[[diffusers.loaders.lora_base.LoraBaseMixin.unfuse_lora]]

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

Fuente

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 desvincular los parámetros LoRA del UNet.

unfuse_text_encoder (bool, por defecto True) : Si se deben desvincular 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[[diffusers.loaders.lora_base.LoraBaseMixin.unload_lora_weights]]

unload_lora_weights()

Fuente

Descarga los parámetros de LoRA.

Ejemplos:

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

write_lora_layers[[diffusers.loaders.lora_base.LoraBaseMixin.write_lora_layers]]

write_lora_layers(state_dict: dict[str, torch.Tensor], save_directory: str, is_main_process: bool, weight_name: str, save_function: Callable, safe_serialization: bool, lora_adapter_metadata: dict | None = None)

Fuente

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

StableDiffusionLoraLoaderMixin[[diffusers.loaders.StableDiffusionLoraLoaderMixin]]

diffusers.loaders.StableDiffusionLoraLoaderMixin[[diffusers.loaders.StableDiffusionLoraLoaderMixin]]

diffusers.loaders.StableDiffusionLoraLoaderMixin()

Fuente

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

load_lora_into_text_encoder[[diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_text_encoder]]

load_lora_into_text_encoder(state_dict, network_alphas, text_encoder, prefix = None, lora_scale = 1.0, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Parámetros:

state_dict (dict) : Un state dict estándar que contiene los parámetros de las capas lora. La clave debe tener como prefijo adicional 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 subdesbordamiento. 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 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) : Cuánto escalar la salida de la capa lineal de lora antes de que se sume con 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) : Consulte load_lora_weights().

metadata (dict) : Metadatos opcionales del adaptador LoRA. Si se proporciona, 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[[diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet]]

load_lora_into_unet(state_dict, network_alphas, unet, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

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, lo que permite 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 subdesbordamiento. 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 no inicializando los pesos aleatorios.

hotswap (bool, opcional) : Consulte load_lora_weights().

metadata (dict) : Metadatos opcionales del adaptador LoRA. Si se proporciona, 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[[diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights]]

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

Fuente

Parámetros:

pretrained_model_name_or_path_or_dict (str o os.PathLike o dict) : Consulte 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) : El valor predeterminado es False. Indica si se debe sustituir un adaptador (LoRA) existente por el adaptador recién cargado in situ. 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 la recompilación del modelo. Al usar hotswapping, el adapter_name pasado debe ser el nombre de un adaptador ya cargado. Si el nuevo adaptador y el antiguo tienen rangos y/o alfas de LoRA (es decir, escalado) diferentes, es necesario llamar a un método adicional antes de cargar el adaptador: py 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 hotswapping de adaptadores del codificador de texto aún no se admite. Esta técnica tiene algunas limitaciones adicionales, que se documentan aquí: https://huggingface.co/docs/peft/main/en/package_reference/hotswap

kwargs (dict, opcional) : Consulte 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[[diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict]]

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

Fuente

Parámetros:

pretrained_model_name_or_path_or_dict (str o os.PathLike o dict) : Puede ser: - Una cadena, 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 torch state dict.

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, reemplazando 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 localmente. 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 archivos remotos. Si es True, se utiliza el token generado por 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, valor predeterminado "") : 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, valor predeterminado 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 experimental y podría cambiar en el futuro.

save_lora_weights[[diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, unet_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_lora_layers: dict[str, torch.nn.Module] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, unet_lora_adapter_metadata = None, text_encoder_lora_adapter_metadata = None)

Fuente

Parámetros:

save_directory (str o os.PathLike) : Directorio para guardar los parámetros de LoRA. Se creará si no existe.

unet_lora_layers (dict[str, torch.nn.Module] o dict[str, torch.Tensor]) : Diccionario de estado de las capas LoRA correspondientes al unet.

text_encoder_lora_layers (dict[str, torch.nn.Module] o dict[str, torch.Tensor]) : Diccionario de estado de las capas LoRA correspondiente al text_encoder. Debe pasar explícitamente el diccionario de estado 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 necesitas reemplazar torch.save con otro método. Se puede configurar con la variable de entorno DIFFUSERS_SAVE_MODE.

safe_serialization (bool, opcional, por defecto 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 van a serializar con el state dict.

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

StableDiffusionXLLoraLoaderMixin[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin]]

diffusers.loaders.StableDiffusionXLLoraLoaderMixin[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin]]

diffusers.loaders.StableDiffusionXLLoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_text_encoder[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_into_text_encoder]]

load_lora_into_text_encoder(state_dict, network_alphas, text_encoder, prefix = None, lora_scale = 1.0, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Parámetros:

state_dict (dict) : Un state dict estándar que contiene los parámetros de las capas lora. La clave debe tener como prefijo adicional 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 subdesbordamiento. 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 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) : Cuánto escalar la salida de la capa lineal de lora antes de que se sume con 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) : Consulte load_lora_weights().

metadata (dict) : Metadatos opcionales del adaptador LoRA. Si se proporciona, 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[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_into_unet]]

load_lora_into_unet(state_dict, network_alphas, unet, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

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, lo que permite 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 subdesbordamiento. 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 no inicializando los pesos aleatorios.

hotswap (bool, opcional) : Consulte load_lora_weights().

metadata (dict) : Metadatos opcionales del adaptador LoRA. Si se proporciona, 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[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.lora_state_dict]]

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

Fuente

Parámetros:

pretrained_model_name_or_path_or_dict (str o os.PathLike o dict) : Puede ser: - Una cadena, 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 torch state dict.

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, reemplazando 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 localmente. 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 archivos remotos. Si es True, se utiliza el token generado por 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, valor predeterminado "") : 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, valor predeterminado 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 experimental y podría cambiar en el futuro.

save_lora_weights[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, unet_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_2_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, unet_lora_adapter_metadata = None, text_encoder_lora_adapter_metadata = None, text_encoder_2_lora_adapter_metadata = None)

Fuente

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

unfuse_lora[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

SD3LoraLoaderMixin[[diffusers.loaders.SD3LoraLoaderMixin]]

diffusers.loaders.SD3LoraLoaderMixin[[diffusers.loaders.SD3LoraLoaderMixin]]

diffusers.loaders.SD3LoraLoaderMixin()

Fuente

Carga las capas LoRA en SD3Transformer2DModel, CLIPTextModel y CLIPTextModelWithProjection.

Específico de StableDiffusion3Pipeline.

fuse_lora[[diffusers.loaders.SD3LoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_text_encoder[[diffusers.loaders.SD3LoraLoaderMixin.load_lora_into_text_encoder]]

load_lora_into_text_encoder(state_dict, network_alphas, text_encoder, prefix = None, lora_scale = 1.0, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Parámetros:

state_dict (dict) : Un state dict estándar que contiene los parámetros de las capas lora. La clave debe tener como prefijo adicional 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 subdesbordamiento. 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 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) : Cuánto escalar la salida de la capa lineal de lora antes de que se sume con 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) : Consulte load_lora_weights().

metadata (dict) : Metadatos opcionales del adaptador LoRA. Si se proporciona, 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[[diffusers.loaders.SD3LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.SD3LoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.SD3LoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.SD3LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_2_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata = None, text_encoder_lora_adapter_metadata = None, text_encoder_2_lora_adapter_metadata = None)

Fuente

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

unfuse_lora[[diffusers.loaders.SD3LoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

FluxLoraLoaderMixin[[diffusers.loaders.FluxLoraLoaderMixin]]

diffusers.loaders.FluxLoraLoaderMixin[[diffusers.loaders.FluxLoraLoaderMixin]]

diffusers.loaders.FluxLoraLoaderMixin()

Fuente

Carga las capas LoRA en FluxTransformer2DModel, CLIPTextModel.

Específico de FluxPipeline.

fuse_lora[[diffusers.loaders.FluxLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

load_lora_into_text_encoder[[diffusers.loaders.FluxLoraLoaderMixin.load_lora_into_text_encoder]]

load_lora_into_text_encoder(state_dict, network_alphas, text_encoder, prefix = None, lora_scale = 1.0, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Parámetros:

state_dict (dict) : Un state dict estándar que contiene los parámetros de las capas lora. La clave debe tener como prefijo adicional 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 subdesbordamiento. 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 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) : Cuánto escalar la salida de la capa lineal de lora antes de que se sume con 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) : Consulte load_lora_weights().

metadata (dict) : Metadatos opcionales del adaptador LoRA. Si se proporciona, 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[[diffusers.loaders.FluxLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, network_alphas, transformer, adapter_name = None, metadata = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.FluxLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.FluxLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.FluxLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_lora_layers: dict[str, torch.nn.Module] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata = None, text_encoder_lora_adapter_metadata = None)

Fuente

Parámetros:

save_directory (str o os.PathLike) : Directorio para guardar los parámetros de LoRA. Se creará si no existe.

transformer_lora_layers (dict[str, torch.nn.Module] o dict[str, torch.Tensor]) : Diccionario de estado de las capas LoRA correspondiente al transformer.

text_encoder_lora_layers (dict[str, torch.nn.Module] o dict[str, torch.Tensor]) : Diccionario de estado de las capas LoRA correspondiente al text_encoder. Debe pasar explícitamente el diccionario de estado 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 necesitas reemplazar torch.save con otro método. Se puede configurar con la variable de entorno DIFFUSERS_SAVE_MODE.

safe_serialization (bool, opcional, por defecto 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 con el state dict.

text_encoder_lora_adapter_metadata : Metadatos del adaptador LoRA asociados con el codificador de texto que se van a serializar con el state dict.

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

unfuse_lora[[diffusers.loaders.FluxLoraLoaderMixin.unfuse_lora]]

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

Fuente

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[[diffusers.loaders.FluxLoraLoaderMixin.unload_lora_weights]]

unload_lora_weights(reset_to_overwritten_params = False)

Fuente

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[[diffusers.loaders.Flux2LoraLoaderMixin]]

diffusers.loaders.Flux2LoraLoaderMixin[[diffusers.loaders.Flux2LoraLoaderMixin]]

diffusers.loaders.Flux2LoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.Flux2LoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.Flux2LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.Flux2LoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.Flux2LoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.Flux2LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.Flux2LoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

Flux3LoraLoaderMixin[[diffusers.loaders.Flux3LoraLoaderMixin]]

diffusers.loaders.Flux3LoraLoaderMixin[[diffusers.loaders.Flux3LoraLoaderMixin]]

diffusers.loaders.Flux3LoraLoaderMixin()

Fuente

fuse_lora[[diffusers.loaders.Flux3LoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.Flux3LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.Flux3LoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

save_lora_weights[[diffusers.loaders.Flux3LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.Flux3LoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

BriaFibo2LoraLoaderMixin[[diffusers.loaders.BriaFibo2LoraLoaderMixin]]

diffusers.loaders.BriaFibo2LoraLoaderMixin[[diffusers.loaders.BriaFibo2LoraLoaderMixin]]

diffusers.loaders.BriaFibo2LoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.BriaFibo2LoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.BriaFibo2LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.BriaFibo2LoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.BriaFibo2LoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.BriaFibo2LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.BriaFibo2LoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

ErnieImageLoraLoaderMixin[[diffusers.loaders.ErnieImageLoraLoaderMixin]]

diffusers.loaders.ErnieImageLoraLoaderMixin[[diffusers.loaders.ErnieImageLoraLoaderMixin]]

diffusers.loaders.ErnieImageLoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.ErnieImageLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.ErnieImageLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.ErnieImageLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.ErnieImageLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.ErnieImageLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.ErnieImageLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

LTX2LoraLoaderMixin[[diffusers.loaders.LTX2LoraLoaderMixin]]

diffusers.loaders.LTX2LoraLoaderMixin[[diffusers.loaders.LTX2LoraLoaderMixin]]

diffusers.loaders.LTX2LoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.LTX2LoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.LTX2LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None, prefix: str = 'transformer')

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.LTX2LoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.LTX2LoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.LTX2LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.LTX2LoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

CogVideoXLoraLoaderMixin[[diffusers.loaders.CogVideoXLoraLoaderMixin]]

diffusers.loaders.CogVideoXLoraLoaderMixin[[diffusers.loaders.CogVideoXLoraLoaderMixin]]

diffusers.loaders.CogVideoXLoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.CogVideoXLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.CogVideoXLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.CogVideoXLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.CogVideoXLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.CogVideoXLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.CogVideoXLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

Mochi1LoraLoaderMixin[[diffusers.loaders.Mochi1LoraLoaderMixin]]

diffusers.loaders.Mochi1LoraLoaderMixin[[diffusers.loaders.Mochi1LoraLoaderMixin]]

diffusers.loaders.Mochi1LoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.Mochi1LoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.Mochi1LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.Mochi1LoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.Mochi1LoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.Mochi1LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.Mochi1LoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

AuraFlowLoraLoaderMixin[[diffusers.loaders.AuraFlowLoraLoaderMixin]]

diffusers.loaders.AuraFlowLoraLoaderMixin[[diffusers.loaders.AuraFlowLoraLoaderMixin]]

diffusers.loaders.AuraFlowLoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.AuraFlowLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.AuraFlowLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.AuraFlowLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.AuraFlowLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.AuraFlowLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.AuraFlowLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

LTXVideoLoraLoaderMixin[[diffusers.loaders.LTXVideoLoraLoaderMixin]]

diffusers.loaders.LTXVideoLoraLoaderMixin[[diffusers.loaders.LTXVideoLoraLoaderMixin]]

diffusers.loaders.LTXVideoLoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.LTXVideoLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.LTXVideoLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.LTXVideoLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.LTXVideoLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.LTXVideoLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.LTXVideoLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

SanaLoraLoaderMixin[[diffusers.loaders.SanaLoraLoaderMixin]]

diffusers.loaders.SanaLoraLoaderMixin[[diffusers.loaders.SanaLoraLoaderMixin]]

diffusers.loaders.SanaLoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.SanaLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.SanaLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.SanaLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.SanaLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.SanaLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.SanaLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

HeliosLoraLoaderMixin[[diffusers.loaders.HeliosLoraLoaderMixin]]

diffusers.loaders.HeliosLoraLoaderMixin[[diffusers.loaders.HeliosLoraLoaderMixin]]

diffusers.loaders.HeliosLoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.HeliosLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.HeliosLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.HeliosLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.HeliosLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.HeliosLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.HeliosLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

HunyuanVideoLoraLoaderMixin[[diffusers.loaders.HunyuanVideoLoraLoaderMixin]]

diffusers.loaders.HunyuanVideoLoraLoaderMixin[[diffusers.loaders.HunyuanVideoLoraLoaderMixin]]

diffusers.loaders.HunyuanVideoLoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

Lumina2LoraLoaderMixin[[diffusers.loaders.Lumina2LoraLoaderMixin]]

diffusers.loaders.Lumina2LoraLoaderMixin[[diffusers.loaders.Lumina2LoraLoaderMixin]]

diffusers.loaders.Lumina2LoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.Lumina2LoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.Lumina2LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.Lumina2LoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.Lumina2LoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.Lumina2LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.Lumina2LoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

CogView4LoraLoaderMixin[[diffusers.loaders.CogView4LoraLoaderMixin]]

diffusers.loaders.CogView4LoraLoaderMixin[[diffusers.loaders.CogView4LoraLoaderMixin]]

diffusers.loaders.CogView4LoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.CogView4LoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.CogView4LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.CogView4LoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.CogView4LoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.CogView4LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.CogView4LoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

WanLoraLoaderMixin[[diffusers.loaders.WanLoraLoaderMixin]]

diffusers.loaders.WanLoraLoaderMixin[[diffusers.loaders.WanLoraLoaderMixin]]

diffusers.loaders.WanLoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.WanLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.WanLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.WanLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.WanLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.WanLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.WanLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

SkyReelsV2LoraLoaderMixin[[diffusers.loaders.SkyReelsV2LoraLoaderMixin]]

diffusers.loaders.SkyReelsV2LoraLoaderMixin[[diffusers.loaders.SkyReelsV2LoraLoaderMixin]]

diffusers.loaders.SkyReelsV2LoraLoaderMixin()

Fuente

Carga las capas LoRA en SkyReelsV2Transformer3DModel.

fuse_lora[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

AmusedLoraLoaderMixin[[diffusers.loaders.AmusedLoraLoaderMixin]]

diffusers.loaders.AmusedLoraLoaderMixin[[diffusers.loaders.AmusedLoraLoaderMixin]]

diffusers.loaders.AmusedLoraLoaderMixin()

Fuente

load_lora_into_transformer[[diffusers.loaders.AmusedLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, network_alphas, transformer, adapter_name = None, metadata = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

save_lora_weights[[diffusers.loaders.AmusedLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, text_encoder_lora_layers: dict[str, torch.nn.Module] = None, transformer_lora_layers: dict[str, torch.nn.Module] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True)

Fuente

Parámetros:

save_directory (str o os.PathLike) : Directorio para guardar los parámetros de LoRA. Se creará si no existe.

unet_lora_layers (dict[str, torch.nn.Module] o dict[str, torch.Tensor]) : Diccionario de estado de las capas LoRA correspondientes al unet.

text_encoder_lora_layers (dict[str, torch.nn.Module] o dict[str, torch.Tensor]) : Diccionario de estado de las capas LoRA correspondiente al text_encoder. Debe pasar explícitamente el diccionario de estado 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 necesitas reemplazar torch.save con otro método. Se puede configurar con la variable de entorno DIFFUSERS_SAVE_MODE.

safe_serialization (bool, opcional, por defecto 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[[diffusers.loaders.AnimaLoraLoaderMixin]]

diffusers.loaders.AnimaLoraLoaderMixin[[diffusers.loaders.AnimaLoraLoaderMixin]]

diffusers.loaders.AnimaLoraLoaderMixin()

Fuente

Carga las capas LoRA en CosmosTransformer3DModel y AnimaTextConditioner.

fuse_lora[[diffusers.loaders.AnimaLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_weights[[diffusers.loaders.AnimaLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.AnimaLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

unfuse_lora[[diffusers.loaders.AnimaLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

AceStepLoraLoaderMixin[[diffusers.loaders.AceStepLoraLoaderMixin]]

diffusers.loaders.AceStepLoraLoaderMixin[[diffusers.loaders.AceStepLoraLoaderMixin]]

diffusers.loaders.AceStepLoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.AceStepLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.AceStepLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.AceStepLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.AceStepLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.AceStepLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.AceStepLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

HiDreamImageLoraLoaderMixin[[diffusers.loaders.HiDreamImageLoraLoaderMixin]]

diffusers.loaders.HiDreamImageLoraLoaderMixin[[diffusers.loaders.HiDreamImageLoraLoaderMixin]]

diffusers.loaders.HiDreamImageLoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.HiDreamImageLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.HiDreamImageLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.HiDreamImageLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.HiDreamImageLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.HiDreamImageLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.HiDreamImageLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

QwenImageLoraLoaderMixin[[diffusers.loaders.QwenImageLoraLoaderMixin]]

diffusers.loaders.QwenImageLoraLoaderMixin[[diffusers.loaders.QwenImageLoraLoaderMixin]]

diffusers.loaders.QwenImageLoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.QwenImageLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.QwenImageLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.QwenImageLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.QwenImageLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.QwenImageLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.QwenImageLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

ZImageLoraLoaderMixin[[diffusers.loaders.ZImageLoraLoaderMixin]]

diffusers.loaders.ZImageLoraLoaderMixin[[diffusers.loaders.ZImageLoraLoaderMixin]]

diffusers.loaders.ZImageLoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.ZImageLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.ZImageLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.ZImageLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.ZImageLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.ZImageLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.ZImageLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

CosmosLoraLoaderMixin[[diffusers.loaders.CosmosLoraLoaderMixin]]

diffusers.loaders.CosmosLoraLoaderMixin[[diffusers.loaders.CosmosLoraLoaderMixin]]

diffusers.loaders.CosmosLoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.CosmosLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.CosmosLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.CosmosLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.CosmosLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.CosmosLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.CosmosLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

KandinskyLoraLoaderMixin[[diffusers.loaders.KandinskyLoraLoaderMixin]]

diffusers.loaders.KandinskyLoraLoaderMixin[[diffusers.loaders.KandinskyLoraLoaderMixin]]

diffusers.loaders.KandinskyLoraLoaderMixin()

Fuente

Carga las capas LoRA en Kandinsky5Transformer3DModel,

fuse_lora[[diffusers.loaders.KandinskyLoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.KandinskyLoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.KandinskyLoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.KandinskyLoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.KandinskyLoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.KandinskyLoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

Ideogram4LoraLoaderMixin[[diffusers.loaders.Ideogram4LoraLoaderMixin]]

diffusers.loaders.Ideogram4LoraLoaderMixin[[diffusers.loaders.Ideogram4LoraLoaderMixin]]

diffusers.loaders.Ideogram4LoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.Ideogram4LoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.Ideogram4LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.Ideogram4LoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.Ideogram4LoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.Ideogram4LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.Ideogram4LoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

Krea2LoraLoaderMixin[[diffusers.loaders.Krea2LoraLoaderMixin]]

diffusers.loaders.Krea2LoraLoaderMixin[[diffusers.loaders.Krea2LoraLoaderMixin]]

diffusers.loaders.Krea2LoraLoaderMixin()

Fuente

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

fuse_lora[[diffusers.loaders.Krea2LoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.Krea2LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_weights[[diffusers.loaders.Krea2LoraLoaderMixin.load_lora_weights]]

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

Fuente

Consulte load_lora_weights() para obtener más detalles.

lora_state_dict[[diffusers.loaders.Krea2LoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.Krea2LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None)

Fuente

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

unfuse_lora[[diffusers.loaders.Krea2LoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

MiniMaxH3LoraLoaderMixin[[diffusers.loaders.MiniMaxH3LoraLoaderMixin]]

diffusers.loaders.MiniMaxH3LoraLoaderMixin[[diffusers.loaders.MiniMaxH3LoraLoaderMixin]]

diffusers.loaders.MiniMaxH3LoraLoaderMixin()

Fuente

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 (por ejemplo, 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 en fp32 hacen que la ruta de LoRA no fusionada se 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 por una incompatibilidad de tamaño. Los archivos sin alpha 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[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.fuse_lora]]

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

Fuente

Consulte fuse_lora() para más detalles.

load_lora_into_transformer[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_into_transformer]]

load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

Consulte load_lora_into_unet() para obtener más detalles.

load_lora_into_transformer_ref[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_into_transformer_ref]]

load_lora_into_transformer_ref(state_dict, transformer_ref, prefix, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)

Fuente

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[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_weights]]

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

Fuente

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 desruido, 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[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.lora_state_dict]]

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

Fuente

Consulte lora_state_dict() para obtener más detalles.

save_lora_weights[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, transformer_ref_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, transformer_lora_adapter_metadata: dict | None = None, transformer_ref_lora_adapter_metadata: dict | None = None)

Fuente

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[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.unfuse_lora]]

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

Fuente

Consulte unfuse_lora() para más detalles.

PikaH3FlexLoraLoaderMixin[[diffusers.loaders.PikaH3FlexLoraLoaderMixin]]

diffusers.loaders.PikaH3FlexLoraLoaderMixin[[diffusers.loaders.PikaH3FlexLoraLoaderMixin]]

diffusers.loaders.PikaH3FlexLoraLoaderMixin()

Fuente

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, publicados 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[[diffusers.loaders.lora_base.LoraBaseMixin]]

diffusers.loaders.lora_base.LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]

diffusers.loaders.lora_base.LoraBaseMixin()

Fuente

Clase de utilidad para gestionar LoRAs.

delete_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.delete_adapters]]

delete_adapters(adapter_names: list[str] | str)

Fuente

Parámetros:

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

Eliminar las capas LoRA de un adaptador 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_names="cinematic"
)
pipeline.delete_adapters("cinematic")

disable_lora[[diffusers.loaders.lora_base.LoraBaseMixin.disable_lora]]

disable_lora()

Fuente

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[[diffusers.loaders.lora_base.LoraBaseMixin.enable_lora]]

enable_lora()

Fuente

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[[diffusers.loaders.lora_base.LoraBaseMixin.enable_lora_hotswap]]

enable_lora_hotswap(**kwargs)

Fuente

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" (por defecto): lanza un error - "warn": emite una advertencia - "ignore": no hace nada

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

fuse_lora[[diffusers.loaders.lora_base.LoraBaseMixin.fuse_lora]]

fuse_lora(components: list[str] | None = None, lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)

Fuente

Parámetros:

components : (list[str]): lista de componentes inyectables con LoRA en los que fusionar los LoRA.

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[[diffusers.loaders.lora_base.LoraBaseMixin.get_active_adapters]]

get_active_adapters()

Fuente

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[[diffusers.loaders.lora_base.LoraBaseMixin.get_list_adapters]]

get_list_adapters()

Fuente

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

set_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.set_adapters]]

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

Fuente

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, un 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 y bloques UNet no especificados 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[[diffusers.loaders.lora_base.LoraBaseMixin.set_lora_device]]

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

Fuente

Parámetros:

adapter_names (list[str]) : lista de adaptadores a los que enviar el 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 si deseas 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 provocarí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[[diffusers.loaders.lora_base.LoraBaseMixin.unfuse_lora]]

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

Fuente

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 desvincular los parámetros LoRA del UNet.

unfuse_text_encoder (bool, por defecto True) : Si se deben desvincular 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[[diffusers.loaders.lora_base.LoraBaseMixin.unload_lora_weights]]

unload_lora_weights()

Fuente

Descarga los parámetros de LoRA.

Ejemplos:

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

write_lora_layers[[diffusers.loaders.lora_base.LoraBaseMixin.write_lora_layers]]

write_lora_layers(state_dict: dict[str, torch.Tensor], save_directory: str, is_main_process: bool, weight_name: str, save_function: Callable, safe_serialization: bool, lora_adapter_metadata: dict | None = None)

Fuente

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