# 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](/docs/diffusers/v0.43.0/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) o a un Transformer (por ejemplo, [SD3Transformer2DModel](/docs/diffusers/v0.43.0/es/api/models/sd3_transformer2d#diffusers.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)](../../api/pipelines/stable_diffusion/stable_diffusion_xl) 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](https://huggingface.co/blog/sd3).
- `FluxLoraLoaderMixin` proporciona funciones similares para [Flux](https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux).
- `CogVideoXLoraLoaderMixin` proporciona funciones similares para [CogVideoX](https://huggingface.co/docs/diffusers/main/en/api/pipelines/cogvideox).
- `Mochi1LoraLoaderMixin` proporciona funciones similares para [Mochi](https://huggingface.co/docs/diffusers/main/en/api/pipelines/mochi).
- `AuraFlowLoraLoaderMixin` proporciona funciones similares para [AuraFlow](https://huggingface.co/fal/AuraFlow).
- `LTXVideoLoraLoaderMixin` proporciona funciones similares para [LTX-Video](https://huggingface.co/docs/diffusers/main/en/api/pipelines/ltx_video).
- `SanaLoraLoaderMixin` proporciona funciones similares para [Sana](https://huggingface.co/docs/diffusers/main/en/api/pipelines/sana).
- `HeliosLoraLoaderMixin` proporciona funciones similares para [HunyuanVideo](https://huggingface.co/docs/diffusers/main/en/api/pipelines/helios).
- `HunyuanVideoLoraLoaderMixin` proporciona funciones similares para [HunyuanVideo](https://huggingface.co/docs/diffusers/main/en/api/pipelines/hunyuan_video).
- `Lumina2LoraLoaderMixin` proporciona funciones similares para [Lumina2](https://huggingface.co/docs/diffusers/main/en/api/pipelines/lumina2).
- `WanLoraLoaderMixin` proporciona funciones similares para [Wan](https://huggingface.co/docs/diffusers/main/en/api/pipelines/wan).
- `SkyReelsV2LoraLoaderMixin` proporciona funciones similares para [SkyReels-V2](https://huggingface.co/docs/diffusers/main/en/api/pipelines/skyreels_v2).
- `CogView4LoraLoaderMixin` proporciona funciones similares para [CogView4](https://huggingface.co/docs/diffusers/main/en/api/pipelines/cogview4).
- `AmusedLoraLoaderMixin` es para `AmusedPipeline`.
- `AnimaLoraLoaderMixin` proporciona funciones similares para [Anima](https://huggingface.co/docs/diffusers/main/en/api/pipelines/anima).
- `AceStepLoraLoaderMixin` proporciona funciones similares para [ACE-Step](https://huggingface.co/docs/diffusers/main/en/api/pipelines/ace_step).
- `HiDreamImageLoraLoaderMixin` proporciona funciones similares para [HiDream Image](https://huggingface.co/docs/diffusers/main/en/api/pipelines/hidream)
- `QwenImageLoraLoaderMixin` proporciona funciones similares para [Qwen Image](https://huggingface.co/docs/diffusers/main/en/api/pipelines/qwen).
- `ZImageLoraLoaderMixin` proporciona funciones similares para [Z-Image](https://huggingface.co/docs/diffusers/main/en/api/pipelines/zimage).
- `Flux2LoraLoaderMixin` proporciona funciones similares para [Flux2](https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux2).
- `ErnieImageLoraLoaderMixin` proporciona funciones similares para [Ernie-Image](https://huggingface.co/docs/diffusers/main/en/api/pipelines/ernie_image).
- `LTX2LoraLoaderMixin` proporciona funciones similares para [Flux2](https://huggingface.co/docs/diffusers/main/en/api/pipelines/ltx2).
- `MiniMaxH3LoraLoaderMixin` proporciona funciones similares para [MiniMax-H3](https://huggingface.co/docs/diffusers/main/en/api/pipelines/minimax_h3).
- `PikaH3FlexLoraLoaderMixin` proporciona funciones similares para [Pika H3 Flex](https://huggingface.co/docs/diffusers/main/en/api/pipelines/pika_h3_flex).
- `RFD4ProteinaLoraLoaderMixin` proporciona funciones similares para [RFD4-Proteína](https://huggingface.co/docs/diffusers/main/en/api/pipelines/rfd4_proteina).
- `BriaFibo2LoraLoaderMixin` proporciona funciones similares para [fibo-2](https://huggingface.co/docs/diffusers/main/en/api/pipelines/bria_fibo2).
- `LoraBaseMixin` proporciona una clase base con varios métodos de utilidad para fusionar, desfusionar, descargar, LoRAs y más.

> [!TIP]
> Para obtener más información sobre cómo cargar los pesos de LoRA, consulte la guía de carga de [LoRA](../../tutorials/using_peft_for_inference).

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

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

```python
diffusers.loaders.RFD4ProteinaLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7532)

Carga las capas LoRA en [RFD4ProteinaTransformer](/docs/diffusers/v0.43.0/es/api/models/rfd4_proteina_transformer#diffusers.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]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7694)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7631)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7595)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7543)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7658)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7714)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.lora_base.LoraBaseMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L491)

Clase de utilidad para gestionar LoRAs.

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

```python
delete_adapters(adapter_names: list[str] | str)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L873)

**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:

```py
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]]

```python
disable_lora()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L813)

Desactiva las capas LoRA activas del pipeline.

Ejemplo:

```py
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]]

```python
enable_lora()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L843)

Habilita las capas LoRA activas del pipeline.

Ejemplo:

```py
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]]

```python
enable_lora_hotswap(**kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L1020)

**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]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L549)

**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:

```py
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]]

```python
get_active_adapters()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L911)

Obtiene la lista de los adaptadores activos actuales.

Ejemplo:

```python
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]]

```python
get_list_adapters()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L944)

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

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L698)

**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:

```py
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]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L966)

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

```python
>>> 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]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L636)

**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()`](https://huggingface.co/docs/diffusers/main/en/api/loaders#diffusers.loaders.LoraBaseMixin.fuse_lora).

#### unload_lora_weights[[diffusers.loaders.lora_base.LoraBaseMixin.unload_lora_weights]]

```python
unload_lora_weights()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L526)

Descarga los parámetros de LoRA.

Ejemplos:

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

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L1043)

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

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

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

```python
diffusers.loaders.StableDiffusionLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L138)

Carga las capas LoRA en el [UNet2DConditionModel](/docs/diffusers/v0.43.0/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel) y el [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) de Stable Diffusion.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L408)

**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](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).

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()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.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]]

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L354)

**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](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).

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()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.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]]

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L148)

**Parámetros:**

pretrained_model_name_or_path_or_dict (`str` o `os.PathLike` o `dict`) : Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.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()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.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()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles sobre cómo se carga el state dict.

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.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()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.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]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L243)

**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()](/docs/diffusers/v0.43.0/es/api/models/overview#diffusers.ModelMixin.save_pretrained). - Un [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-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.

> [!WARNING] > 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]]

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L466)

**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]]

```python
diffusers.loaders.StableDiffusionXLLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L585)

Carga las capas LoRA en el [UNet2DConditionModel](/docs/diffusers/v0.43.0/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel), el [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) y el [`CLIPTextModelWithProjection`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection) de Stable Diffusion XL.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L938)

Consulte `fuse_lora()` para más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L831)

**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](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).

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()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.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]]

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L776)

**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](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).

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()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.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]]

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L596)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L664)

