# LoRA

LoRA est une méthode d'entraînement rapide et légère qui insère et entraîne un nombre de paramètres nettement inférieur à celui de tous les paramètres du modèle. Cela produit un fichier plus petit (~100 Mo) et facilite l'entraînement rapide d'un modèle pour qu'il apprenne un nouveau concept. Les poids LoRA sont généralement chargés dans le débruiteur, l'encodeur de texte ou les deux. Le débruiteur correspond généralement à un UNet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel), par exemple) ou à un Transformer ([SD3Transformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel), par exemple). Il existe plusieurs classes pour charger les poids LoRA :

- `StableDiffusionLoraLoaderMixin` fournit des fonctions pour charger et décharger, fusionner et défusionner, activer et désactiver, ainsi que d’autres fonctions pour gérer les poids LoRA. Cette classe peut être utilisée avec n’importe quel modèle.
- `StableDiffusionXLLoraLoaderMixin` est une version [Stable Diffusion (SDXL)](../../api/pipelines/stable_diffusion/stable_diffusion_xl) de la classe `StableDiffusionLoraLoaderMixin` pour charger et enregistrer les poids LoRA. Elle ne peut être utilisée qu’avec le modèle SDXL.
- `SD3LoraLoaderMixin` fournit des fonctions similaires pour [Stable Diffusion 3](https://huggingface.co/blog/sd3).
- `FluxLoraLoaderMixin` fournit des fonctions similaires pour [Flux](https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux).
- `CogVideoXLoraLoaderMixin` fournit des fonctions similaires pour [CogVideoX](https://huggingface.co/docs/diffusers/main/en/api/pipelines/cogvideox).
- `Mochi1LoraLoaderMixin` fournit des fonctions similaires pour [Mochi](https://huggingface.co/docs/diffusers/main/en/api/pipelines/mochi).
- `AuraFlowLoraLoaderMixin` fournit des fonctions similaires pour [AuraFlow](https://huggingface.co/fal/AuraFlow).
- `LTXVideoLoraLoaderMixin` fournit des fonctions similaires pour [LTX-Video](https://huggingface.co/docs/diffusers/main/en/api/pipelines/ltx_video).
- `SanaLoraLoaderMixin` fournit des fonctions similaires pour [Sana](https://huggingface.co/docs/diffusers/main/en/api/pipelines/sana).
- `HeliosLoraLoaderMixin` fournit des fonctions similaires pour [HunyuanVideo](https://huggingface.co/docs/diffusers/main/en/api/pipelines/helios).
- `HunyuanVideoLoraLoaderMixin` fournit des fonctions similaires pour [HunyuanVideo](https://huggingface.co/docs/diffusers/main/en/api/pipelines/hunyuan_video).
- `Lumina2LoraLoaderMixin` fournit des fonctions similaires pour [Lumina2](https://huggingface.co/docs/diffusers/main/en/api/pipelines/lumina2).
- `WanLoraLoaderMixin` fournit des fonctions similaires pour [Wan](https://huggingface.co/docs/diffusers/main/en/api/pipelines/wan).
- `SkyReelsV2LoraLoaderMixin` fournit des fonctions similaires pour [SkyReels-V2](https://huggingface.co/docs/diffusers/main/en/api/pipelines/skyreels_v2).
- `CogView4LoraLoaderMixin` fournit des fonctions similaires pour [CogView4](https://huggingface.co/docs/diffusers/main/en/api/pipelines/cogview4).
- `AmusedLoraLoaderMixin` est destiné à `AmusedPipeline`.
- `AnimaLoraLoaderMixin` fournit des fonctions similaires pour [Anima](https://huggingface.co/docs/diffusers/main/en/api/pipelines/anima).
- `AceStepLoraLoaderMixin` fournit des fonctions similaires pour [ACE-Step](https://huggingface.co/docs/diffusers/main/en/api/pipelines/ace_step).
- `HiDreamImageLoraLoaderMixin` fournit des fonctions similaires pour [HiDream Image](https://huggingface.co/docs/diffusers/main/en/api/pipelines/hidream)
- `QwenImageLoraLoaderMixin` fournit des fonctions similaires pour [Qwen Image](https://huggingface.co/docs/diffusers/main/en/api/pipelines/qwen).
- `ZImageLoraLoaderMixin` fournit des fonctions similaires pour [Z-Image](https://huggingface.co/docs/diffusers/main/en/api/pipelines/zimage).
- `Flux2LoraLoaderMixin` fournit des fonctions similaires pour [Flux2](https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux2).
- `ErnieImageLoraLoaderMixin` fournit des fonctions similaires pour [Ernie-Image](https://huggingface.co/docs/diffusers/main/en/api/pipelines/ernie_image).
- `LTX2LoraLoaderMixin` fournit des fonctions similaires pour [Flux2](https://huggingface.co/docs/diffusers/main/en/api/pipelines/ltx2).
- `MiniMaxH3LoraLoaderMixin` fournit des fonctions similaires pour [MiniMax-H3](https://huggingface.co/docs/diffusers/main/en/api/pipelines/minimax_h3).
- `PikaH3FlexLoraLoaderMixin` fournit des fonctions similaires pour [Pika H3 Flex](https://huggingface.co/docs/diffusers/main/en/api/pipelines/pika_h3_flex).
- `RFD4ProteinaLoraLoaderMixin` fournit des fonctions similaires pour [RFD4-Proteína](https://huggingface.co/docs/diffusers/main/en/api/pipelines/rfd4_proteina).
- `BriaFibo2LoraLoaderMixin` fournit des fonctions similaires pour [fibo-2](https://huggingface.co/docs/diffusers/main/en/api/pipelines/bria_fibo2).
- `LoraBaseMixin` fournit une classe de base avec plusieurs méthodes utilitaires pour fusionner, désfusionner, décharger des LoRAs et plus encore.

> [!TIP]
> Pour en savoir plus sur la manière de charger les poids LoRA, consultez le guide de chargement [LoRA](../../tutorials/using_peft_for_inference).

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

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

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

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

Charger les couches LoRA dans [RFD4ProteinaTransformer](/docs/diffusers/v0.43.0/fr/api/models/rfd4_proteina_transformer#diffusers.RFD4ProteinaTransformer).

L'autoencodeur est associé au point de contrôle du débruiteur et n'est pas adapté, de sorte que le transformeur est le seul module chargeable.

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Classe utilitaire pour la gestion des LoRA.

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

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

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

**Paramètres :**

adapter_names (`list[str, str]`) : Les noms des adaptateurs à supprimer.

Supprimer les couches LoRA d'un adaptateur du pipeline.

Exemple :

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

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

Désactive les couches LoRA actives du pipeline.

Exemple :

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

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

Active les couches LoRA actives du pipeline.

Exemple :

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

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

**Paramètres :**

target_rank (`int`) : Le rang le plus élevé parmi tous les adaptateurs qui seront chargés.

check_compiled (`str`, *facultatif*, par défaut `"error"`) : Comment gérer un modèle déjà compilé. La vérification peut renvoyer les messages suivants : - "error" (par défaut) : lever une erreur - "warn" : émettre un avertissement - "ignore" : ne rien faire

Chauder les adaptateurs sans déclencher la recompilation d'un modèle ou si les rangs des adaptateurs chargés sont différents.

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

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

**Paramètres :**

components : (`list[str]`) : liste des composants injectables par LoRA dans lesquels fusionner les LoRA.

lora_scale (`float`, par défaut 1.0) : Contrôle dans quelle mesure les paramètres LoRA influencent les sorties.

safe_fusing (`bool`, par défaut `False`) : Indique s'il faut vérifier les poids fusionnés pour détecter des valeurs NaN avant la fusion, et, si des valeurs sont NaN, de ne pas les fusionner.

adapter_names (`list[str]`, *facultatif*) : Noms des adaptateurs à utiliser pour la fusion. Si rien n'est transmis, tous les adaptateurs actifs seront fusionnés.

Fond les paramètres LoRA dans les paramètres originaux des blocs correspondants.

Exemple :

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

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

Renvoie la liste des adaptateurs actifs actuels.

Exemple :

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

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

Renvoie la liste actuelle de tous les adaptateurs disponibles dans le pipeline.

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

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

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

**Paramètres :**

adapter_names (`list[str]` ou `str`) : Les noms des adaptateurs à utiliser.

adapter_weights (`float`, `dict` ou `list`, *facultatif*) : Poids pour les adaptateurs. Un scalaire met à l'échelle tous les composants compatibles LoRA. Un dictionnaire associe les noms de composants (par ex. `"unet"`, `"transformer"` ou `"text_encoder"`) à des poids ; le poids d'un composant UNet peut également être un dictionnaire imbriqué d'échelles de blocs. Un scalaire ou un dictionnaire unique est appliqué à chaque adaptateur. Une liste doit contenir un scalaire, un dictionnaire ou `None` par adaptateur, dans l'ordre de `adapter_names`. `None` est par défaut `1.0`, y compris pour les entrées de liste et les poids des composants. Les composants non spécifiés et les blocs UNet sont également par défaut `1.0`.

Définissez les adaptateurs actuellement actifs pour leur utilisation dans le pipeline.

Exemple :

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

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

**Paramètres :**

adapter_names (`list[str]`) : liste des adaptateurs à envoyer vers l'appareil.

device (`torch.device | str | int`) : Appareil vers lequel envoyer les adaptateurs. Peut être un appareil torch, une chaîne de caractères ou un entier.

Déplace les LoRA listés dans `adapter_names` vers un appareil cible. Utile pour décharger le LoRA sur le CPU si vous souhaitez charger plusieurs adaptateurs et libérer de la mémoire GPU.

Après avoir déchargé les adaptateurs LoRA sur le CPU, tant que le reste du modèle est toujours sur le GPU, les adaptateurs LoRA ne peuvent plus être utilisés pour l'inférence, car cela provoquerait une incompatibilité de périphérique. Pensez à réinitialiser le périphérique sur le GPU avant d'utiliser ces adaptateurs LoRA pour l'inférence.

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

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

**Paramètres :**

components (`list[str]`) : liste des composants injectables par LoRA dont il faut retirer l'injection de LoRA.

unfuse_unet (`bool`, par défaut `True`) : Indique s'il faut désfusionner les paramètres LoRA du UNet.

unfuse_text_encoder (`bool`, par défaut `True`) : Indique s'il faut désfusionner les paramètres LoRA de l'encodeur de texte. Si l'encodeur de texte n'a pas été modifié (monkey-patched) avec les paramètres LoRA, cela n'aura aucun effet.

Annule l'effet de [`pipe.fuse_lora()`](https://huggingface.co/docs/diffusers/main/en/api/loaders#diffusers.loaders.LoraBaseMixin.fuse_lora).

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

```python
unload_lora_weights()
```

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

Décharge les paramètres LoRA.

Exemples :

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

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

Écrit le dictionnaire d'état des couches LoRA (éventuellement avec des métadonnées) sur le disque.

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

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

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

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

Charger les couches LoRA dans le [UNet2DConditionModel](/docs/diffusers/v0.43.0/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel) et le [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) de Stable Diffusion.

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

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

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

**Paramètres :**

state_dict (`dict`) : Un state dict standard contenant les paramètres des couches lora. La clé doit être préfixée par `text_encoder` supplémentaire afin de distinguer les couches lora de unet.

network_alphas (`dict[str, float]`) : La valeur de l'alpha du réseau utilisée pour un apprentissage stable et la prévention du sous-débordement. Cette valeur a la même signification que l'option `--network_alpha` du script d'entraînement kohya-ss. Consultez [ce lien](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).

text_encoder (`CLIPTextModel`) : le modèle d'encodeur de texte dans lequel charger les couches LoRA.

prefix (`str`) : Préfixe attendu du `text_encoder` dans le `state_dict`.

lora_scale (`float`) : Facteur d'échelle appliqué à la sortie de la couche linéaire lora avant son ajout à la sortie de la couche lora standard.

adapter_name (`str`, *facultatif*) : Nom de l'adaptateur à utiliser pour référencer le modèle d'adaptateur chargé. S'il n'est pas spécifié, `default_{i}` sera utilisé, où i est le nombre total d'adaptateurs chargés.

low_cpu_mem_usage (`bool`, *facultatif*) : Accélère le chargement du modèle en ne chargeant que les poids LoRA préentraînés et sans initialiser les poids aléatoires.

hotswap (`bool`, *facultatif*) : Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights).

metadata (`dict`) : métadonnées facultatives de l’adaptateur LoRA. Si fournies, les arguments `LoraConfig` de `peft` ne seront pas dérivés du dictionnaire d’état.

Cela chargera les couches LoRA spécifiées dans `state_dict` dans `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)
```

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

**Paramètres :**

state_dict (`dict`) : Un state dict standard contenant les paramètres des couches lora. Les clés peuvent soit être indexées directement dans le unet, soit préfixées par un `unet` supplémentaire, ce qui permet de distinguer les couches lora des encodeurs de texte.

network_alphas (`dict[str, float]`) : La valeur de l'alpha du réseau utilisée pour un apprentissage stable et la prévention du sous-débordement. Cette valeur a la même signification que l'option `--network_alpha` du script d'entraînement kohya-ss. Consultez [ce lien](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).

unet (`UNet2DConditionModel`) : Le modèle UNet dans lequel charger les couches LoRA.

adapter_name (`str`, *facultatif*) : Nom de l'adaptateur à utiliser pour référencer le modèle d'adaptateur chargé. S'il n'est pas spécifié, `default_{i}` sera utilisé, où i est le nombre total d'adaptateurs chargés.

low_cpu_mem_usage (`bool`, *facultatif*) : Accélère le chargement du modèle en ne chargeant que les poids LoRA préentraînés et sans initialiser les poids aléatoires.

hotswap (`bool`, *facultatif*) : Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights).

metadata (`dict`) : métadonnées facultatives de l’adaptateur LoRA. Si fournies, les arguments `LoraConfig` de `peft` ne seront pas dérivés du dictionnaire d’état.

Cela chargera les couches LoRA spécifiées dans `state_dict` dans `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)
```

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

**Paramètres :**

pretrained_model_name_or_path_or_dict (`str` ou `os.PathLike` ou `dict`) : Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict).

adapter_name (`str`, *facultatif*) : Nom de l'adaptateur à utiliser pour référencer le modèle d'adaptateur chargé. S'il n'est pas spécifié, `default_{i}` sera utilisé, où i est le nombre total d'adaptateurs chargés.

low_cpu_mem_usage (`bool`, *facultatif*) : Accélère le chargement du modèle en ne chargeant que les poids LoRA préentraînés et sans initialiser les poids aléatoires.

hotswap (`bool`, *facultatif*) : La valeur par défaut est `False`. Indique s'il faut substituer un adaptateur (LoRA) existant par l'adaptateur nouvellement chargé, sur place. Cela signifie que, au lieu de charger un adaptateur supplémentaire, les poids de l'adaptateur existant seront remplacés par ceux du nouvel adaptateur. Cette approche peut être plus rapide et plus efficace en termes de mémoire. Cependant, l'avantage principal du hotswapping est que, lorsque le modèle est compilé avec torch.compile, le chargement du nouvel adaptateur ne nécessite pas de recompiler le modèle. Lors de l'utilisation du hotswapping, le `adapter_name` transmis doit être le nom d'un adaptateur déjà chargé. Si le nouvel adaptateur et l'ancien adaptateur ont des rangs et/ou des alphas LoRA (c'est-à-dire des échelles) différents, vous devez appeler une méthode supplémentaire avant de charger l'adaptateur : ```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 ``` Notez que le hotswapping des adaptateurs de l'encodeur de texte n'est pas encore pris en charge. Cette technique comporte d'autres limitations, documentées ici : https://huggingface.co/docs/peft/main/en/package_reference/hotswap

kwargs (`dict`, *facultatif*) : Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict).

Charge les poids LoRA spécifiés dans `pretrained_model_name_or_path_or_dict` dans `self.unet` et `self.text_encoder`.

Tous les kwargs sont transmis à `self.lora_state_dict`.

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails sur la manière dont le state dict est chargé.

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails sur la façon dont le state dict est chargé dans `self.unet`.

Voir [load_lora_into_text_encoder()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_text_encoder) pour plus de détails sur la façon dont le state dict est chargé dans `self.text_encoder`.

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

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

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

**Paramètres :**

pretrained_model_name_or_path_or_dict (`str` ou `os.PathLike` ou `dict`) : Peut être : - Une chaîne de caractères, l'*identifiant du modèle* (par exemple `google/ddpm-celebahq-256`) d'un modèle pré-entraîné hébergé sur le Hub. - Un chemin vers un *dossier* (par exemple `./my_model_directory`) contenant les poids du modèle enregistrés avec [ModelMixin.save_pretrained()](/docs/diffusers/v0.43.0/fr/api/models/overview#diffusers.ModelMixin.save_pretrained). - Un [dictionnaire d'état torch](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict).

cache_dir (`str | os.PathLike`, *facultatif*) : Chemin vers un répertoire où la configuration d'un modèle pré-entraîné téléchargé est mise en cache si le cache standard n'est pas utilisé.

force_download (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut forcer le (re)téléchargement des poids du modèle et des fichiers de configuration, en ignorant les versions mises en cache si elles existent.

proxies (`dict[str, str]`, *facultatif*) : Un dictionnaire de serveurs proxy à utiliser par protocole ou point de terminaison, par exemple, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Les proxys sont utilisés pour chaque requête.

local_files_only (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut charger uniquement les poids et les fichiers de configuration du modèle locaux. Si défini sur `True`, le modèle ne sera pas téléchargé depuis le Hub.

token (`str` ou *bool*, *facultatif*) : Le jeton à utiliser comme autorisation bearer HTTP pour les fichiers distants. Si `True`, le jeton généré par `diffusers-cli login` (stocké dans `~/.huggingface`) est utilisé.

revision (`str`, *facultatif*, par défaut `"main"`) : La version spécifique du modèle à utiliser. Il peut s'agir d'un nom de branche, d'un nom de tag, d'un identifiant de commit ou de tout identifiant autorisé par Git.

subfolder (`str`, *facultatif*, valeur par défaut `""`) : Emplacement du sous-dossier du fichier de modèle au sein d'un dépôt de modèle plus large sur le Hub ou en local.

weight_name (`str`, *facultatif*, valeur par défaut None) : Nom du fichier de dictionnaire d'état sérialisé.

return_lora_metadata (`bool`, *facultatif*, valeur par défaut : False) : Si activé, renvoie également les métadonnées de l'adaptateur LoRA, généralement présentes dans le state dict.

Retourne le dictionnaire d'état pour les poids lora et les alphas du réseau.

> [!WARNING] > Nous prenons en charge le chargement de points de contrôle LoRA au format A1111 de manière limitée. > > Cette fonction est
expérimental et susceptible de changer à l'avenir.

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

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

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

**Paramètres :**

save_directory (`str` ou `os.PathLike`) : Répertoire où enregistrer les paramètres LoRA. Sera créé s'il n'existe pas.

unet_lora_layers (`dict[str, torch.nn.Module]` ou `dict[str, torch.Tensor]`) : Dictionnaire d'état des couches LoRA correspondant à `unet`.

text_encoder_lora_layers (`dict[str, torch.nn.Module]` ou `dict[str, torch.Tensor]`) : Dictionnaire d'état des couches LoRA correspondant au `text_encoder`. Il est nécessaire de passer explicitement le dictionnaire d'état LoRA de l'encodeur de texte, car il provient de 🤗 Transformers.

is_main_process (`bool`, *facultatif*, par défaut `True`) : Indique si le processus qui appelle cette fonction est le processus principal ou non. Utile lors de l'entraînement distribué lorsque vous devez appeler cette fonction sur tous les processus. Dans ce cas, définissez `is_main_process=True` uniquement sur le processus principal pour éviter les conditions de course.

save_function (`Callable`) : La fonction à utiliser pour enregistrer le dictionnaire d'état. Utile lors de l'entraînement distribué lorsque vous devez remplacer `torch.save` par une autre méthode. Peut être configuré avec la variable d'environnement `DIFFUSERS_SAVE_MODE`.

safe_serialization (`bool`, *facultatif*, par défaut `True`) : Indique si le modèle doit être enregistré en utilisant `safetensors` ou de manière traditionnelle PyTorch avec `pickle`.

unet_lora_adapter_metadata : métadonnées de l'adaptateur LoRA associées au unet à sérialiser avec le state dict.

text_encoder_lora_adapter_metadata : métadonnées de l'adaptateur LoRA associées à l'encodeur de texte à sérialiser avec le dictionnaire d'état.

Enregistrez les paramètres LoRA correspondant à l'UNet et à l'encodeur de texte.

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

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

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

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

Charger les couches LoRA dans le [UNet2DConditionModel](/docs/diffusers/v0.43.0/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel), le [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) et le [`CLIPTextModelWithProjection`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection) de Stable Diffusion XL.

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

**Paramètres :**

state_dict (`dict`) : Un state dict standard contenant les paramètres des couches lora. La clé doit être préfixée par `text_encoder` supplémentaire afin de distinguer les couches lora de unet.

network_alphas (`dict[str, float]`) : La valeur de l'alpha du réseau utilisée pour un apprentissage stable et la prévention du sous-débordement. Cette valeur a la même signification que l'option `--network_alpha` du script d'entraînement kohya-ss. Consultez [ce lien](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).

text_encoder (`CLIPTextModel`) : le modèle d'encodeur de texte dans lequel charger les couches LoRA.

prefix (`str`) : Préfixe attendu du `text_encoder` dans le `state_dict`.

lora_scale (`float`) : Facteur d'échelle appliqué à la sortie de la couche linéaire lora avant son ajout à la sortie de la couche lora standard.

adapter_name (`str`, *facultatif*) : Nom de l'adaptateur à utiliser pour référencer le modèle d'adaptateur chargé. S'il n'est pas spécifié, `default_{i}` sera utilisé, où i est le nombre total d'adaptateurs chargés.

low_cpu_mem_usage (`bool`, *facultatif*) : Accélère le chargement du modèle en ne chargeant que les poids LoRA préentraînés et sans initialiser les poids aléatoires.

hotswap (`bool`, *facultatif*) : Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights).

metadata (`dict`) : métadonnées facultatives de l’adaptateur LoRA. Si fournies, les arguments `LoraConfig` de `peft` ne seront pas dérivés du dictionnaire d’état.

Cela chargera les couches LoRA spécifiées dans `state_dict` dans `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)
```

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

**Paramètres :**

state_dict (`dict`) : Un state dict standard contenant les paramètres des couches lora. Les clés peuvent soit être indexées directement dans le unet, soit préfixées par un `unet` supplémentaire, ce qui permet de distinguer les couches lora des encodeurs de texte.

network_alphas (`dict[str, float]`) : La valeur de l'alpha du réseau utilisée pour un apprentissage stable et la prévention du sous-débordement. Cette valeur a la même signification que l'option `--network_alpha` du script d'entraînement kohya-ss. Consultez [ce lien](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).

unet (`UNet2DConditionModel`) : Le modèle UNet dans lequel charger les couches LoRA.

adapter_name (`str`, *facultatif*) : Nom de l'adaptateur à utiliser pour référencer le modèle d'adaptateur chargé. S'il n'est pas spécifié, `default_{i}` sera utilisé, où i est le nombre total d'adaptateurs chargés.

low_cpu_mem_usage (`bool`, *facultatif*) : Accélère le chargement du modèle en ne chargeant que les poids LoRA préentraînés et sans initialiser les poids aléatoires.

hotswap (`bool`, *facultatif*) : Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights).

metadata (`dict`) : métadonnées facultatives de l’adaptateur LoRA. Si fournies, les arguments `LoraConfig` de `peft` ne seront pas dérivés du dictionnaire d’état.

Cela chargera les couches LoRA spécifiées dans `state_dict` dans `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)
```

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

**Paramètres :**

pretrained_model_name_or_path_or_dict (`str` ou `os.PathLike` ou `dict`) : Peut être : - Une chaîne de caractères, l'*identifiant du modèle* (par exemple `google/ddpm-celebahq-256`) d'un modèle pré-entraîné hébergé sur le Hub. - Un chemin vers un *dossier* (par exemple `./my_model_directory`) contenant les poids du modèle enregistrés avec [ModelMixin.save_pretrained()](/docs/diffusers/v0.43.0/fr/api/models/overview#diffusers.ModelMixin.save_pretrained). - Un [dictionnaire d'état torch](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict).

cache_dir (`str | os.PathLike`, *facultatif*) : Chemin vers un répertoire où la configuration d'un modèle pré-entraîné téléchargé est mise en cache si le cache standard n'est pas utilisé.

force_download (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut forcer le (re)téléchargement des poids du modèle et des fichiers de configuration, en ignorant les versions mises en cache si elles existent.

proxies (`dict[str, str]`, *facultatif*) : Un dictionnaire de serveurs proxy à utiliser par protocole ou point de terminaison, par exemple, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Les proxys sont utilisés pour chaque requête.

local_files_only (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut charger uniquement les poids et les fichiers de configuration du modèle locaux. Si défini sur `True`, le modèle ne sera pas téléchargé depuis le Hub.

token (`str` ou *bool*, *facultatif*) : Le jeton à utiliser comme autorisation bearer HTTP pour les fichiers distants. Si `True`, le jeton généré par `diffusers-cli login` (stocké dans `~/.huggingface`) est utilisé.

revision (`str`, *facultatif*, par défaut `"main"`) : La version spécifique du modèle à utiliser. Il peut s'agir d'un nom de branche, d'un nom de tag, d'un identifiant de commit ou de tout identifiant autorisé par Git.

subfolder (`str`, *facultatif*, valeur par défaut `""`) : Emplacement du sous-dossier du fichier de modèle au sein d'un dépôt de modèle plus large sur le Hub ou en local.

weight_name (`str`, *facultatif*, valeur par défaut None) : Nom du fichier de dictionnaire d'état sérialisé.

return_lora_metadata (`bool`, *facultatif*, valeur par défaut : False) : Si activé, renvoie également les métadonnées de l'adaptateur LoRA, généralement présentes dans le state dict.

Retourne le dictionnaire d'état pour les poids lora et les alphas du réseau.

> [!WARNING] > Nous prenons en charge le chargement de points de contrôle LoRA au format A1111 de manière limitée. > > Cette fonction est
expérimental et susceptible de changer à l'avenir.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charger les couches LoRA dans [SD3Transformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel), [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) et [`CLIPTextModelWithProjection`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection).

Spécifique à [StableDiffusion3Pipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/stable_diffusion_3#diffusers.StableDiffusion3Pipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

**Paramètres :**

state_dict (`dict`) : Un state dict standard contenant les paramètres des couches lora. La clé doit être préfixée par `text_encoder` supplémentaire afin de distinguer les couches lora de unet.

network_alphas (`dict[str, float]`) : La valeur de l'alpha du réseau utilisée pour un apprentissage stable et la prévention du sous-débordement. Cette valeur a la même signification que l'option `--network_alpha` du script d'entraînement kohya-ss. Consultez [ce lien](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).

text_encoder (`CLIPTextModel`) : le modèle d'encodeur de texte dans lequel charger les couches LoRA.

prefix (`str`) : Préfixe attendu du `text_encoder` dans le `state_dict`.

lora_scale (`float`) : Facteur d'échelle appliqué à la sortie de la couche linéaire lora avant son ajout à la sortie de la couche lora standard.

adapter_name (`str`, *facultatif*) : Nom de l'adaptateur à utiliser pour référencer le modèle d'adaptateur chargé. S'il n'est pas spécifié, `default_{i}` sera utilisé, où i est le nombre total d'adaptateurs chargés.

low_cpu_mem_usage (`bool`, *facultatif*) : Accélère le chargement du modèle en ne chargeant que les poids LoRA préentraînés et sans initialiser les poids aléatoires.

hotswap (`bool`, *facultatif*) : Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights).

metadata (`dict`) : métadonnées facultatives de l’adaptateur LoRA. Si fournies, les arguments `LoraConfig` de `peft` ne seront pas dérivés du dictionnaire d’état.

Cela chargera les couches LoRA spécifiées dans `state_dict` dans `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)
```

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charger les couches LoRA dans [FluxTransformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/flux_transformer#diffusers.FluxTransformer2DModel), [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel).

Spécifique à [FluxPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/flux#diffusers.FluxPipeline).

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

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

**Paramètres :**

state_dict (`dict`) : Un state dict standard contenant les paramètres des couches lora. La clé doit être préfixée par `text_encoder` supplémentaire afin de distinguer les couches lora de unet.

network_alphas (`dict[str, float]`) : La valeur de l'alpha du réseau utilisée pour un apprentissage stable et la prévention du sous-débordement. Cette valeur a la même signification que l'option `--network_alpha` du script d'entraînement kohya-ss. Consultez [ce lien](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).

text_encoder (`CLIPTextModel`) : le modèle d'encodeur de texte dans lequel charger les couches LoRA.

prefix (`str`) : Préfixe attendu du `text_encoder` dans le `state_dict`.

lora_scale (`float`) : Facteur d'échelle appliqué à la sortie de la couche linéaire lora avant son ajout à la sortie de la couche lora standard.

adapter_name (`str`, *facultatif*) : Nom de l'adaptateur à utiliser pour référencer le modèle d'adaptateur chargé. S'il n'est pas spécifié, `default_{i}` sera utilisé, où i est le nombre total d'adaptateurs chargés.

low_cpu_mem_usage (`bool`, *facultatif*) : Accélère le chargement du modèle en ne chargeant que les poids LoRA préentraînés et sans initialiser les poids aléatoires.

hotswap (`bool`, *facultatif*) : Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights).

metadata (`dict`) : métadonnées facultatives de l’adaptateur LoRA. Si fournies, les arguments `LoraConfig` de `peft` ne seront pas dérivés du dictionnaire d’état.

Cela chargera les couches LoRA spécifiées dans `state_dict` dans `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)
```

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

**Paramètres :**

save_directory (`str` ou `os.PathLike`) : Répertoire où enregistrer les paramètres LoRA. Sera créé s'il n'existe pas.

transformer_lora_layers (`dict[str, torch.nn.Module]` ou `dict[str, torch.Tensor]`) : Dictionnaire d'état des couches LoRA correspondant au `transformer`.

text_encoder_lora_layers (`dict[str, torch.nn.Module]` ou `dict[str, torch.Tensor]`) : Dictionnaire d'état des couches LoRA correspondant au `text_encoder`. Il est nécessaire de passer explicitement le dictionnaire d'état LoRA de l'encodeur de texte, car il provient de 🤗 Transformers.

is_main_process (`bool`, *facultatif*, par défaut `True`) : Indique si le processus qui appelle cette fonction est le processus principal ou non. Utile lors de l'entraînement distribué lorsque vous devez appeler cette fonction sur tous les processus. Dans ce cas, définissez `is_main_process=True` uniquement sur le processus principal pour éviter les conditions de course.

save_function (`Callable`) : La fonction à utiliser pour enregistrer le dictionnaire d'état. Utile lors de l'entraînement distribué lorsque vous devez remplacer `torch.save` par une autre méthode. Peut être configuré avec la variable d'environnement `DIFFUSERS_SAVE_MODE`.

safe_serialization (`bool`, *facultatif*, par défaut `True`) : Indique si le modèle doit être enregistré en utilisant `safetensors` ou de manière traditionnelle PyTorch avec `pickle`.

transformer_lora_adapter_metadata : métadonnées de l'adaptateur LoRA associées au transformateur à sérialiser avec le dictionnaire d'état.

text_encoder_lora_adapter_metadata : métadonnées de l'adaptateur LoRA associées à l'encodeur de texte à sérialiser avec le dictionnaire d'état.

Enregistrez les paramètres LoRA correspondant à l'UNet et à l'encodeur de texte.

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

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

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

**Paramètres :**

components (`list[str]`) : liste des composants injectables par LoRA dont il faut retirer l'injection de LoRA.

Annule l'effet de [`pipe.fuse_lora()`](https://huggingface.co/docs/diffusers/main/en/api/loaders#diffusers.loaders.LoraBaseMixin.fuse_lora).

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

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

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

**Paramètres :**

reset_to_overwritten_params (`bool`, par défaut `False`) : Indique s'il faut réinitialiser les modules chargés avec LoRA à leurs paramètres d'origine. Consultez la [documentation de Flux](https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux) pour en savoir plus.

Décharge les paramètres LoRA.

Exemples :

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

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

Charge les couches LoRA dans [Flux2Transformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/flux2_transformer#diffusers.Flux2Transformer2DModel). Spécifique à [Flux2Pipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/flux2#diffusers.Flux2Pipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [BriaFibo2Transformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/transformer_bria_fibo2#diffusers.BriaFibo2Transformer2DModel). Spécifique à [BriaFibo2Pipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/bria_fibo2#diffusers.BriaFibo2Pipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [ErnieImageTransformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/ernie_image_transformer2d#diffusers.ErnieImageTransformer2DModel). Spécifique à `ErnieImagePipeline`.

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [LTX2VideoTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/ltx2_video_transformer3d#diffusers.LTX2VideoTransformer3DModel). Spécifique à [LTX2Pipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/ltx2#diffusers.LTX2Pipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [CogVideoXTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/cogvideox_transformer3d#diffusers.CogVideoXTransformer3DModel). Spécifique à [CogVideoXPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/cogvideox#diffusers.CogVideoXPipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [MochiTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/mochi_transformer3d#diffusers.MochiTransformer3DModel). Spécifique à [MochiPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/mochi#diffusers.MochiPipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charger les couches LoRA dans [AuraFlowTransformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/aura_flow_transformer2d#diffusers.AuraFlowTransformer2DModel) Spécifique à [AuraFlowPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/aura_flow#diffusers.AuraFlowPipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [LTXVideoTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/ltx_video_transformer3d#diffusers.LTXVideoTransformer3DModel). Spécifique à [LTXPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/ltx_video#diffusers.LTXPipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [SanaTransformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/sana_transformer2d#diffusers.SanaTransformer2DModel). Spécifique à [SanaPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/sana#diffusers.SanaPipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [HeliosTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/helios_transformer3d#diffusers.HeliosTransformer3DModel). Spécifique à [HeliosPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/helios#diffusers.HeliosPipeline) et [HeliosPyramidPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/helios#diffusers.HeliosPyramidPipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [HunyuanVideoTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/hunyuan_video_transformer_3d#diffusers.HunyuanVideoTransformer3DModel). Spécifique à [HunyuanVideoPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/hunyuan_video#diffusers.HunyuanVideoPipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [Lumina2Transformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/lumina2_transformer2d#diffusers.Lumina2Transformer2DModel). Spécifique à [Lumina2Pipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/lumina2#diffusers.Lumina2Pipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [WanTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel). Spécifique à [CogView4Pipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/cogview4#diffusers.CogView4Pipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [WanTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel). Spécifique à [WanPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/wan#diffusers.WanPipeline) et `[WanImageToVideoPipeline`.

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charger les couches LoRA dans [SkyReelsV2Transformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/skyreels_v2_transformer_3d#diffusers.SkyReelsV2Transformer3DModel).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

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

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

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

**Paramètres :**

save_directory (`str` ou `os.PathLike`) : Répertoire où enregistrer les paramètres LoRA. Sera créé s'il n'existe pas.

unet_lora_layers (`dict[str, torch.nn.Module]` ou `dict[str, torch.Tensor]`) : Dictionnaire d'état des couches LoRA correspondant à `unet`.

text_encoder_lora_layers (`dict[str, torch.nn.Module]` ou `dict[str, torch.Tensor]`) : Dictionnaire d'état des couches LoRA correspondant au `text_encoder`. Il est nécessaire de passer explicitement le dictionnaire d'état LoRA de l'encodeur de texte, car il provient de 🤗 Transformers.

is_main_process (`bool`, *facultatif*, par défaut `True`) : Indique si le processus qui appelle cette fonction est le processus principal ou non. Utile lors de l'entraînement distribué lorsque vous devez appeler cette fonction sur tous les processus. Dans ce cas, définissez `is_main_process=True` uniquement sur le processus principal pour éviter les conditions de course.

save_function (`Callable`) : La fonction à utiliser pour enregistrer le dictionnaire d'état. Utile lors de l'entraînement distribué lorsque vous devez remplacer `torch.save` par une autre méthode. Peut être configuré avec la variable d'environnement `DIFFUSERS_SAVE_MODE`.

safe_serialization (`bool`, *facultatif*, par défaut `True`) : Indique si le modèle doit être enregistré en utilisant `safetensors` ou de manière traditionnelle PyTorch avec `pickle`.

Enregistrez les paramètres LoRA correspondant à l'UNet et à l'encodeur de texte.

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

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

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

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

Charger les couches LoRA dans [CosmosTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel) et [AnimaTextConditioner](/docs/diffusers/v0.43.0/fr/api/pipelines/anima#diffusers.AnimaTextConditioner).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [AceStepTransformer1DModel](/docs/diffusers/v0.43.0/fr/api/models/ace_step_transformer#diffusers.AceStepTransformer1DModel). Spécifique à [AceStepPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/ace_step#diffusers.AceStepPipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [HiDreamImageTransformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/hidream_image_transformer#diffusers.HiDreamImageTransformer2DModel). Spécifique à [HiDreamImagePipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/hidream#diffusers.HiDreamImagePipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [QwenImageTransformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel). Spécifique à [QwenImagePipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/qwenimage#diffusers.QwenImagePipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [ZImageTransformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/z_image_transformer2d#diffusers.ZImageTransformer2DModel). Spécifique à [ZImagePipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/z_image#diffusers.ZImagePipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charger les couches LoRA dans [CosmosTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel), spécifique à [Cosmos2_5_PredictBasePipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/cosmos#diffusers.Cosmos2_5_PredictBasePipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charger les couches LoRA dans `Kandinsky5Transformer3DModel`,

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

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

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

Charge les couches LoRA dans [Ideogram4Transformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/ideogram4_transformer2d#diffusers.Ideogram4Transformer2DModel). Spécifique à [Ideogram4Pipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/ideogram4#diffusers.Ideogram4Pipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

```python
diffusers.loaders.Krea2LoraLoaderMixin()
```

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

Charge les couches LoRA dans [Krea2Transformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/krea2_transformer2d#diffusers.Krea2Transformer2DModel). Spécifique à [Krea2Pipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/krea2#diffusers.Krea2Pipeline).

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

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Voir [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Voir [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

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

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

```python
diffusers.loaders.MiniMaxH3LoraLoaderMixin()
```

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

Charge les couches LoRA dans [MiniMaxH3Transformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/minimax_h3_transformer3d#diffusers.MiniMaxH3Transformer3DModel). Spécifique à [MiniMaxH3ModularPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/minimax_h3#diffusers.MiniMaxH3ModularPipeline).

MiniMax-H3 embarque deux partitions DiT indépendantes portant des noms de modules identiques (un LoRA destiné à l’une se charge dans l’autre et dégrade la sortie), la routage est donc explicite : les dictionnaires d’état convertis ciblent `transformer.` ; pour accéder à `transformer_ref`, utilisez un fichier préfixé par `transformer_ref.` ou `load_into_transformer_ref=True`.

Les LoRA de DiffSynth-Studio (par exemple [DiffSynth-Studio/MiniMax-H3-LoRA-LineartAnime](https://huggingface.co/DiffSynth-Studio/MiniMax-H3-LoRA-LineartAnime)) sont entraînés sur le QKV fusionné par tête et entrelacé du point de contrôle brut, puis désentrelacés lors de la conversion. Leurs facteurs fp32 font que le chemin LoRA non fusionné effectue les calculs en fp32 ; l'application de `.to(torch.bfloat16)` au modèle après chargement restaure le budget mémoire bf16.

Les LoRAs entraînés sur un point de contrôle élagué (les fichiers `*_pruned_*` dans [Comfy-Org/MiniMax-H3](https://huggingface.co/Comfy-Org/MiniMax-H3) ; [joyfox/MiniMax-H3-Turbo](https://huggingface.co/joyfox/MiniMax-H3-Turbo) en est un) échouent avec une erreur de correspondance de taille. Les fichiers sans `alpha == rank` sont chargés avec `alpha == rank` (échelle 1.0, la convention énoncée par exemple par [larryvrh/MiniMax-H3-Turbo-Lora](https://huggingface.co/larryvrh/MiniMax-H3-Turbo-Lora)) ; une entrée `__metadata__` `alpha` (par exemple le fichier 8 étapes de [lightx2v/Minimax-h3-Turbo](https://huggingface.co/lightx2v/Minimax-h3-Turbo)), lorsqu'elle est présente, est prise en compte à la place.

#### fuse_lora[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.fuse_lora]]

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

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

Voir `fuse_lora()` pour plus de détails.

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

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

Voir [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

Chargez les couches LoRA dans la partition `transformer_ref`. `prefix` est le nom du composant porté par les clés, qui est `transformer_ref` pour un fichier qui nomme la partition et `transformer` pour un fichier routé ici par `load_into_transformer_ref=True`. Consultez [load_lora_into_unet()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) pour plus de détails.

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

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

**Paramètres :**

load_into_transformer_ref (`bool`, par défaut `False`) : Charge les couches préfixées par `transformer.` dans la partition `transformer_ref` — celle avec laquelle le workflow `ref2va` effectue le débruitage — au lieu de `transformer`. Nécessaire uniquement lorsque les deux partitions sont chargées : un pipeline qui ne détient que `transformer_ref` y achemine les opérations de lui-même.

Charge les couches LoRA dans `transformer` ou, avec `load_into_transformer_ref=True`, dans `transformer_ref`. Consultez [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour plus de détails.

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

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

Voir [lora_state_dict()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) pour plus de détails.

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

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

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

Enregistrez les couches LoRA d’une ou des deux partitions de MiniMax-H3. Il est impossible de déterminer à quelle partition appartient un LoRA à partir de ses clés ; c’est donc la seule manière de publier un LoRA H3 qui le consigne. Consultez [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour plus d’informations.

#### unfuse_lora[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.unfuse_lora]]

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

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

Voir `unfuse_lora()` pour plus de détails.

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

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

```python
diffusers.loaders.PikaH3FlexLoraLoaderMixin()
```

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

Charge les couches LoRA dans [MiniMaxH3Transformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/minimax_h3_transformer3d#diffusers.MiniMaxH3Transformer3DModel). Spécifique à [PikaH3FlexModularPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/pika_h3_flex#diffusers.PikaH3FlexModularPipeline).

La sortie Pika H3 Flex *est* une paire d'adaptateurs de rang 128 sur les deux partitions de transformeurs MiniMax-H3, publiées sous forme de dumps PEFT simples portant les noms de modules diffusers (`fl2va/adapter.safetensors` pour `transformer`, `ref2va/adapter.safetensors` pour `transformer_ref`). Les fichiers sans alpha se chargent avec `alpha == rank` (échelle 1.0), le contrat propre aux adaptateurs, et le chargement, le routage et la sauvegarde sont ceux de `MiniMaxH3LoraLoaderMixin` : l'adaptateur `fl2va` est placé dans `transformer`, et l'adaptateur `ref2va` dans `transformer_ref` — seul lorsque le pipeline détient cette partition à elle seule (`workflow="ref2va"`), avec `load_into_transformer_ref=True` lorsqu'il détient les deux.

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

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

Classe utilitaire pour la gestion des LoRA.

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

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

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

**Paramètres :**

adapter_names (`list[str, str]`) : Les noms des adaptateurs à supprimer.

Supprimer les couches LoRA d'un adaptateur du pipeline.

Exemple :

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

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

Désactive les couches LoRA actives du pipeline.

Exemple :

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

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

Active les couches LoRA actives du pipeline.

Exemple :

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

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

**Paramètres :**

target_rank (`int`) : Le rang le plus élevé parmi tous les adaptateurs qui seront chargés.

check_compiled (`str`, *facultatif*, par défaut `"error"`) : Comment gérer un modèle déjà compilé. La vérification peut renvoyer les messages suivants : - "error" (par défaut) : lever une erreur - "warn" : émettre un avertissement - "ignore" : ne rien faire

Chauder les adaptateurs sans déclencher la recompilation d'un modèle ou si les rangs des adaptateurs chargés sont différents.

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

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

**Paramètres :**

components : (`list[str]`) : liste des composants injectables par LoRA dans lesquels fusionner les LoRA.

lora_scale (`float`, par défaut 1.0) : Contrôle dans quelle mesure les paramètres LoRA influencent les sorties.

safe_fusing (`bool`, par défaut `False`) : Indique s'il faut vérifier les poids fusionnés pour détecter des valeurs NaN avant la fusion, et, si des valeurs sont NaN, de ne pas les fusionner.

adapter_names (`list[str]`, *facultatif*) : Noms des adaptateurs à utiliser pour la fusion. Si rien n'est transmis, tous les adaptateurs actifs seront fusionnés.

Fond les paramètres LoRA dans les paramètres originaux des blocs correspondants.

Exemple :

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

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

Renvoie la liste des adaptateurs actifs actuels.

Exemple :

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

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

Renvoie la liste actuelle de tous les adaptateurs disponibles dans le pipeline.

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

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

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

**Paramètres :**

adapter_names (`list[str]` ou `str`) : Les noms des adaptateurs à utiliser.

adapter_weights (`float`, `dict` ou `list`, *facultatif*) : Poids pour les adaptateurs. Un scalaire met à l'échelle tous les composants compatibles LoRA. Un dictionnaire associe les noms de composants (par ex. `"unet"`, `"transformer"` ou `"text_encoder"`) à des poids ; le poids d'un composant UNet peut également être un dictionnaire imbriqué d'échelles de blocs. Un scalaire ou un dictionnaire unique est appliqué à chaque adaptateur. Une liste doit contenir un scalaire, un dictionnaire ou `None` par adaptateur, dans l'ordre de `adapter_names`. `None` est par défaut `1.0`, y compris pour les entrées de liste et les poids des composants. Les composants non spécifiés et les blocs UNet sont également par défaut `1.0`.

Définissez les adaptateurs actuellement actifs pour leur utilisation dans le pipeline.

Exemple :

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

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

**Paramètres :**

adapter_names (`list[str]`) : liste des adaptateurs à envoyer vers l'appareil.

device (`torch.device | str | int`) : Appareil vers lequel envoyer les adaptateurs. Peut être un appareil torch, une chaîne de caractères ou un entier.

Déplace les LoRA listés dans `adapter_names` vers un appareil cible. Utile pour décharger le LoRA sur le CPU si vous souhaitez charger plusieurs adaptateurs et libérer de la mémoire GPU.

Après avoir déchargé les adaptateurs LoRA sur le CPU, tant que le reste du modèle est toujours sur le GPU, les adaptateurs LoRA ne peuvent plus être utilisés pour l'inférence, car cela provoquerait une incompatibilité de périphérique. Pensez à réinitialiser le périphérique sur le GPU avant d'utiliser ces adaptateurs LoRA pour l'inférence.

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

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

**Paramètres :**

components (`list[str]`) : liste des composants injectables par LoRA dont il faut retirer l'injection de LoRA.

unfuse_unet (`bool`, par défaut `True`) : Indique s'il faut désfusionner les paramètres LoRA du UNet.

unfuse_text_encoder (`bool`, par défaut `True`) : Indique s'il faut désfusionner les paramètres LoRA de l'encodeur de texte. Si l'encodeur de texte n'a pas été modifié (monkey-patched) avec les paramètres LoRA, cela n'aura aucun effet.

Annule l'effet de [`pipe.fuse_lora()`](https://huggingface.co/docs/diffusers/main/en/api/loaders#diffusers.loaders.LoraBaseMixin.fuse_lora).

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

```python
unload_lora_weights()
```

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

Décharge les paramètres LoRA.

Exemples :

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

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

Écrit le dictionnaire d'état des couches LoRA (éventuellement avec des métadonnées) sur le disque.