# LoRA

LoRA 是一种快速且轻量级的训练方法，它通过插入并训练数量远少于模型全部参数的参数来实现训练。这会产生更小的文件（约 100 MB），并使快速训练模型以学习新概念变得更加容易。LoRA 权重通常加载到去噪器、文本编码器或两者中。去噪器通常对应于 UNet（例如 [UNet2DConditionModel](/docs/diffusers/main/zh/api/models/unet2d-cond#diffusers.UNet2DConditionModel)）或 Transformer（例如 [SD3Transformer2DModel](/docs/diffusers/main/zh/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel)）。有几种用于加载 LoRA 权重的类：

- `StableDiffusionLoraLoaderMixin` 提供了用于加载和卸载、融合和取消融合、启用和禁用等管理 LoRA 权重的函数。该类可与任何模型配合使用。
- `StableDiffusionXLLoraLoaderMixin` 是 `StableDiffusionLoraLoaderMixin` 类的 [Stable Diffusion (SDXL)](../../api/pipelines/stable_diffusion/stable_diffusion_xl) 版本，用于加载和保存 LoRA 权重。它仅能与 SDXL 模型配合使用。
- `SD3LoraLoaderMixin` 为 [Stable Diffusion 3](https://huggingface.co/blog/sd3) 提供了类似的功能。
- `FluxLoraLoaderMixin` 为 [Flux](https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux) 提供了类似的功能。
- `CogVideoXLoraLoaderMixin` 为 [CogVideoX](https://huggingface.co/docs/diffusers/main/en/api/pipelines/cogvideox) 提供了类似的功能。
- `Mochi1LoraLoaderMixin` 为 [Mochi](https://huggingface.co/docs/diffusers/main/en/api/pipelines/mochi) 提供了类似的功能。
- `AuraFlowLoraLoaderMixin` 为 [AuraFlow](https://huggingface.co/fal/AuraFlow) 提供了类似的功能。
- `LTXVideoLoraLoaderMixin` 为 [LTX-Video](https://huggingface.co/docs/diffusers/main/en/api/pipelines/ltx_video) 提供了类似的功能。
- `SanaLoraLoaderMixin` 为 [Sana](https://huggingface.co/docs/diffusers/main/en/api/pipelines/sana) 提供了类似的功能。
- `HeliosLoraLoaderMixin` 为 [HunyuanVideo](https://huggingface.co/docs/diffusers/main/en/api/pipelines/helios) 提供了类似的功能。
- `HunyuanVideoLoraLoaderMixin` 为 [HunyuanVideo](https://huggingface.co/docs/diffusers/main/en/api/pipelines/hunyuan_video) 提供了类似的功能。
- `Lumina2LoraLoaderMixin` 为 [Lumina2](https://huggingface.co/docs/diffusers/main/en/api/pipelines/lumina2) 提供了类似的功能。
- `WanLoraLoaderMixin` 为 [Wan](https://huggingface.co/docs/diffusers/main/en/api/pipelines/wan) 提供了类似的功能。
- `SkyReelsV2LoraLoaderMixin` 为 [SkyReels-V2](https://huggingface.co/docs/diffusers/main/en/api/pipelines/skyreels_v2) 提供了类似的功能。
- `CogView4LoraLoaderMixin` 为 [CogView4](https://huggingface.co/docs/diffusers/main/en/api/pipelines/cogview4) 提供了类似的功能。
- `AmusedLoraLoaderMixin` 用于 `AmusedPipeline`。
- `AnimaLoraLoaderMixin` 为 [Anima](https://huggingface.co/docs/diffusers/main/en/api/pipelines/anima) 提供了类似的功能。
- `AceStepLoraLoaderMixin` 为 [ACE-Step](https://huggingface.co/docs/diffusers/main/en/api/pipelines/ace_step) 提供类似的功能。
- `HiDreamImageLoraLoaderMixin` 为 [HiDream Image](https://huggingface.co/docs/diffusers/main/en/api/pipelines/hidream) 提供了类似的功能
- `QwenImageLoraLoaderMixin` 为 [Qwen Image](https://huggingface.co/docs/diffusers/main/en/api/pipelines/qwen) 提供了类似的功能。
- `ZImageLoraLoaderMixin` 为 [Z-Image](https://huggingface.co/docs/diffusers/main/en/api/pipelines/zimage) 提供了类似的功能。
- `Flux2LoraLoaderMixin` 为 [Flux2](https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux2) 提供了类似的功能。
- `ErnieImageLoraLoaderMixin` 为 [Ernie-Image](https://huggingface.co/docs/diffusers/main/en/api/pipelines/ernie_image) 提供了类似的功能。
- `LTX2LoraLoaderMixin` 为 [Flux2](https://huggingface.co/docs/diffusers/main/en/api/pipelines/ltx2) 提供了类似的功能。
- `MiniMaxH3LoraLoaderMixin` 为 [MiniMax-H3](https://huggingface.co/docs/diffusers/main/en/api/pipelines/minimax_h3) 提供了类似的功能。
- `PikaH3FlexLoraLoaderMixin` 为 [Pika H3 Flex](https://huggingface.co/docs/diffusers/main/en/api/pipelines/pika_h3_flex) 提供了类似的功能。
- `RFD4ProteinaLoraLoaderMixin` 为 [RFD4-Proteína](https://huggingface.co/docs/diffusers/main/en/api/pipelines/rfd4_proteina) 提供了类似的功能。
- `BriaFibo2LoraLoaderMixin` 为 [fibo-2](https://huggingface.co/docs/diffusers/main/en/api/pipelines/bria_fibo2) 提供了类似的功能。
- `LoraBaseMixin` 提供了一个基类，其中包含用于融合、解融合、卸载 LoRA 等的若干实用方法。

> [!TIP]
> 要了解如何加载 LoRA 权重，请参阅 [LoRA](../../tutorials/using_peft_for_inference) 加载指南。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7532)

将 LoRA 层加载到 [RFD4ProteinaTransformer](/docs/diffusers/main/zh/api/models/rfd4_proteina_transformer#diffusers.RFD4ProteinaTransformer) 中。

自编码器与去噪器检查点配对使用，且未进行适配，因此 Transformer 是唯一可加载的模块。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7694)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7631)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7595)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7543)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7658)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7714)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L491)

用于处理 LoRA 的实用类。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L873)

**参数：**

adapter_names (`list[str, str]`) : 要删除的适配器名称。

从流水线中删除适配器的 LoRA 层。

示例：

```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()
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L813)

禁用管道中处于激活状态的 LoRA 层。

示例：

```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()
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L843)

启用管道中处于激活状态的 LoRA 层。

示例：

```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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L1020)

**参数：**

target_rank (`int`) : 所有将加载的适配器中的最高秩。

check_compiled (`str`，*可选*，默认为 `"error"`)：如何处理已编译的模型。该检查可能返回以下消息：- "error"（默认）：引发错误 - "warn"：发出警告 - "ignore"：不执行任何操作

在不触发模型重新编译的情况下热插拔适配器，或者在加载的适配器秩不同时进行热插拔。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L549)

**参数：**

components : (`list[str]`): 要融合 LoRA 的 LoRA 可注入组件列表。

lora_scale (`float`，默认值为 1.0)：控制 LoRA 参数对输出的影响程度。

safe_fusing (`bool`，默认为 `False`)：是否在融合前检查融合权重中的 NaN 值，如果值为 NaN 则不进行融合。

adapter_names (`list[str]`, *可选*) : 用于融合的适配器名称。如果未传入任何值，则所有处于活动状态的适配器都将被融合。

将 LoRA 参数融合到对应块的原始参数中。

示例：

```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()
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L911)

获取当前激活的适配器列表。

示例：

```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()
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L944)

获取管道中当前所有可用适配器的列表。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L698)

**参数：**

adapter_names (`list[str]` 或 `str`) : 要使用的适配器名称。

adapter_weights (`float`、`dict` 或 `list`，*可选*)：适配器的权重。标量会缩放所有支持 LoRA 的组件。字典将组件名称（例如 `"unet"`、`"transformer"` 或 `"text_encoder"`）映射到对应的权重；UNet 组件的权重也可以是一个包含块缩放的嵌套字典。单个标量或字典会应用于每个适配器。列表必须按 `adapter_names` 的顺序，为每个适配器包含一个标量、字典或 `None`。`None` 默认为 `1.0`，包括列表项和组件权重。未指定的组件和 UNet 块也默认为 `1.0`。

设置当前用于流水线的活动适配器。

示例：

```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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L966)

**参数：**

adapter_names (`list[str]`) : 要发送到该设备的适配器列表。

device (`torch.device | str | int`) : 用于将适配器发送到的设备。可以是 torch 设备、字符串或整数。

将 `adapter_names` 中列出的 LoRA 移动到目标设备。如果您希望加载多个适配器并释放部分 GPU 内存，可以将 LoRA 卸载到 CPU，此操作非常有用。

将 LoRA 适配器卸载到 CPU 后，只要模型的其余部分仍在 GPU 上，这些 LoRA 适配器就无法再用于推理，因为这会导致设备不匹配。在将这些 LoRA 适配器用于推理之前，请务必将设备重新设置回 GPU。

```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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L636)

**参数：**

components (`list[str]`) : 要从中解除 LoRA 融合的、可注入 LoRA 的组件列表。

unfuse_unet (`bool`，默认为 `True`)：是否取消融合 UNet LoRA 参数。

unfuse_text_encoder (`bool`，默认为 `True`)：是否解绑文本编码器的 LoRA 参数。如果文本编码器未通过 monkey-patch 方式注入 LoRA 参数，则此设置不会生效。

撤销 [`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()
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L526)

卸载 LoRA 参数。

示例：

```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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L1043)

将 LoRA 层的 state dict（可选包含元数据）写入磁盘。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L138)

将 LoRA 层加载到 Stable Diffusion 的 [UNet2DConditionModel](/docs/diffusers/main/zh/api/models/unet2d-cond#diffusers.UNet2DConditionModel) 和 [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) 中。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L408)

**参数：**

state_dict (`dict`) : 包含 lora 层参数的标准 state dict。键名应额外添加 `text_encoder` 前缀，以区分 unet 的 lora 层。

network_alphas (`dict[str, float]`) : 用于稳定学习和防止下溢的网络 alpha 值。该值与 kohya-ss 训练脚本中的 `--network_alpha` 选项含义相同。请参阅 [此链接](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning)。

text_encoder (`CLIPTextModel`)：用于加载 LoRA 层的文本编码器模型。

prefix (`str`) : `state_dict` 中 `text_encoder` 的预期前缀。

lora_scale (`float`) : 在将 LoRA 线性层的输出与常规 LoRA 层的输出相加之前，对 LoRA 线性层输出进行缩放的系数。

adapter_name (`str`，*可选*)：用于引用已加载的适配器模型的适配器名称。如果未指定，则使用 `default_{i}`，其中 i 为正在加载的适配器总数。

low_cpu_mem_usage (`bool`，*可选*)：通过仅加载预训练的 LoRA 权重而不初始化随机权重，来加快模型加载速度。

hotswap (`bool`，*可选*)：参见 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

metadata (`dict`) : 可选的 LoRA 适配器元数据。如果提供，`peft` 的 `LoraConfig` 参数将不会从状态字典中推导得出。

这将把`state_dict`中指定的 LoRA 层加载到`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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L354)

**参数：**

state_dict (`dict`) : 包含 lora 层参数的标准 state dict。键可以直接索引到 unet，也可以带有额外的 `unet` 前缀，用于区分文本编码器的 lora 层。

network_alphas (`dict[str, float]`) : 用于稳定学习和防止下溢的网络 alpha 值。该值与 kohya-ss 训练脚本中的 `--network_alpha` 选项含义相同。请参阅 [此链接](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning)。

unet (`UNet2DConditionModel`)：要加载 LoRA 层的 UNet 模型。

adapter_name (`str`，*可选*)：用于引用已加载的适配器模型的适配器名称。如果未指定，则使用 `default_{i}`，其中 i 为正在加载的适配器总数。

low_cpu_mem_usage (`bool`，*可选*)：仅加载预训练的 LoRA 权重而不初始化随机权重，以加快模型加载速度。

hotswap (`bool`，*可选*)：参见 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

metadata (`dict`) : 可选的 LoRA 适配器元数据。如果提供，`peft` 的 `LoraConfig` 参数将不会从状态字典中推导得出。

这将把 `state_dict` 中指定的 LoRA 层加载到 `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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L148)

**参数：**

pretrained_model_name_or_path_or_dict (`str` 或 `os.PathLike` 或 `dict`)：参见 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

adapter_name (`str`，*可选*)：用于引用已加载的适配器模型的适配器名称。如果未指定，则使用 `default_{i}`，其中 i 为正在加载的适配器总数。

low_cpu_mem_usage (`bool`，*可选*)：通过仅加载预训练的 LoRA 权重而不初始化随机权重，来加快模型加载速度。

hotswap (`bool`, *可选*) : 默认为 `False`。是否就地用新加载的适配器替换现有的（LoRA）适配器。这意味着，不会加载额外的适配器，而是将现有适配器的权重替换为新适配器的权重。这种方式可能更快且更节省内存。然而，热替换的主要优势在于，当模型使用 torch.compile 编译时，加载新适配器无需重新编译模型。使用热替换时，传入的 `adapter_name` 应为已加载适配器的名称。 如果新适配器和旧适配器的秩（rank）和/或 LoRA alpha（即缩放）不同，在加载适配器之前需要调用一个额外方法：  ```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 ```  请注意，目前尚不支持对文本编码器适配器进行热替换。该技术还有一些其他限制，详见此处：https://huggingface.co/docs/peft/main/en/package_reference/hotswap

kwargs (`dict`，*可选*)：参见 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

将 `pretrained_model_name_or_path_or_dict` 中指定的 LoRA 权重加载到 `self.unet` 和 `self.text_encoder` 中。

所有 kwargs 都会转发到 `self.lora_state_dict`。

有关状态字典加载方式的更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

有关状态字典如何加载到 `self.unet` 的更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

有关状态字典如何加载到 `self.text_encoder` 的更多详细信息，请参阅 [load_lora_into_text_encoder()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L243)

**参数：**

pretrained_model_name_or_path_or_dict (`str` 或 `os.PathLike` 或 `dict`) : 可以是以下之一： - 一个字符串，即托管在 Hub 上的预训练模型的 *model id*（例如 `google/ddpm-celebahq-256`）。 - 一个指向 *目录* 的路径（例如 `./my_model_directory`），其中包含使用 [ModelMixin.save_pretrained()](/docs/diffusers/main/zh/api/models/overview#diffusers.ModelMixin.save_pretrained) 保存的模型权重。 - 一个 [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict)。

cache_dir (`str | os.PathLike`，*可选*)：如果未使用标准缓存，则已下载的预训练模型配置将缓存到的目录路径。

force_download (`bool`，*可选*，默认为 `False`)：是否强制（重新）下载模型权重和配置文件，如果存在缓存版本则覆盖它们。

proxies (`dict[str, str]`，*可选*)：一个字典，用于按协议或端点指定要使用的代理服务器，例如 `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`。每次请求都会使用这些代理。

local_files_only (`bool`，*可选*，默认为 `False`)：是否仅加载本地模型权重和配置文件。如果设置为 `True`，则不会从 Hub 下载模型。

token (`str` 或 *bool*，*可选*) : 用于远程文件的 HTTP 承载者授权令牌。如果为 `True`，则使用由 `diffusers-cli login` 生成的令牌（存储在 `~/.huggingface` 中）。

revision (`str`，*可选*，默认为 `"main"`)：要使用的特定模型版本。它可以是分支名称、标签名称、提交 ID，或 Git 允许的任何标识符。

subfolder (`str`，*可选*，默认为 `""`)：模型文件在 Hub 或本地的大型模型仓库中的子文件夹位置。

weight_name (`str`，*可选*，默认为 None)：序列化状态字典文件的名称。

return_lora_metadata (`bool`，*可选*，默认为 False)：启用后，将额外返回 LoRA 适配器元数据，通常位于 state dict 中。

返回 LoRA 权重和网络 alpha 的状态字典。

> [!WARNING] > 我们有限地支持加载 A1111 格式的 LoRA 检查点。 > > 此函数
实验性功能，未来可能会发生变化。

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

```python
save_lora_weights(save_directory: str | os.PathLike, unet_lora_layers: dict = None, text_encoder_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L466)

**参数：**

save_directory (`str` 或 `os.PathLike`)：用于保存 LoRA 参数的目录。如果该目录不存在，将自动创建。

unet_lora_layers (`dict[str, torch.nn.Module]` 或 `dict[str, torch.Tensor]`) : 与 `unet` 对应的 LoRA 层的 state dict。

text_encoder_lora_layers (`dict[str, torch.nn.Module]` 或 `dict[str, torch.Tensor]`) : 与 `text_encoder` 对应的 LoRA 层的 state dict。由于它来自 🤗 Transformers，因此必须显式传入文本编码器的 LoRA state dict。

is_main_process (`bool`，*可选*，默认为 `True`)：调用此函数的进程是否为主进程。在分布式训练期间，如果需要在所有进程上调用此函数，此参数非常有用。在这种情况下，仅在将 `is_main_process=True` 设置为主进程时，以避免竞态条件。

save_function (`Callable`) : 用于保存状态字典的函数。在分布式训练期间，当您需要用其他方法替换 `torch.save` 时非常有用。可通过环境变量 `DIFFUSERS_SAVE_MODE` 进行配置。

safe_serialization (`bool`，*可选*，默认为 `True`)：是否使用 `safetensors` 保存模型，还是使用传统的 PyTorch 方式（通过 `pickle`）。

unet_lora_adapter_metadata : 与 unet 关联的 LoRA 适配器元数据，将随 state dict 一起序列化。

text_encoder_lora_adapter_metadata : 与文本编码器关联的 LoRA 适配器元数据，将随状态字典一起序列化。

保存与 UNet 和文本编码器对应的 LoRA 参数。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L585)

将 LoRA 层加载到 Stable Diffusion XL 的 [UNet2DConditionModel](/docs/diffusers/main/zh/api/models/unet2d-cond#diffusers.UNet2DConditionModel)、[`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) 和 [`CLIPTextModelWithProjection`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection) 中。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L938)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L831)

**参数：**

state_dict (`dict`) : 包含 lora 层参数的标准 state dict。键名应额外添加 `text_encoder` 前缀，以区分 unet 的 lora 层。

network_alphas (`dict[str, float]`) : 用于稳定学习和防止下溢的网络 alpha 值。该值与 kohya-ss 训练脚本中的 `--network_alpha` 选项含义相同。请参阅 [此链接](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning)。

text_encoder (`CLIPTextModel`)：用于加载 LoRA 层的文本编码器模型。

prefix (`str`) : `state_dict` 中 `text_encoder` 的预期前缀。

lora_scale (`float`) : 在将 LoRA 线性层的输出与常规 LoRA 层的输出相加之前，对 LoRA 线性层输出进行缩放的系数。

adapter_name (`str`，*可选*)：用于引用已加载的适配器模型的适配器名称。如果未指定，则使用 `default_{i}`，其中 i 为正在加载的适配器总数。

low_cpu_mem_usage (`bool`，*可选*)：通过仅加载预训练的 LoRA 权重而不初始化随机权重，来加快模型加载速度。

hotswap (`bool`，*可选*)：参见 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

metadata (`dict`) : 可选的 LoRA 适配器元数据。如果提供，`peft` 的 `LoraConfig` 参数将不会从状态字典中推导得出。

这将把`state_dict`中指定的 LoRA 层加载到`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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L776)

**参数：**

state_dict (`dict`) : 包含 lora 层参数的标准 state dict。键可以直接索引到 unet，也可以带有额外的 `unet` 前缀，用于区分文本编码器的 lora 层。

network_alphas (`dict[str, float]`) : 用于稳定学习和防止下溢的网络 alpha 值。该值与 kohya-ss 训练脚本中的 `--network_alpha` 选项含义相同。请参阅 [此链接](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning)。

unet (`UNet2DConditionModel`)：要加载 LoRA 层的 UNet 模型。

adapter_name (`str`，*可选*)：用于引用已加载的适配器模型的适配器名称。如果未指定，则使用 `default_{i}`，其中 i 为正在加载的适配器总数。

low_cpu_mem_usage (`bool`，*可选*)：仅加载预训练的 LoRA 权重而不初始化随机权重，以加快模型加载速度。

hotswap (`bool`，*可选*)：参见 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

metadata (`dict`) : 可选的 LoRA 适配器元数据。如果提供，`peft` 的 `LoraConfig` 参数将不会从状态字典中推导得出。

这将把 `state_dict` 中指定的 LoRA 层加载到 `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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L596)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L664)

**参数：**

pretrained_model_name_or_path_or_dict (`str` 或 `os.PathLike` 或 `dict`) : 可以是以下之一： - 一个字符串，即托管在 Hub 上的预训练模型的 *model id*（例如 `google/ddpm-celebahq-256`）。 - 一个 *目录* 的路径（例如 `./my_model_directory`），其中包含使用 [ModelMixin.save_pretrained()](/docs/diffusers/main/zh/api/models/overview#diffusers.ModelMixin.save_pretrained) 保存的模型权重。 - 一个 [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict)。

cache_dir (`str | os.PathLike`，*可选*)：如果未使用标准缓存，则已下载的预训练模型配置将缓存到的目录路径。

force_download (`bool`，*可选*，默认为 `False`)：是否强制（重新）下载模型权重和配置文件，如果存在缓存版本则覆盖它们。

proxies (`dict[str, str]`，*可选*)：一个字典，用于按协议或端点指定要使用的代理服务器，例如 `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`。每次请求都会使用这些代理。

local_files_only (`bool`，*可选*，默认为 `False`)：是否仅加载本地模型权重和配置文件。如果设置为 `True`，则不会从 Hub 下载模型。

token (`str` 或 *bool*，*可选*) : 用于远程文件的 HTTP 承载者授权令牌。如果为 `True`，则使用由 `diffusers-cli login` 生成的令牌（存储在 `~/.huggingface` 中）。

revision (`str`，*可选*，默认为 `"main"`)：要使用的特定模型版本。它可以是分支名称、标签名称、提交 ID，或 Git 允许的任何标识符。

subfolder (`str`，*可选*，默认为 `""`)：模型文件在 Hub 或本地的大型模型仓库中的子文件夹位置。

weight_name (`str`，*可选*，默认为 None)：序列化状态字典文件的名称。

return_lora_metadata (`bool`，*可选*，默认为 False)：启用后，将额外返回 LoRA 适配器元数据，通常位于 state dict 中。

返回 LoRA 权重和网络 alpha 的状态字典。

> [!WARNING] > 我们有限地支持加载 A1111 格式的 LoRA 检查点。 > > 此函数
实验性功能，未来可能会发生变化。

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

```python
save_lora_weights(save_directory: str | os.PathLike, unet_lora_layers: dict = None, text_encoder_lora_layers: dict = None, text_encoder_2_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L890)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L957)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L964)

将 LoRA 层加载到 [SD3Transformer2DModel](/docs/diffusers/main/zh/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel)、[`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) 和 [`CLIPTextModelWithProjection`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection) 中。

特定于 [StableDiffusion3Pipeline](/docs/diffusers/main/zh/api/pipelines/stable_diffusion/stable_diffusion_3#diffusers.StableDiffusion3Pipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1225)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1116)

**参数：**

state_dict (`dict`) : 包含 lora 层参数的标准 state dict。键名应额外添加 `text_encoder` 前缀，以区分 unet 的 lora 层。

network_alphas (`dict[str, float]`) : 用于稳定学习和防止下溢的网络 alpha 值。该值与 kohya-ss 训练脚本中的 `--network_alpha` 选项含义相同。请参阅 [此链接](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning)。

text_encoder (`CLIPTextModel`)：用于加载 LoRA 层的文本编码器模型。

prefix (`str`) : `state_dict` 中 `text_encoder` 的预期前缀。

lora_scale (`float`) : 在将 LoRA 线性层的输出与常规 LoRA 层的输出相加之前，对 LoRA 线性层输出进行缩放的系数。

adapter_name (`str`，*可选*)：用于引用已加载的适配器模型的适配器名称。如果未指定，则使用 `default_{i}`，其中 i 为正在加载的适配器总数。

low_cpu_mem_usage (`bool`，*可选*)：通过仅加载预训练的 LoRA 权重而不初始化随机权重，来加快模型加载速度。

hotswap (`bool`，*可选*)：参见 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

metadata (`dict`) : 可选的 LoRA 适配器元数据。如果提供，`peft` 的 `LoraConfig` 参数将不会从状态字典中推导得出。

这将把`state_dict`中指定的 LoRA 层加载到`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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1090)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1031)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L977)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = None, text_encoder_lora_layers: dict = None, text_encoder_2_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1175)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1245)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1441)

将 LoRA 层加载到 [FluxTransformer2DModel](/docs/diffusers/main/zh/api/models/flux_transformer#diffusers.FluxTransformer2DModel)、[`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) 中。

特定于 [FluxPipeline](/docs/diffusers/main/zh/api/pipelines/flux#diffusers.FluxPipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1879)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1756)

**参数：**

state_dict (`dict`) : 包含 lora 层参数的标准 state dict。键名应额外添加 `text_encoder` 前缀，以区分 unet 的 lora 层。

network_alphas (`dict[str, float]`) : 用于稳定学习和防止下溢的网络 alpha 值。该值与 kohya-ss 训练脚本中的 `--network_alpha` 选项含义相同。请参阅 [此链接](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning)。

text_encoder (`CLIPTextModel`)：用于加载 LoRA 层的文本编码器模型。

prefix (`str`) : `state_dict` 中 `text_encoder` 的预期前缀。

lora_scale (`float`) : 在将 LoRA 线性层的输出与常规 LoRA 层的输出相加之前，对 LoRA 线性层输出进行缩放的系数。

adapter_name (`str`，*可选*)：用于引用已加载的适配器模型的适配器名称。如果未指定，则使用 `default_{i}`，其中 i 为正在加载的适配器总数。

low_cpu_mem_usage (`bool`，*可选*)：通过仅加载预训练的 LoRA 权重而不初始化随机权重，来加快模型加载速度。

hotswap (`bool`，*可选*)：参见 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

metadata (`dict`) : 可选的 LoRA 适配器元数据。如果提供，`peft` 的 `LoraConfig` 参数将不会从状态字典中推导得出。

这将把`state_dict`中指定的 LoRA 层加载到`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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1675)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1579)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1454)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = None, text_encoder_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1815)

**参数：**

save_directory (`str` 或 `os.PathLike`)：用于保存 LoRA 参数的目录。如果该目录不存在，将自动创建。

transformer_lora_layers (`dict[str, torch.nn.Module]` 或 `dict[str, torch.Tensor]`) : 与 `transformer` 对应的 LoRA 层的 state dict。

text_encoder_lora_layers (`dict[str, torch.nn.Module]` 或 `dict[str, torch.Tensor]`) : 与 `text_encoder` 对应的 LoRA 层的 state dict。由于它来自 🤗 Transformers，因此必须显式传入文本编码器的 LoRA state dict。

is_main_process (`bool`，*可选*，默认为 `True`)：调用此函数的进程是否为主进程。在分布式训练期间，如果需要在所有进程上调用此函数，此参数非常有用。在这种情况下，仅在将 `is_main_process=True` 设置为主进程时，以避免竞态条件。

save_function (`Callable`) : 用于保存状态字典的函数。在分布式训练期间，当您需要用其他方法替换 `torch.save` 时非常有用。可通过环境变量 `DIFFUSERS_SAVE_MODE` 进行配置。

safe_serialization (`bool`，*可选*，默认为 `True`)：是否使用 `safetensors` 保存模型，还是使用传统的 PyTorch 方式（通过 `pickle`）。

transformer_lora_adapter_metadata : 与 transformer 关联的 LoRA 适配器元数据，将随 state dict 一起序列化。

text_encoder_lora_adapter_metadata : 与文本编码器关联的 LoRA 适配器元数据，将随状态字典一起序列化。

保存与 UNet 和文本编码器对应的 LoRA 参数。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1911)

**参数：**

components (`list[str]`) : 要从中解除 LoRA 融合的、可注入 LoRA 的组件列表。

撤销 [`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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1926)

**参数：**

reset_to_overwritten_params (`bool`，默认为 `False`)：是否将加载了 LoRA 的模块重置为其原始参数。请参阅 [Flux 文档](https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux) 以了解更多信息。

卸载 LoRA 参数。

示例：

```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()
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5773)

将 LoRA 层加载到 [Flux2Transformer2DModel](/docs/diffusers/main/zh/api/models/flux2_transformer#diffusers.Flux2Transformer2DModel) 中。专用于 [Flux2Pipeline](/docs/diffusers/main/zh/api/pipelines/flux2#diffusers.Flux2Pipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5957)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5894)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5859)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5781)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5921)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5977)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5984)

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6139)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6076)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6040)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6103)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6159)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6166)

将 LoRA 层加载到 [BriaFibo2Transformer2DModel](/docs/diffusers/main/zh/api/models/transformer_bria_fibo2#diffusers.BriaFibo2Transformer2DModel) 中。专用于 [BriaFibo2Pipeline](/docs/diffusers/main/zh/api/pipelines/bria_fibo2#diffusers.BriaFibo2Pipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6328)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6265)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6229)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6174)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6292)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6348)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6551)

将 LoRA 层加载到 [ErnieImageTransformer2DModel](/docs/diffusers/main/zh/api/models/ernie_image_transformer2d#diffusers.ErnieImageTransformer2DModel) 中。专用于 `ErnieImagePipeline`。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6724)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6661)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6625)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6559)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6688)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6744)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2919)

将 LoRA 层加载到 [LTX2VideoTransformer3DModel](/docs/diffusers/main/zh/api/models/ltx2_video_transformer3d#diffusers.LTX2VideoTransformer3DModel) 中。专用于 [LTX2Pipeline](/docs/diffusers/main/zh/api/pipelines/ltx2#diffusers.LTX2Pipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3108)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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')
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3044)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2992)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2928)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3072)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3128)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2353)

将 LoRA 层加载到 [CogVideoXTransformer3DModel](/docs/diffusers/main/zh/api/models/cogvideox_transformer3d#diffusers.CogVideoXTransformer3DModel) 中。专用于 [CogVideoXPipeline](/docs/diffusers/main/zh/api/pipelines/cogvideox#diffusers.CogVideoXPipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2512)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2451)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2416)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2361)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2478)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2531)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2538)

将 LoRA 层加载到 [MochiTransformer3DModel](/docs/diffusers/main/zh/api/models/mochi_transformer3d#diffusers.MochiTransformer3DModel) 中。专用于 [MochiPipeline](/docs/diffusers/main/zh/api/pipelines/mochi#diffusers.MochiPipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2700)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2637)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2601)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2546)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2664)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2720)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1252)

将 LoRA 层加载到 [AuraFlowTransformer2DModel](/docs/diffusers/main/zh/api/models/aura_flow_transformer2d#diffusers.AuraFlowTransformer2DModel) 中。专用于 [AuraFlowPipeline](/docs/diffusers/main/zh/api/pipelines/aura_flow#diffusers.AuraFlowPipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1414)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1351)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1315)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1260)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1378)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1434)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2727)

将 LoRA 层加载到 [LTXVideoTransformer3DModel](/docs/diffusers/main/zh/api/models/ltx_video_transformer3d#diffusers.LTXVideoTransformer3DModel) 中。专用于 [LTXPipeline](/docs/diffusers/main/zh/api/pipelines/ltx_video#diffusers.LTXPipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2892)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2829)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2793)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2735)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2856)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2912)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3135)

将 LoRA 层加载到 [SanaTransformer2DModel](/docs/diffusers/main/zh/api/models/sana_transformer2d#diffusers.SanaTransformer2DModel) 中。专用于 [SanaPipeline](/docs/diffusers/main/zh/api/pipelines/sana#diffusers.SanaPipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3297)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3234)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3198)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3143)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3261)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3317)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3324)

将 LoRA 层加载到 [HeliosTransformer3DModel](/docs/diffusers/main/zh/api/models/helios_transformer3d#diffusers.HeliosTransformer3DModel) 中。专用于 [HeliosPipeline](/docs/diffusers/main/zh/api/pipelines/helios#diffusers.HeliosPipeline) 和 [HeliosPyramidPipeline](/docs/diffusers/main/zh/api/pipelines/helios#diffusers.HeliosPyramidPipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3487)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3424)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3390)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3332)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3451)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3507)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3514)

将 LoRA 层加载到 [HunyuanVideoTransformer3DModel](/docs/diffusers/main/zh/api/models/hunyuan_video_transformer_3d#diffusers.HunyuanVideoTransformer3DModel) 中。专用于 [HunyuanVideoPipeline](/docs/diffusers/main/zh/api/pipelines/hunyuan_video#diffusers.HunyuanVideoPipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3679)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3616)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3580)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3522)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3643)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3699)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3706)

将 LoRA 层加载到 [Lumina2Transformer2DModel](/docs/diffusers/main/zh/api/models/lumina2_transformer2d#diffusers.Lumina2Transformer2DModel) 中。专用于 [Lumina2Pipeline](/docs/diffusers/main/zh/api/pipelines/lumina2#diffusers.Lumina2Pipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3872)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3809)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3773)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3714)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3836)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3892)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4617)

将 LoRA 层加载到 [WanTransformer3DModel](/docs/diffusers/main/zh/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel) 中。专用于 [CogView4Pipeline](/docs/diffusers/main/zh/api/pipelines/cogview4#diffusers.CogView4Pipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4779)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4716)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4680)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4625)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4743)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4799)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4088)

将 LoRA 层加载到 [WanTransformer3DModel](/docs/diffusers/main/zh/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel) 中。专用于 [WanPipeline](/docs/diffusers/main/zh/api/pipelines/wan#diffusers.WanPipeline) 和 `[WanImageToVideoPipeline`。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4324)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4261)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4202)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4096)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4288)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4344)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4351)

将 LoRA 层加载到 [SkyReelsV2Transformer3DModel](/docs/diffusers/main/zh/api/models/skyreels_v2_transformer_3d#diffusers.SkyReelsV2Transformer3DModel) 中。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4590)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4527)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4467)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4359)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4554)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4610)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2211)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, text_encoder_lora_layers: dict = None, transformer_lora_layers: dict = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2298)

**参数：**

save_directory (`str` 或 `os.PathLike`)：用于保存 LoRA 参数的目录。如果该目录不存在，将自动创建。

unet_lora_layers (`dict[str, torch.nn.Module]` 或 `dict[str, torch.Tensor]`) : 与 `unet` 对应的 LoRA 层的 state dict。

text_encoder_lora_layers (`dict[str, torch.nn.Module]` 或 `dict[str, torch.Tensor]`) : 与 `text_encoder` 对应的 LoRA 层的 state dict。由于它来自 🤗 Transformers，因此必须显式传入文本编码器的 LoRA state dict。

is_main_process (`bool`，*可选*，默认为 `True`)：调用此函数的进程是否为主进程。在分布式训练期间，如果需要在所有进程上调用此函数，此参数非常有用。在这种情况下，仅在将 `is_main_process=True` 设置为主进程时，以避免竞态条件。

save_function (`Callable`) : 用于保存状态字典的函数。在分布式训练期间，当您需要用其他方法替换 `torch.save` 时非常有用。可通过环境变量 `DIFFUSERS_SAVE_MODE` 进行配置。

safe_serialization (`bool`，*可选*，默认为 `True`)：是否使用 `safetensors` 保存模型，还是使用传统的 PyTorch 方式（通过 `pickle`）。

保存与 UNet 和文本编码器对应的 LoRA 参数。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5587)

将 LoRA 层加载到 [CosmosTransformer3DModel](/docs/diffusers/main/zh/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel) 和 [AnimaTextConditioner](/docs/diffusers/main/zh/api/pipelines/anima#diffusers.AnimaTextConditioner) 中。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5747)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5652)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5596)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5766)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6941)

将 LoRA 层加载到 [AceStepTransformer1DModel](/docs/diffusers/main/zh/api/models/ace_step_transformer#diffusers.AceStepTransformer1DModel) 中。专用于 [AceStepPipeline](/docs/diffusers/main/zh/api/pipelines/ace_step#diffusers.AceStepPipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7105)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7042)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7006)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6949)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7069)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7125)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4806)

将 LoRA 层加载到 [HiDreamImageTransformer2DModel](/docs/diffusers/main/zh/api/models/hidream_image_transformer#diffusers.HiDreamImageTransformer2DModel) 中。专用于 [HiDreamImagePipeline](/docs/diffusers/main/zh/api/pipelines/hidream#diffusers.HiDreamImagePipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4971)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4908)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4872)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4814)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4935)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4991)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4998)

将 LoRA 层加载到 [QwenImageTransformer2DModel](/docs/diffusers/main/zh/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel) 中。专用于 [QwenImagePipeline](/docs/diffusers/main/zh/api/pipelines/qwenimage#diffusers.QwenImagePipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5166)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5103)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5067)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5006)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5130)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5186)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5387)

将 LoRA 层加载到 [ZImageTransformer2DModel](/docs/diffusers/main/zh/api/models/z_image_transformer2d#diffusers.ZImageTransformer2DModel) 中。专用于 [ZImagePipeline](/docs/diffusers/main/zh/api/pipelines/z_image#diffusers.ZImagePipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5560)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5497)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5461)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5395)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5524)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5580)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6751)

将 LoRA 层加载到 [CosmosTransformer3DModel](/docs/diffusers/main/zh/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel) 中，专用于 [Cosmos2_5_PredictBasePipeline](/docs/diffusers/main/zh/api/pipelines/cosmos#diffusers.Cosmos2_5_PredictBasePipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6914)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6851)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6815)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6760)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6878)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6934)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3899)

将 LoRA 层加载到 `Kandinsky5Transformer3DModel` 中，

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4061)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3998)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3962)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3907)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4025)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4081)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6355)

将 LoRA 层加载到 [Ideogram4Transformer2DModel](/docs/diffusers/main/zh/api/models/ideogram4_transformer2d#diffusers.Ideogram4Transformer2DModel) 中。专用于 [Ideogram4Pipeline](/docs/diffusers/main/zh/api/pipelines/ideogram4#diffusers.Ideogram4Pipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6524)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6461)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6425)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6363)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6488)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6544)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

```python
diffusers.loaders.Krea2LoraLoaderMixin()
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5193)

将 LoRA 层加载到 [Krea2Transformer2DModel](/docs/diffusers/main/zh/api/models/krea2_transformer2d#diffusers.Krea2Transformer2DModel) 中。专用于 [Krea2Pipeline](/docs/diffusers/main/zh/api/pipelines/krea2#diffusers.Krea2Pipeline)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5360)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5297)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5261)

有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5201)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5324)

有关更多信息，请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5380)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

```python
diffusers.loaders.MiniMaxH3LoraLoaderMixin()
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7132)

将 LoRA 层加载到 [MiniMaxH3Transformer3DModel](/docs/diffusers/main/zh/api/models/minimax_h3_transformer3d#diffusers.MiniMaxH3Transformer3DModel) 中。专用于 [MiniMaxH3ModularPipeline](/docs/diffusers/main/zh/api/pipelines/minimax_h3#diffusers.MiniMaxH3ModularPipeline)。

MiniMax-H3 包含两个具有相同模块名称的独立 DiT 分区（针对其中一个加载的 LoRA 会被加载到另一个中，从而导致输出质量下降），因此路由是显式的：转换后的 state dict 目标为 `transformer.`；要访问 `transformer_ref`，请使用带有 `transformer_ref.` 前缀的文件，或设置 `load_into_transformer_ref=True`。

DiffSynth-Studio LoRA（例如 [DiffSynth-Studio/MiniMax-H3-LoRA-LineartAnime](https://huggingface.co/DiffSynth-Studio/MiniMax-H3-LoRA-LineartAnime)）是针对原始检查点中按头交错的融合 QKV 进行训练的，并在转换时进行解交错。其 fp32 因子会使未融合的 LoRA 路径以 fp32 进行计算；在加载模型后对模型执行 `.to(torch.bfloat16)` 可恢复 bf16 内存预算。

针对剪枝检查点（[Comfy-Org/MiniMax-H3](https://huggingface.co/Comfy-Org/MiniMax-H3) 中的 `*_pruned_*` 文件；[joyfox/MiniMax-H3-Turbo](https://huggingface.co/joyfox/MiniMax-H3-Turbo) 即为其中之一）训练的 LoRA 会因尺寸不匹配而加载失败。不含 `alpha` 的文件会以 `alpha == rank` 加载（缩放系数为 1.0，这是例如 [larryvrh/MiniMax-H3-Turbo-Lora](https://huggingface.co/larryvrh/MiniMax-H3-Turbo-Lora) 所采用的约定）；如果 `__metadata__` 中存在 `alpha` 条目（例如 [lightx2v/Minimax-h3-Turbo](https://huggingface.co/lightx2v/Minimax-h3-Turbo) 的 8 步文件），则会优先采用该值。

#### fuse_lora[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.fuse_lora]]

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7489)

有关更多详细信息，请参阅 `fuse_lora()`。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7389)

有关更多详细信息，请参阅 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7416)

将 LoRA 层加载到 `transformer_ref` 分区中。`prefix` 是键所携带的组件名称，对于指定了分区名称的文件，该值为 `transformer_ref`；对于通过 `load_into_transformer_ref=True` 路由到此处的文件，该值为 `transformer`。更多详情请参见 [load_lora_into_unet()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7274)

**参数：**

load_into_transformer_ref (`bool`，默认为 `False`)：将带有 `transformer.` 前缀的层加载到 `transformer_ref` 分区中——即 `ref2va` 工作流执行去噪所使用的分区——而不是 `transformer`。仅当两个分区都已加载时才需要此设置：如果流水线仅持有 `transformer_ref`，它会自动路由到该分区。

将 LoRA 层加载到 `transformer` 中，或者在设置 `load_into_transformer_ref=True` 时加载到 `transformer_ref` 中。有关更多详细信息，请参阅 [load_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7159)

有关更多详细信息，请参阅 [lora_state_dict()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)。

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

```python
save_lora_weights(save_directory: str | os.PathLike, transformer_lora_layers: dict = None, transformer_ref_lora_layers: dict = 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7446)

保存一个或两个 MiniMax-H3 分区的 LoRA 层。LoRA 所属的分区无法从其键中恢复，因此这是发布记录该信息的 H3 LoRA 的唯一方式。更多信息请参阅 [save_lora_weights()](/docs/diffusers/main/zh/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)。

#### unfuse_lora[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.unfuse_lora]]

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7508)

有关更多详细信息，请参阅 `unfuse_lora()`。

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

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

```python
diffusers.loaders.PikaH3FlexLoraLoaderMixin()
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7515)

将 LoRA 层加载到 [MiniMaxH3Transformer3DModel](/docs/diffusers/main/zh/api/models/minimax_h3_transformer3d#diffusers.MiniMaxH3Transformer3DModel) 中。专用于 [PikaH3FlexModularPipeline](/docs/diffusers/main/zh/api/pipelines/pika_h3_flex#diffusers.PikaH3FlexModularPipeline)。

Pika H3 Flex 版本*是*针对两个 MiniMax-H3 transformer 分区的一对 rank-128 适配器，以 diffusers 模块名称的纯 PEFT 转储形式发布（`transformer` 对应 `fl2va/adapter.safetensors`，`transformer_ref` 对应 `ref2va/adapter.safetensors`）。这些不含 alpha 的文件在 `alpha == rank`（缩放系数 1.0）时加载，这是适配器自身的约定；其加载、路由和保存逻辑均遵循 `MiniMaxH3LoraLoaderMixin`：`fl2va` 适配器加载到 `transformer`，`ref2va` 适配器加载到 `transformer_ref`——当流水线仅持有该分区时（`workflow="ref2va"`）单独加载，当流水线同时持有两个分区时则需设置 `load_into_transformer_ref=True`。

```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()
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L491)

用于处理 LoRA 的实用类。

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

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

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L873)

**参数：**

adapter_names (`list[str, str]`) : 要删除的适配器名称。

从流水线中删除适配器的 LoRA 层。

示例：

```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()
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L813)

禁用管道中处于激活状态的 LoRA 层。

示例：

```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()
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L843)

启用管道中处于激活状态的 LoRA 层。

示例：

```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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L1020)

**参数：**

target_rank (`int`) : 所有将加载的适配器中的最高秩。

check_compiled (`str`，*可选*，默认为 `"error"`)：如何处理已编译的模型。该检查可能返回以下消息：- "error"（默认）：引发错误 - "warn"：发出警告 - "ignore"：不执行任何操作

在不触发模型重新编译的情况下热插拔适配器，或者在加载的适配器秩不同时进行热插拔。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L549)

**参数：**

components : (`list[str]`): 要融合 LoRA 的 LoRA 可注入组件列表。

lora_scale (`float`，默认值为 1.0)：控制 LoRA 参数对输出的影响程度。

safe_fusing (`bool`，默认为 `False`)：是否在融合前检查融合权重中的 NaN 值，如果值为 NaN 则不进行融合。

adapter_names (`list[str]`, *可选*) : 用于融合的适配器名称。如果未传入任何值，则所有处于活动状态的适配器都将被融合。

将 LoRA 参数融合到对应块的原始参数中。

示例：

```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()
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L911)

获取当前激活的适配器列表。

示例：

```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()
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L944)

获取管道中当前所有可用适配器的列表。

#### 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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L698)

**参数：**

adapter_names (`list[str]` 或 `str`) : 要使用的适配器名称。

adapter_weights (`float`、`dict` 或 `list`，*可选*)：适配器的权重。标量会缩放所有支持 LoRA 的组件。字典将组件名称（例如 `"unet"`、`"transformer"` 或 `"text_encoder"`）映射到对应的权重；UNet 组件的权重也可以是一个包含块缩放的嵌套字典。单个标量或字典会应用于每个适配器。列表必须按 `adapter_names` 的顺序，为每个适配器包含一个标量、字典或 `None`。`None` 默认为 `1.0`，包括列表项和组件权重。未指定的组件和 UNet 块也默认为 `1.0`。

设置当前用于流水线的活动适配器。

示例：

```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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L966)

**参数：**

adapter_names (`list[str]`) : 要发送到该设备的适配器列表。

device (`torch.device | str | int`) : 用于将适配器发送到的设备。可以是 torch 设备、字符串或整数。

将 `adapter_names` 中列出的 LoRA 移动到目标设备。如果您希望加载多个适配器并释放部分 GPU 内存，可以将 LoRA 卸载到 CPU，此操作非常有用。

将 LoRA 适配器卸载到 CPU 后，只要模型的其余部分仍在 GPU 上，这些 LoRA 适配器就无法再用于推理，因为这会导致设备不匹配。在将这些 LoRA 适配器用于推理之前，请务必将设备重新设置回 GPU。

```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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L636)

**参数：**

components (`list[str]`) : 要从中解除 LoRA 融合的、可注入 LoRA 的组件列表。

unfuse_unet (`bool`，默认为 `True`)：是否取消融合 UNet LoRA 参数。

unfuse_text_encoder (`bool`，默认为 `True`)：是否解绑文本编码器的 LoRA 参数。如果文本编码器未通过 monkey-patch 方式注入 LoRA 参数，则此设置不会生效。

撤销 [`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()
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L526)

卸载 LoRA 参数。

示例：

```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)
```

[源代码](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L1043)

将 LoRA 层的 state dict（可选包含元数据）写入磁盘。