**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()](/docs/diffusers/v0.43.0/es/api/models/overview#diffusers.ModelMixin.save_pretrained). - Un [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-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.

> [!WARNING] > 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]]

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L890)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L957)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.SD3LoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L964)

Carga las capas LoRA en [SD3Transformer2DModel](/docs/diffusers/v0.43.0/es/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel), [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) y [`CLIPTextModelWithProjection`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection).

Específico de [StableDiffusion3Pipeline](/docs/diffusers/v0.43.0/es/api/pipelines/stable_diffusion/stable_diffusion_3#diffusers.StableDiffusion3Pipeline).

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1225)

Consulte `fuse_lora()` para más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1116)

**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](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).

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()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.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]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1090)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1031)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L977)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1175)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1245)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.FluxLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1441)

Carga las capas LoRA en [FluxTransformer2DModel](/docs/diffusers/v0.43.0/es/api/models/flux_transformer#diffusers.FluxTransformer2DModel), [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel).

Específico de [FluxPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/flux#diffusers.FluxPipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1879)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1756)

**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](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).

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()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.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]]

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1675)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1579)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1454)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1815)

**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]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1911)

**Parámetros:**

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

Revierte el efecto de [`pipe.fuse_lora()`](https://huggingface.co/docs/diffusers/main/en/api/loaders#diffusers.loaders.LoraBaseMixin.fuse_lora).

#### unload_lora_weights[[diffusers.loaders.FluxLoraLoaderMixin.unload_lora_weights]]

```python
unload_lora_weights(reset_to_overwritten_params = False)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1926)

**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](https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux) para obtener más información.

Descarga los parámetros de LoRA.

Ejemplos:

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

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

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

```python
diffusers.loaders.Flux2LoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5773)

Carga las capas LoRA en [Flux2Transformer2DModel](/docs/diffusers/v0.43.0/es/api/models/flux2_transformer#diffusers.Flux2Transformer2DModel). Específico de [Flux2Pipeline](/docs/diffusers/v0.43.0/es/api/pipelines/flux2#diffusers.Flux2Pipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5957)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5894)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5859)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5781)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5921)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5977)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.Flux3LoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5984)

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6139)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6076)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6040)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6103)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6159)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.BriaFibo2LoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6166)

Carga las capas LoRA en [BriaFibo2Transformer2DModel](/docs/diffusers/v0.43.0/es/api/models/transformer_bria_fibo2#diffusers.BriaFibo2Transformer2DModel). Específico de [BriaFibo2Pipeline](/docs/diffusers/v0.43.0/es/api/pipelines/bria_fibo2#diffusers.BriaFibo2Pipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6328)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6265)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6229)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6174)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6292)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6348)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.ErnieImageLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6551)

Carga las capas LoRA en [ErnieImageTransformer2DModel](/docs/diffusers/v0.43.0/es/api/models/ernie_image_transformer2d#diffusers.ErnieImageTransformer2DModel). Específico de `ErnieImagePipeline`.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6724)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6661)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6625)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6559)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6688)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6744)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.LTX2LoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2919)

Carga las capas LoRA en [LTX2VideoTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/ltx2_video_transformer3d#diffusers.LTX2VideoTransformer3DModel). Específico de [LTX2Pipeline](/docs/diffusers/v0.43.0/es/api/pipelines/ltx2#diffusers.LTX2Pipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3108)

Consulte `fuse_lora()` para más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3044)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2992)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2928)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3072)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3128)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.CogVideoXLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2353)

Carga las capas LoRA en [CogVideoXTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/cogvideox_transformer3d#diffusers.CogVideoXTransformer3DModel). Específico de [CogVideoXPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/cogvideox#diffusers.CogVideoXPipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2512)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2451)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2416)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2361)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2478)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2531)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.Mochi1LoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2538)

Carga las capas LoRA en [MochiTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/mochi_transformer3d#diffusers.MochiTransformer3DModel). Específico de [MochiPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/mochi#diffusers.MochiPipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2700)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2637)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2601)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2546)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2664)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2720)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.AuraFlowLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1252)

Carga las capas LoRA en [AuraFlowTransformer2DModel](/docs/diffusers/v0.43.0/es/api/models/aura_flow_transformer2d#diffusers.AuraFlowTransformer2DModel) Específico de [AuraFlowPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/aura_flow#diffusers.AuraFlowPipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1414)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1351)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1315)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1260)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1378)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L1434)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.LTXVideoLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2727)

Carga las capas LoRA en [LTXVideoTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/ltx_video_transformer3d#diffusers.LTXVideoTransformer3DModel). Específico de [LTXPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/ltx_video#diffusers.LTXPipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2892)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2829)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2793)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2735)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2856)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2912)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.SanaLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3135)

Carga las capas LoRA en [SanaTransformer2DModel](/docs/diffusers/v0.43.0/es/api/models/sana_transformer2d#diffusers.SanaTransformer2DModel). Específico de [SanaPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/sana#diffusers.SanaPipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3297)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3234)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3198)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3143)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3261)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3317)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.HeliosLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3324)

Carga las capas LoRA en [HeliosTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/helios_transformer3d#diffusers.HeliosTransformer3DModel). Específico de [HeliosPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/helios#diffusers.HeliosPipeline) y [HeliosPyramidPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/helios#diffusers.HeliosPyramidPipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3487)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3424)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3390)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3332)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3451)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3507)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.HunyuanVideoLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3514)

Carga las capas LoRA en [HunyuanVideoTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/hunyuan_video_transformer_3d#diffusers.HunyuanVideoTransformer3DModel). Específico de [HunyuanVideoPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/hunyuan_video#diffusers.HunyuanVideoPipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3679)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3616)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3580)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3522)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3643)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3699)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.Lumina2LoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3706)

Carga las capas LoRA en [Lumina2Transformer2DModel](/docs/diffusers/v0.43.0/es/api/models/lumina2_transformer2d#diffusers.Lumina2Transformer2DModel). Específico de [Lumina2Pipeline](/docs/diffusers/v0.43.0/es/api/pipelines/lumina2#diffusers.Lumina2Pipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3872)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3809)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3773)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3714)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3836)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3892)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.CogView4LoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4617)

Carga las capas LoRA en [WanTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel). Específico de [CogView4Pipeline](/docs/diffusers/v0.43.0/es/api/pipelines/cogview4#diffusers.CogView4Pipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4779)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4716)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4680)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4625)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4743)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4799)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.WanLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4088)

Carga las capas LoRA en [WanTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel). Específico de [WanPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/wan#diffusers.WanPipeline) y `[WanImageToVideoPipeline`.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4324)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4261)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4202)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4096)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4288)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4344)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.SkyReelsV2LoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4351)

Carga las capas LoRA en [SkyReelsV2Transformer3DModel](/docs/diffusers/v0.43.0/es/api/models/skyreels_v2_transformer_3d#diffusers.SkyReelsV2Transformer3DModel).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4590)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4527)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4467)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4359)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4554)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4610)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.AmusedLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2206)

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2211)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L2298)

**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]]

```python
diffusers.loaders.AnimaLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5587)

Carga las capas LoRA en [CosmosTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel) y [AnimaTextConditioner](/docs/diffusers/v0.43.0/es/api/pipelines/anima#diffusers.AnimaTextConditioner).

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5747)

Consulte `fuse_lora()` para más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5652)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5596)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5766)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.AceStepLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6941)

Carga las capas LoRA en [AceStepTransformer1DModel](/docs/diffusers/v0.43.0/es/api/models/ace_step_transformer#diffusers.AceStepTransformer1DModel). Específico de [AceStepPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/ace_step#diffusers.AceStepPipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7105)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7042)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7006)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6949)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7069)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7125)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.HiDreamImageLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4806)

Carga las capas LoRA en [HiDreamImageTransformer2DModel](/docs/diffusers/v0.43.0/es/api/models/hidream_image_transformer#diffusers.HiDreamImageTransformer2DModel). Específico de [HiDreamImagePipeline](/docs/diffusers/v0.43.0/es/api/pipelines/hidream#diffusers.HiDreamImagePipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4971)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4908)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4872)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4814)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4935)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4991)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.QwenImageLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4998)

Carga las capas LoRA en [QwenImageTransformer2DModel](/docs/diffusers/v0.43.0/es/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel). Específico de [QwenImagePipeline](/docs/diffusers/v0.43.0/es/api/pipelines/qwenimage#diffusers.QwenImagePipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5166)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5103)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5067)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5006)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5130)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5186)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.ZImageLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5387)

Carga las capas LoRA en [ZImageTransformer2DModel](/docs/diffusers/v0.43.0/es/api/models/z_image_transformer2d#diffusers.ZImageTransformer2DModel). Específico de [ZImagePipeline](/docs/diffusers/v0.43.0/es/api/pipelines/z_image#diffusers.ZImagePipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5560)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5497)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5461)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5395)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5524)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5580)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.CosmosLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6751)

Carga las capas LoRA en [CosmosTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel), específico de [Cosmos2_5_PredictBasePipeline](/docs/diffusers/v0.43.0/es/api/pipelines/cosmos#diffusers.Cosmos2_5_PredictBasePipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6914)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6851)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6815)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6760)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6878)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6934)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.KandinskyLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3899)

Carga las capas LoRA en `Kandinsky5Transformer3DModel`,

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4061)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3998)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3962)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L3907)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4025)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L4081)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.Ideogram4LoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6355)

Carga las capas LoRA en [Ideogram4Transformer2DModel](/docs/diffusers/v0.43.0/es/api/models/ideogram4_transformer2d#diffusers.Ideogram4Transformer2DModel). Específico de [Ideogram4Pipeline](/docs/diffusers/v0.43.0/es/api/pipelines/ideogram4#diffusers.Ideogram4Pipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6524)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6461)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6425)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6363)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6488)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L6544)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.Krea2LoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5193)

Carga las capas LoRA en [Krea2Transformer2DModel](/docs/diffusers/v0.43.0/es/api/models/krea2_transformer2d#diffusers.Krea2Transformer2DModel). Específico de [Krea2Pipeline](/docs/diffusers/v0.43.0/es/api/pipelines/krea2#diffusers.Krea2Pipeline).

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5360)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5297)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5261)

Consulte [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para obtener más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5201)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5324)

Consulte [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L5380)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.MiniMaxH3LoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7132)

Carga las capas LoRA en [MiniMaxH3Transformer3DModel](/docs/diffusers/v0.43.0/es/api/models/minimax_h3_transformer3d#diffusers.MiniMaxH3Transformer3DModel). Específico de [MiniMaxH3ModularPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/minimax_h3#diffusers.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](https://huggingface.co/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](https://huggingface.co/Comfy-Org/MiniMax-H3); [joyfox/MiniMax-H3-Turbo](https://huggingface.co/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](https://huggingface.co/larryvrh/MiniMax-H3-Turbo-Lora)); una entrada de `__metadata__` `alpha` (por ejemplo, el archivo de 8 pasos de [lightx2v/Minimax-h3-Turbo](https://huggingface.co/lightx2v/Minimax-h3-Turbo)), si está presente, se respeta en su lugar.

#### fuse_lora[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.fuse_lora]]

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7489)

Consulte `fuse_lora()` para más detalles.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7389)

Consulte [load_lora_into_unet()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7416)

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()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para más detalles.

#### load_lora_weights[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_weights]]

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7274)

**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()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para más detalles.

#### lora_state_dict[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.lora_state_dict]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7159)

Consulte [lora_state_dict()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para obtener más detalles.

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7446)

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()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para obtener más información.

#### unfuse_lora[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.unfuse_lora]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7508)

Consulte `unfuse_lora()` para más detalles.

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

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

```python
diffusers.loaders.PikaH3FlexLoraLoaderMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_pipeline.py#L7515)

Carga las capas LoRA en [MiniMaxH3Transformer3DModel](/docs/diffusers/v0.43.0/es/api/models/minimax_h3_transformer3d#diffusers.MiniMaxH3Transformer3DModel). Específico de [PikaH3FlexModularPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/pika_h3_flex#diffusers.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.

```py
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]]

```python
diffusers.loaders.lora_base.LoraBaseMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L491)

Clase de utilidad para gestionar LoRAs.

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

```python
delete_adapters(adapter_names: list[str] | str)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L873)

**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:

```py
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]]

```python
disable_lora()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L813)

Desactiva las capas LoRA activas del pipeline.

Ejemplo:

```py
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]]

```python
enable_lora()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L843)

Habilita las capas LoRA activas del pipeline.

Ejemplo:

```py
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]]

```python
enable_lora_hotswap(**kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L1020)

**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]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L549)

**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:

```py
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]]

```python
get_active_adapters()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L911)

Obtiene la lista de los adaptadores activos actuales.

Ejemplo:

```python
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]]

```python
get_list_adapters()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L944)

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

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L698)

**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:

```py
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]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L966)

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

```python
>>> 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]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L636)

**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()`](https://huggingface.co/docs/diffusers/main/en/api/loaders#diffusers.loaders.LoraBaseMixin.fuse_lora).

#### unload_lora_weights[[diffusers.loaders.lora_base.LoraBaseMixin.unload_lora_weights]]

```python
unload_lora_weights()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L526)

Descarga los parámetros de LoRA.

Ejemplos:

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

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

```python
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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/loaders/lora_base.py#L1043)

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