Buckets:
# LoRA
LoRA é um método de treinamento rápido e leve que insere e treina um número significativamente menor de parâmetros, em vez de todos os parâmetros do modelo. Isso gera um arquivo menor (~100 MBs) e facilita o treinamento rápido de um modelo para aprender um novo conceito. Os pesos do LoRA são tipicamente carregados no denoiser, no text encoder ou em ambos. O denoiser geralmente corresponde a um UNet ([UNet2DConditionModel](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel), por exemplo) ou a um Transformer ([SD3Transformer2DModel](/docs/diffusers/main/pt/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel), por exemplo). Existem várias classes para carregar pesos do LoRA:
- `StableDiffusionLoraLoaderMixin` fornece funções para carregar e descarregar, fundir e desfazer a fusão, habilitar e desabilitar, além de outras funções para gerenciar pesos LoRA. Esta classe pode ser usada com qualquer modelo.
- `StableDiffusionXLLoraLoaderMixin` é uma versão [Stable Diffusion (SDXL)](../../api/pipelines/stable_diffusion/stable_diffusion_xl) da classe `StableDiffusionLoraLoaderMixin` para carregar e salvar pesos de LoRA. Ela só pode ser usada com o modelo SDXL.
- `SD3LoraLoaderMixin` fornece funções semelhantes para [Stable Diffusion 3](https://huggingface.co/blog/sd3).
- `FluxLoraLoaderMixin` fornece funções semelhantes para [Flux](../pipelines/flux).
- `CogVideoXLoraLoaderMixin` fornece funções semelhantes para [CogVideoX](../pipelines/cogvideox).
- `Mochi1LoraLoaderMixin` fornece funções semelhantes para [Mochi](../pipelines/mochi).
- `AuraFlowLoraLoaderMixin` fornece funções semelhantes para [AuraFlow](https://huggingface.co/fal/AuraFlow).
- `LTXVideoLoraLoaderMixin` fornece funções semelhantes para [LTX-Video](../pipelines/ltx_video).
- `SanaLoraLoaderMixin` fornece funções semelhantes para [Sana](../pipelines/sana).
- `HeliosLoraLoaderMixin` fornece funções semelhantes para [HunyuanVideo](../pipelines/helios).
- `HunyuanVideoLoraLoaderMixin` fornece funções semelhantes para [HunyuanVideo](../pipelines/hunyuan_video).
- `Lumina2LoraLoaderMixin` fornece funções semelhantes para [Lumina2](../pipelines/lumina2).
- `WanLoraLoaderMixin` fornece funções semelhantes para [Wan](../pipelines/wan).
- `SkyReelsV2LoraLoaderMixin` fornece funções semelhantes para [SkyReels-V2](../pipelines/skyreels_v2).
- `CogView4LoraLoaderMixin` fornece funções semelhantes para [CogView4](../pipelines/cogview4).
- `AmusedLoraLoaderMixin` é para o `AmusedPipeline`.
- `AnimaLoraLoaderMixin` fornece funções semelhantes para [Anima](../pipelines/anima).
- `AceStepLoraLoaderMixin` fornece funções semelhantes para [ACE-Step](../pipelines/ace_step).
- `HiDreamImageLoraLoaderMixin` fornece funções semelhantes para [HiDream Image](../pipelines/hidream)
- `QwenImageLoraLoaderMixin` fornece funções semelhantes para [Qwen Image](../pipelines/qwenimage).
- `ZImageLoraLoaderMixin` fornece funções semelhantes para [Z-Image](../pipelines/z_image).
- `Flux2LoraLoaderMixin` fornece funções semelhantes para [Flux2](../pipelines/flux2).
- `ErnieImageLoraLoaderMixin` fornece funções semelhantes para [Ernie-Image](../pipelines/ernie_image).
- `LTX2LoraLoaderMixin` fornece funções semelhantes para [Flux2](../pipelines/ltx2).
- `MiniMaxH3LoraLoaderMixin` fornece funções semelhantes para [MiniMax-H3](../pipelines/minimax_h3).
- `PikaH3FlexLoraLoaderMixin` fornece funções semelhantes para [Pika H3 Flex](../pipelines/pika_h3_flex).
- `RFD4ProteinaLoraLoaderMixin` fornece funções semelhantes para [RFD4-Proteína](../pipelines/rfd4_proteina).
- `BriaFibo2LoraLoaderMixin` fornece funções semelhantes para [fibo-2](../pipelines/bria_fibo2).
- `LoraBaseMixin` fornece uma classe base com vários métodos utilitários para fundir, desfazer a fusão, descarregar LoRAs e mais.
> [!TIP]
> Para saber mais sobre como carregar pesos LoRA, consulte o guia de carregamento de [LoRA](../../tutorials/using_peft_for_inference).
## RFD4ProteinaLoraLoaderMixin[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin]]
#### diffusers.loaders.RFD4ProteinaLoraLoaderMixin[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin]]
```python
diffusers.loaders.RFD4ProteinaLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7532)
Carregue as camadas LoRA em [RFD4ProteinaTransformer](/docs/diffusers/main/pt/api/models/rfd4_proteina_transformer#diffusers.RFD4ProteinaTransformer).
O autoencoder é pareado com o checkpoint do denoiser e não é adaptado, portanto, o transformer é o único módulo carregável.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7694)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7631)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7595)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7543)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7658)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7714)
Veja `unfuse_lora()` para mais detalhes.
## LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]
#### diffusers.loaders.lora_base.LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]
```python
diffusers.loaders.lora_base.LoraBaseMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L491)
Classe utilitária para lidar com LoRAs.
#### delete_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.delete_adapters]]
```python
delete_adapters(adapter_names: list[str] | str)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L873)
**Parâmetros:**
adapter_names (`list[str, str]`) : Os nomes dos adaptadores a serem excluídos.
Exclua as camadas LoRA de um adaptador do pipeline.
Exemplo:
```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()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L813)
Desativa as camadas LoRA ativas do pipeline.
Exemplo:
```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()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L843)
Ativa as camadas LoRA ativas do pipeline.
Exemplo:
```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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L1020)
**Parâmetros:**
target_rank (`int`) : O maior rank entre todos os adaptadores que serão carregados.
check_compiled (`str`, *opcional*, padrão `"error"`) : Como lidar com um modelo que já está compilado. A verificação pode retornar as seguintes mensagens: - "error" (padrão): lança um erro - "warn": emite um aviso - "ignore": não faz nada
Troque adaptadores a quente sem acionar a recompilação de um modelo ou quando as classes dos adaptadores carregados forem diferentes.
#### fuse_lora[[diffusers.loaders.lora_base.LoraBaseMixin.fuse_lora]]
```python
fuse_lora(components: list[str] | None = None, lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L549)
**Parâmetros:**
components : (`list[str]`): lista dos componentes injetáveis de LoRA nos quais fundir os LoRAs.
lora_scale (`float`, padrão 1.0) : Controla o quanto os parâmetros LoRA influenciam as saídas.
safe_fusing (`bool`, padrão `False`) : Se deve verificar os pesos fundidos em busca de valores NaN antes da fusão e, se os valores forem NaN, não fundi-los.
adapter_names (`list[str]`, *opcional*) : Nomes dos adaptadores a serem usados para fusão. Se nada for passado, todos os adaptadores ativos serão fundidos.
Funde os parâmetros do LoRA nos parâmetros originais dos blocos correspondentes.
Exemplo:
```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()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L911)
Obtém a lista dos adaptadores ativos atuais.
Exemplo:
```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()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L944)
Obtém a lista atual de todos os adaptadores disponíveis no 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L698)
**Parâmetros:**
adapter_names (`list[str]` ou `str`) : Os nomes dos adaptadores a serem usados.
adapter_weights (`float`, `dict` ou `list`, *opcional*) : Pesos para os adaptadores. Um escalar escala todos os componentes compatíveis com LoRA. Um dicionário mapeia nomes de componentes (por exemplo, `"unet"`, `"transformer"` ou `"text_encoder"`) para pesos; o peso de um componente UNet também pode ser um dicionário aninhado de escalas de blocos. Um único escalar ou dicionário é aplicado a cada adaptador. Uma lista deve conter um escalar, dicionário ou `None` por adaptador, na ordem de `adapter_names`. `None` tem valor padrão de `1.0`, incluindo entradas de lista e pesos de componentes. Componentes não especificados e blocos UNet também têm valor padrão de `1.0`.
Defina os adaptadores atualmente ativos para uso no pipeline.
Exemplo:
```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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L966)
**Parâmetros:**
adapter_names (`list[str]`) : lista de adaptadores para enviar o dispositivo.
device (`torch.device | str | int`) : Dispositivo para onde enviar os adaptadores. Pode ser um dispositivo torch, uma str ou um inteiro.
Move os LoRAs listados em `adapter_names` para um dispositivo de destino. Útil para descarregar o LoRA para a CPU, caso você queira carregar vários adaptadores e liberar alguma memória de GPU.
Após descarregar os adaptadores LoRA para a CPU, desde que o restante do modelo ainda esteja na GPU, os adaptadores LoRA não podem mais ser usados para inferência, pois isso causaria uma incompatibilidade de dispositivos. Lembre-se de definir o dispositivo de volta para a GPU antes de usar esses adaptadores LoRA para inferência.
```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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L636)
**Parâmetros:**
components (`list[str]`) : lista de componentes injetáveis de LoRA dos quais desfazer a fusão do LoRA.
unfuse_unet (`bool`, padrão `True`) : Se deve desfazer a fusão dos parâmetros LoRA do UNet.
unfuse_text_encoder (`bool`, padrão `True`) : Se deve desfazer a fusão dos parâmetros LoRA do codificador de texto. Se o codificador de texto não foi modificado com os parâmetros LoRA, isso não terá nenhum efeito.
Reverte o efeito 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()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L526)
Descarrega os parâmetros do LoRA.
Exemplos:
```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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L1043)
Escreve o state dict das camadas LoRA (opcionalmente com metadados) no disco.
## StableDiffusionLoraLoaderMixin[[diffusers.loaders.StableDiffusionLoraLoaderMixin]]
#### diffusers.loaders.StableDiffusionLoraLoaderMixin[[diffusers.loaders.StableDiffusionLoraLoaderMixin]]
```python
diffusers.loaders.StableDiffusionLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L138)
Carregue as camadas LoRA no [UNet2DConditionModel](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel) e no [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) do 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L408)
**Parâmetros:**
state_dict (`dict`) : Um state dict padrão contendo os parâmetros das camadas lora. A chave deve ser prefixada com um adicional `text_encoder` para distinguir entre as camadas lora do unet.
network_alphas (`dict[str, float]`) : O valor do alfa da rede usado para aprendizado estável e prevenção de underflow. Este valor tem o mesmo significado que a opção `--network_alpha` no script de treinamento do kohya-ss. Consulte [este link](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).
text_encoder (`CLIPTextModel`) : O modelo de codificador de texto em que as camadas LoRA serão carregadas.
prefix (`str`) : Prefixo esperado do `text_encoder` no `state_dict`.
lora_scale (`float`) : Em quanto escalar a saída da camada linear lora antes de ser somada à saída da camada lora regular.
adapter_name (`str`, *opcional*) : Nome do adaptador a ser usado para referenciar o modelo de adaptador carregado. Se não for especificado, será usado `default_{i}`, onde i é o número total de adaptadores sendo carregados.
low_cpu_mem_usage (`bool`, *opcional*) : Acelera o carregamento do modelo carregando apenas os pesos LoRA pré-treinados e não inicializando os pesos aleatórios.
hotswap (`bool`, *opcional*) : Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights).
metadata (`dict`) : Metadados opcionais do adaptador LoRA. Quando fornecidos, os argumentos de `LoraConfig` do `peft` não serão derivados do state dict.
Isso carregará as camadas LoRA especificadas em `state_dict` em `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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L354)
**Parâmetros:**
state_dict (`dict`) : Um state dict padrão contendo os parâmetros das camadas lora. As chaves podem ser indexadas diretamente no unet ou prefixadas com um `unet` adicional, o que pode ser usado para distinguir entre as camadas lora do text encoder.
network_alphas (`dict[str, float]`) : O valor do alfa da rede usado para aprendizado estável e prevenção de underflow. Este valor tem o mesmo significado que a opção `--network_alpha` no script de treinamento do kohya-ss. Consulte [este link](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).
unet (`UNet2DConditionModel`) : O modelo UNet para carregar as camadas LoRA.
adapter_name (`str`, *opcional*) : Nome do adaptador a ser usado para referenciar o modelo de adaptador carregado. Se não for especificado, será usado `default_{i}`, onde i é o número total de adaptadores sendo carregados.
low_cpu_mem_usage (`bool`, *opcional*) : Acelera o carregamento do modelo carregando apenas os pesos LoRA pré-treinados e não inicializando os pesos aleatórios.
hotswap (`bool`, *opcional*) : Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights).
metadata (`dict`) : Metadados opcionais do adaptador LoRA. Quando fornecidos, os argumentos de `LoraConfig` do `peft` não serão derivados do state dict.
Isso carregará as camadas LoRA especificadas em `state_dict` em `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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L148)
**Parâmetros:**
pretrained_model_name_or_path_or_dict (`str` ou `os.PathLike` ou `dict`) : Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict).
adapter_name (`str`, *opcional*) : Nome do adaptador a ser usado para referenciar o modelo de adaptador carregado. Se não for especificado, será usado `default_{i}`, onde i é o número total de adaptadores sendo carregados.
low_cpu_mem_usage (`bool`, *opcional*) : Acelera o carregamento do modelo carregando apenas os pesos LoRA pré-treinados e não inicializando os pesos aleatórios.
hotswap (`bool`, *opcional*) : O padrão é `False`. Se deve substituir um adaptador (LoRA) existente pelo adaptador recém-carregado no local. Isso significa que, em vez de carregar um adaptador adicional, isso pegará os pesos do adaptador existente e os substituirá pelos pesos do novo adaptador. Isso pode ser mais rápido e eficiente em termos de memória. No entanto, a principal vantagem do hotswap é que, quando o modelo é compilado com torch.compile, o carregamento do novo adaptador não requer a recompilação do modelo. Ao usar hotswap, o `adapter_name` passado deve ser o nome de um adaptador já carregado. Se o novo adaptador e o antigo tiverem ranks e/ou alfas LoRA (ou seja, escalonamento) diferentes, você precisa chamar um método adicional antes de carregar o adaptador: ```py pipeline = ... # load diffusers pipeline max_rank = ... # the highest rank among all LoRAs that you want to load # call *before* compiling and loading the LoRA adapter pipeline.enable_lora_hotswap(target_rank=max_rank) pipeline.load_lora_weights(file_name) # optionally compile the model now ``` Observe que o hotswap de adaptadores do codificador de texto ainda não é suportado. Existem algumas limitações adicionais a essa técnica, que estão documentadas aqui: https://huggingface.co/docs/peft/main/en/package_reference/hotswap
kwargs (`dict`, *opcional*) : Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict).
Carrega os pesos LoRA especificados em `pretrained_model_name_or_path_or_dict` para `self.unet` e `self.text_encoder`.
Todos os kwargs são encaminhados para `self.lora_state_dict`.
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes sobre como o state dict é carregado.
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes sobre como o state dict é carregado em `self.unet`.
Veja [load_lora_into_text_encoder()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_text_encoder) para mais detalhes sobre como o state dict é carregado em `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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L243)
**Parâmetros:**
pretrained_model_name_or_path_or_dict (`str` ou `os.PathLike` ou `dict`) : Pode ser: - Uma string, o *model id* (por exemplo `google/ddpm-celebahq-256`) de um modelo pré-treinado hospedado no Hub. - Um caminho para um *diretório* (por exemplo `./my_model_directory`) contendo os pesos do modelo salvos com [ModelMixin.save_pretrained()](/docs/diffusers/main/pt/api/models/overview#diffusers.ModelMixin.save_pretrained). - Um [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict).
cache_dir (`str | os.PathLike`, *opcional*) : Caminho para um diretório onde a configuração de um modelo pré-treinado baixado é armazenada em cache, caso o cache padrão não seja utilizado.
force_download (`bool`, *opcional*, padrão `False`) : Se deve forçar o (re-)download dos pesos do modelo e dos arquivos de configuração, sobrescrevendo as versões em cache, caso existam.
proxies (`dict[str, str]`, *opcional*) : Um dicionário de servidores proxy a serem usados por protocolo ou endpoint, por exemplo, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Os proxies são usados em cada solicitação.
local_files_only (`bool`, *opcional*, padrão `False`) : Se deve carregar apenas os pesos e os arquivos de configuração do modelo localmente ou não. Se definido como `True`, o modelo não será baixado do Hub.
token (`str` ou *bool*, *opcional*) : O token a ser usado como autorização HTTP bearer para arquivos remotos. Se `True`, o token gerado por `diffusers-cli login` (armazenado em `~/.huggingface`) é utilizado.
revision (`str`, *opcional*, padrão `"main"`) : A versão específica do modelo a ser usada. Pode ser o nome de um branch, o nome de uma tag, um id de commit ou qualquer identificador permitido pelo Git.
subfolder (`str`, *opcional*, padrão `""`) : A localização da subpasta de um arquivo de modelo dentro de um repositório de modelo maior no Hub ou localmente.
weight_name (`str`, *opcional*, padrão None) : Nome do arquivo de state dict serializado.
return_lora_metadata (`bool`, *opcional*, padrão é False) : Quando habilitado, retorna adicionalmente os metadados do adaptador LoRA, geralmente encontrados no state dict.
Retorna o state dict para os pesos do lora e os alfas da rede.
> [!WARNING] > Suportamos o carregamento de checkpoints LoRA formatados no A1111 em capacidade limitada. > > Esta função é
experimental e pode mudar no futuro.
#### save_lora_weights[[diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights]]
```python
save_lora_weights(save_directory: str | os.PathLike, unet_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_lora_layers: dict[str, torch.nn.Module] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, unet_lora_adapter_metadata = None, text_encoder_lora_adapter_metadata = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L466)
**Parâmetros:**
save_directory (`str` ou `os.PathLike`) : Diretório para salvar os parâmetros LoRA. Será criado se não existir.
unet_lora_layers (`dict[str, torch.nn.Module]` ou `dict[str, torch.Tensor]`) : State dict das camadas LoRA correspondentes ao `unet`.
text_encoder_lora_layers (`dict[str, torch.nn.Module]` ou `dict[str, torch.Tensor]`) : State dict das camadas LoRA correspondentes ao `text_encoder`. É necessário passar explicitamente o state dict do LoRA do text encoder, pois ele vem do 🤗 Transformers.
is_main_process (`bool`, *opcional*, padrão `True`) : Indica se o processo que está chamando esta função é o processo principal ou não. Útil durante o treinamento distribuído, quando é necessário chamar esta função em todos os processos. Nesse caso, defina `is_main_process=True` apenas no processo principal para evitar condições de corrida.
save_function (`Callable`) : A função a ser usada para salvar o dicionário de estado. Útil durante o treinamento distribuído quando você precisa substituir `torch.save` por outro método. Pode ser configurado com a variável de ambiente `DIFFUSERS_SAVE_MODE`.
safe_serialization (`bool`, *opcional*, padrão `True`) : Se o modelo deve ser salvo usando `safetensors` ou da maneira tradicional do PyTorch com `pickle`.
unet_lora_adapter_metadata : Metadados do adaptador LoRA associados ao unet a serem serializados com o state dict.
text_encoder_lora_adapter_metadata : Metadados do adaptador LoRA associados ao codificador de texto a serem serializados com o state dict.
Salve os parâmetros do LoRA correspondentes ao UNet e ao codificador de texto.
## StableDiffusionXLLoraLoaderMixin[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin]]
#### diffusers.loaders.StableDiffusionXLLoraLoaderMixin[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin]]
```python
diffusers.loaders.StableDiffusionXLLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L585)
Carregue as camadas LoRA no [UNet2DConditionModel](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel), no [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) e no [`CLIPTextModelWithProjection`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection) do 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L938)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L831)
**Parâmetros:**
state_dict (`dict`) : Um state dict padrão contendo os parâmetros das camadas lora. A chave deve ser prefixada com um adicional `text_encoder` para distinguir entre as camadas lora do unet.
network_alphas (`dict[str, float]`) : O valor do alfa da rede usado para aprendizado estável e prevenção de underflow. Este valor tem o mesmo significado que a opção `--network_alpha` no script de treinamento do kohya-ss. Consulte [este link](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).
text_encoder (`CLIPTextModel`) : O modelo de codificador de texto em que as camadas LoRA serão carregadas.
prefix (`str`) : Prefixo esperado do `text_encoder` no `state_dict`.
lora_scale (`float`) : Em quanto escalar a saída da camada linear lora antes de ser somada à saída da camada lora regular.
adapter_name (`str`, *opcional*) : Nome do adaptador a ser usado para referenciar o modelo de adaptador carregado. Se não for especificado, será usado `default_{i}`, onde i é o número total de adaptadores sendo carregados.
low_cpu_mem_usage (`bool`, *opcional*) : Acelera o carregamento do modelo carregando apenas os pesos LoRA pré-treinados e não inicializando os pesos aleatórios.
hotswap (`bool`, *opcional*) : Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights).
metadata (`dict`) : Metadados opcionais do adaptador LoRA. Quando fornecidos, os argumentos de `LoraConfig` do `peft` não serão derivados do state dict.
Isso carregará as camadas LoRA especificadas em `state_dict` em `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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L776)
**Parâmetros:**
state_dict (`dict`) : Um state dict padrão contendo os parâmetros das camadas lora. As chaves podem ser indexadas diretamente no unet ou prefixadas com um `unet` adicional, o que pode ser usado para distinguir entre as camadas lora do text encoder.
network_alphas (`dict[str, float]`) : O valor do alfa da rede usado para aprendizado estável e prevenção de underflow. Este valor tem o mesmo significado que a opção `--network_alpha` no script de treinamento do kohya-ss. Consulte [este link](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).
unet (`UNet2DConditionModel`) : O modelo UNet para carregar as camadas LoRA.
adapter_name (`str`, *opcional*) : Nome do adaptador a ser usado para referenciar o modelo de adaptador carregado. Se não for especificado, será usado `default_{i}`, onde i é o número total de adaptadores sendo carregados.
low_cpu_mem_usage (`bool`, *opcional*) : Acelera o carregamento do modelo carregando apenas os pesos LoRA pré-treinados e não inicializando os pesos aleatórios.
hotswap (`bool`, *opcional*) : Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights).
metadata (`dict`) : Metadados opcionais do adaptador LoRA. Quando fornecidos, os argumentos de `LoraConfig` do `peft` não serão derivados do state dict.
Isso carregará as camadas LoRA especificadas em `state_dict` em `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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L596)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L664)
**Parâmetros:**
pretrained_model_name_or_path_or_dict (`str` ou `os.PathLike` ou `dict`) : Pode ser: - Uma string, o *model id* (por exemplo `google/ddpm-celebahq-256`) de um modelo pré-treinado hospedado no Hub. - Um caminho para um *diretório* (por exemplo `./my_model_directory`) contendo os pesos do modelo salvos com [ModelMixin.save_pretrained()](/docs/diffusers/main/pt/api/models/overview#diffusers.ModelMixin.save_pretrained). - Um [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict).
cache_dir (`str | os.PathLike`, *opcional*) : Caminho para um diretório onde a configuração de um modelo pré-treinado baixado é armazenada em cache, caso o cache padrão não seja utilizado.
force_download (`bool`, *opcional*, padrão `False`) : Se deve forçar o (re-)download dos pesos do modelo e dos arquivos de configuração, sobrescrevendo as versões em cache, caso existam.
proxies (`dict[str, str]`, *opcional*) : Um dicionário de servidores proxy a serem usados por protocolo ou endpoint, por exemplo, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Os proxies são usados em cada solicitação.
local_files_only (`bool`, *opcional*, padrão `False`) : Se deve carregar apenas os pesos e os arquivos de configuração do modelo localmente ou não. Se definido como `True`, o modelo não será baixado do Hub.
token (`str` ou *bool*, *opcional*) : O token a ser usado como autorização HTTP bearer para arquivos remotos. Se `True`, o token gerado por `diffusers-cli login` (armazenado em `~/.huggingface`) é utilizado.
revision (`str`, *opcional*, padrão `"main"`) : A versão específica do modelo a ser usada. Pode ser o nome de um branch, o nome de uma tag, um id de commit ou qualquer identificador permitido pelo Git.
subfolder (`str`, *opcional*, padrão `""`) : A localização da subpasta de um arquivo de modelo dentro de um repositório de modelo maior no Hub ou localmente.
weight_name (`str`, *opcional*, padrão None) : Nome do arquivo de state dict serializado.
return_lora_metadata (`bool`, *opcional*, padrão é False) : Quando habilitado, retorna adicionalmente os metadados do adaptador LoRA, geralmente encontrados no state dict.
Retorna o state dict para os pesos do lora e os alfas da rede.
> [!WARNING] > Suportamos o carregamento de checkpoints LoRA formatados no A1111 em capacidade limitada. > > Esta função é
experimental e pode mudar no futuro.
#### save_lora_weights[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights]]
```python
save_lora_weights(save_directory: str | os.PathLike, unet_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_2_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, unet_lora_adapter_metadata = None, text_encoder_lora_adapter_metadata = None, text_encoder_2_lora_adapter_metadata = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L890)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['unet', 'text_encoder', 'text_encoder_2'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L957)
Veja `unfuse_lora()` para mais detalhes.
## SD3LoraLoaderMixin[[diffusers.loaders.SD3LoraLoaderMixin]]
#### diffusers.loaders.SD3LoraLoaderMixin[[diffusers.loaders.SD3LoraLoaderMixin]]
```python
diffusers.loaders.SD3LoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L964)
Carregue as camadas LoRA em [SD3Transformer2DModel](/docs/diffusers/main/pt/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel), [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) e [`CLIPTextModelWithProjection`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection).
Específico para [StableDiffusion3Pipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1225)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1116)
**Parâmetros:**
state_dict (`dict`) : Um state dict padrão contendo os parâmetros das camadas lora. A chave deve ser prefixada com um adicional `text_encoder` para distinguir entre as camadas lora do unet.
network_alphas (`dict[str, float]`) : O valor do alfa da rede usado para aprendizado estável e prevenção de underflow. Este valor tem o mesmo significado que a opção `--network_alpha` no script de treinamento do kohya-ss. Consulte [este link](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).
text_encoder (`CLIPTextModel`) : O modelo de codificador de texto em que as camadas LoRA serão carregadas.
prefix (`str`) : Prefixo esperado do `text_encoder` no `state_dict`.
lora_scale (`float`) : Em quanto escalar a saída da camada linear lora antes de ser somada à saída da camada lora regular.
adapter_name (`str`, *opcional*) : Nome do adaptador a ser usado para referenciar o modelo de adaptador carregado. Se não for especificado, será usado `default_{i}`, onde i é o número total de adaptadores sendo carregados.
low_cpu_mem_usage (`bool`, *opcional*) : Acelera o carregamento do modelo carregando apenas os pesos LoRA pré-treinados e não inicializando os pesos aleatórios.
hotswap (`bool`, *opcional*) : Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights).
metadata (`dict`) : Metadados opcionais do adaptador LoRA. Quando fornecidos, os argumentos de `LoraConfig` do `peft` não serão derivados do state dict.
Isso carregará as camadas LoRA especificadas em `state_dict` em `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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1090)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1031)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L977)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1175)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.SD3LoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer', 'text_encoder', 'text_encoder_2'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1245)
Veja `unfuse_lora()` para mais detalhes.
## FluxLoraLoaderMixin[[diffusers.loaders.FluxLoraLoaderMixin]]
#### diffusers.loaders.FluxLoraLoaderMixin[[diffusers.loaders.FluxLoraLoaderMixin]]
```python
diffusers.loaders.FluxLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1441)
Carregue as camadas LoRA em [FluxTransformer2DModel](/docs/diffusers/main/pt/api/models/flux_transformer#diffusers.FluxTransformer2DModel), [`CLIPTextModel`](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel).
Específico para [FluxPipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1879)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1756)
**Parâmetros:**
state_dict (`dict`) : Um state dict padrão contendo os parâmetros das camadas lora. A chave deve ser prefixada com um adicional `text_encoder` para distinguir entre as camadas lora do unet.
network_alphas (`dict[str, float]`) : O valor do alfa da rede usado para aprendizado estável e prevenção de underflow. Este valor tem o mesmo significado que a opção `--network_alpha` no script de treinamento do kohya-ss. Consulte [este link](https://github.com/darkstorm2150/sd-scripts/blob/main/docs/train_network_README-en.md#execute-learning).
text_encoder (`CLIPTextModel`) : O modelo de codificador de texto em que as camadas LoRA serão carregadas.
prefix (`str`) : Prefixo esperado do `text_encoder` no `state_dict`.
lora_scale (`float`) : Em quanto escalar a saída da camada linear lora antes de ser somada à saída da camada lora regular.
adapter_name (`str`, *opcional*) : Nome do adaptador a ser usado para referenciar o modelo de adaptador carregado. Se não for especificado, será usado `default_{i}`, onde i é o número total de adaptadores sendo carregados.
low_cpu_mem_usage (`bool`, *opcional*) : Acelera o carregamento do modelo carregando apenas os pesos LoRA pré-treinados e não inicializando os pesos aleatórios.
hotswap (`bool`, *opcional*) : Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights).
metadata (`dict`) : Metadados opcionais do adaptador LoRA. Quando fornecidos, os argumentos de `LoraConfig` do `peft` não serão derivados do state dict.
Isso carregará as camadas LoRA especificadas em `state_dict` em `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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1675)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1579)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1454)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1815)
**Parâmetros:**
save_directory (`str` ou `os.PathLike`) : Diretório para salvar os parâmetros LoRA. Será criado se não existir.
transformer_lora_layers (`dict[str, torch.nn.Module]` ou `dict[str, torch.Tensor]`) : State dict das camadas LoRA correspondentes ao `transformer`.
text_encoder_lora_layers (`dict[str, torch.nn.Module]` ou `dict[str, torch.Tensor]`) : State dict das camadas LoRA correspondentes ao `text_encoder`. É necessário passar explicitamente o state dict do LoRA do text encoder, pois ele vem do 🤗 Transformers.
is_main_process (`bool`, *opcional*, padrão `True`) : Indica se o processo que está chamando esta função é o processo principal ou não. Útil durante o treinamento distribuído, quando é necessário chamar esta função em todos os processos. Nesse caso, defina `is_main_process=True` apenas no processo principal para evitar condições de corrida.
save_function (`Callable`) : A função a ser usada para salvar o dicionário de estado. Útil durante o treinamento distribuído quando você precisa substituir `torch.save` por outro método. Pode ser configurado com a variável de ambiente `DIFFUSERS_SAVE_MODE`.
safe_serialization (`bool`, *opcional*, padrão `True`) : Se o modelo deve ser salvo usando `safetensors` ou da maneira tradicional do PyTorch com `pickle`.
transformer_lora_adapter_metadata : Metadados do adaptador LoRA associados ao transformer a serem serializados com o state dict.
text_encoder_lora_adapter_metadata : Metadados do adaptador LoRA associados ao codificador de texto a serem serializados com o state dict.
Salve os parâmetros do LoRA correspondentes ao UNet e ao codificador de texto.
#### unfuse_lora[[diffusers.loaders.FluxLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer', 'text_encoder'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1911)
**Parâmetros:**
components (`list[str]`) : lista de componentes injetáveis de LoRA dos quais desfazer a fusão do LoRA.
Reverte o efeito 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1926)
**Parâmetros:**
reset_to_overwritten_params (`bool`, padrão `False`) : Se deve redefinir os módulos carregados com LoRA para seus parâmetros originais. Consulte a [documentação do Flux](https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux) para saber mais.
Descarrega os parâmetros do LoRA.
Exemplos:
```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()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5773)
Carrega as camadas LoRA em [Flux2Transformer2DModel](/docs/diffusers/main/pt/api/models/flux2_transformer#diffusers.Flux2Transformer2DModel). Específico para [Flux2Pipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5957)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5894)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5859)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5781)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5921)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.Flux2LoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5977)
Veja `unfuse_lora()` para mais detalhes.
## Flux3LoraLoaderMixin[[diffusers.loaders.Flux3LoraLoaderMixin]]
#### diffusers.loaders.Flux3LoraLoaderMixin[[diffusers.loaders.Flux3LoraLoaderMixin]]
```python
diffusers.loaders.Flux3LoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5984)
#### fuse_lora[[diffusers.loaders.Flux3LoraLoaderMixin.fuse_lora]]
```python
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6139)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6076)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6040)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6103)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.Flux3LoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6159)
Veja `unfuse_lora()` para mais detalhes.
## BriaFibo2LoraLoaderMixin[[diffusers.loaders.BriaFibo2LoraLoaderMixin]]
#### diffusers.loaders.BriaFibo2LoraLoaderMixin[[diffusers.loaders.BriaFibo2LoraLoaderMixin]]
```python
diffusers.loaders.BriaFibo2LoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6166)
Carrega as camadas LoRA em [BriaFibo2Transformer2DModel](/docs/diffusers/main/pt/api/models/transformer_bria_fibo2#diffusers.BriaFibo2Transformer2DModel). Específico para [BriaFibo2Pipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6328)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6265)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6229)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6174)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6292)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.BriaFibo2LoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6348)
Veja `unfuse_lora()` para mais detalhes.
## ErnieImageLoraLoaderMixin[[diffusers.loaders.ErnieImageLoraLoaderMixin]]
#### diffusers.loaders.ErnieImageLoraLoaderMixin[[diffusers.loaders.ErnieImageLoraLoaderMixin]]
```python
diffusers.loaders.ErnieImageLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6551)
Carrega as camadas LoRA em [ErnieImageTransformer2DModel](/docs/diffusers/main/pt/api/models/ernie_image_transformer2d#diffusers.ErnieImageTransformer2DModel). Específico para `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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6724)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6661)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6625)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6559)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6688)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.ErnieImageLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6744)
Veja `unfuse_lora()` para mais detalhes.
## LTX2LoraLoaderMixin[[diffusers.loaders.LTX2LoraLoaderMixin]]
#### diffusers.loaders.LTX2LoraLoaderMixin[[diffusers.loaders.LTX2LoraLoaderMixin]]
```python
diffusers.loaders.LTX2LoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2919)
Carrega as camadas LoRA em [LTX2VideoTransformer3DModel](/docs/diffusers/main/pt/api/models/ltx2_video_transformer3d#diffusers.LTX2VideoTransformer3DModel). Específico para [LTX2Pipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3108)
Veja `fuse_lora()` para mais detalhes.
#### 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')
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3044)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2992)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2928)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3072)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.LTX2LoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3128)
Veja `unfuse_lora()` para mais detalhes.
## CogVideoXLoraLoaderMixin[[diffusers.loaders.CogVideoXLoraLoaderMixin]]
#### diffusers.loaders.CogVideoXLoraLoaderMixin[[diffusers.loaders.CogVideoXLoraLoaderMixin]]
```python
diffusers.loaders.CogVideoXLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2353)
Carrega as camadas LoRA em [CogVideoXTransformer3DModel](/docs/diffusers/main/pt/api/models/cogvideox_transformer3d#diffusers.CogVideoXTransformer3DModel). Específico para [CogVideoXPipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2512)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2451)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2416)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2361)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2478)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.CogVideoXLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2531)
Veja `unfuse_lora()` para mais detalhes.
## Mochi1LoraLoaderMixin[[diffusers.loaders.Mochi1LoraLoaderMixin]]
#### diffusers.loaders.Mochi1LoraLoaderMixin[[diffusers.loaders.Mochi1LoraLoaderMixin]]
```python
diffusers.loaders.Mochi1LoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2538)
Carrega as camadas LoRA em [MochiTransformer3DModel](/docs/diffusers/main/pt/api/models/mochi_transformer3d#diffusers.MochiTransformer3DModel). Específico para [MochiPipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2700)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2637)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2601)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2546)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2664)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.Mochi1LoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2720)
Veja `unfuse_lora()` para mais detalhes.
## AuraFlowLoraLoaderMixin[[diffusers.loaders.AuraFlowLoraLoaderMixin]]
#### diffusers.loaders.AuraFlowLoraLoaderMixin[[diffusers.loaders.AuraFlowLoraLoaderMixin]]
```python
diffusers.loaders.AuraFlowLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1252)
Carregar camadas LoRA em [AuraFlowTransformer2DModel](/docs/diffusers/main/pt/api/models/aura_flow_transformer2d#diffusers.AuraFlowTransformer2DModel) Específico para [AuraFlowPipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1414)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1351)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1315)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1260)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1378)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.AuraFlowLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer', 'text_encoder'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L1434)
Veja `unfuse_lora()` para mais detalhes.
## LTXVideoLoraLoaderMixin[[diffusers.loaders.LTXVideoLoraLoaderMixin]]
#### diffusers.loaders.LTXVideoLoraLoaderMixin[[diffusers.loaders.LTXVideoLoraLoaderMixin]]
```python
diffusers.loaders.LTXVideoLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2727)
Carrega as camadas LoRA em [LTXVideoTransformer3DModel](/docs/diffusers/main/pt/api/models/ltx_video_transformer3d#diffusers.LTXVideoTransformer3DModel). Específico para [LTXPipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2892)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2829)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2793)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2735)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2856)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.LTXVideoLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2912)
Veja `unfuse_lora()` para mais detalhes.
## SanaLoraLoaderMixin[[diffusers.loaders.SanaLoraLoaderMixin]]
#### diffusers.loaders.SanaLoraLoaderMixin[[diffusers.loaders.SanaLoraLoaderMixin]]
```python
diffusers.loaders.SanaLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3135)
Carrega as camadas LoRA em [SanaTransformer2DModel](/docs/diffusers/main/pt/api/models/sana_transformer2d#diffusers.SanaTransformer2DModel). Específico para [SanaPipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3297)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3234)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3198)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3143)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3261)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.SanaLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3317)
Veja `unfuse_lora()` para mais detalhes.
## HeliosLoraLoaderMixin[[diffusers.loaders.HeliosLoraLoaderMixin]]
#### diffusers.loaders.HeliosLoraLoaderMixin[[diffusers.loaders.HeliosLoraLoaderMixin]]
```python
diffusers.loaders.HeliosLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3324)
Carrega as camadas LoRA em [HeliosTransformer3DModel](/docs/diffusers/main/pt/api/models/helios_transformer3d#diffusers.HeliosTransformer3DModel). Específico para [HeliosPipeline](/docs/diffusers/main/pt/api/pipelines/helios#diffusers.HeliosPipeline) e [HeliosPyramidPipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3487)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3424)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3390)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3332)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3451)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.HeliosLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3507)
Veja `unfuse_lora()` para mais detalhes.
## HunyuanVideoLoraLoaderMixin[[diffusers.loaders.HunyuanVideoLoraLoaderMixin]]
#### diffusers.loaders.HunyuanVideoLoraLoaderMixin[[diffusers.loaders.HunyuanVideoLoraLoaderMixin]]
```python
diffusers.loaders.HunyuanVideoLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3514)
Carrega as camadas LoRA em [HunyuanVideoTransformer3DModel](/docs/diffusers/main/pt/api/models/hunyuan_video_transformer_3d#diffusers.HunyuanVideoTransformer3DModel). Específico para [HunyuanVideoPipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3679)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3616)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3580)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3522)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3643)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3699)
Veja `unfuse_lora()` para mais detalhes.
## Lumina2LoraLoaderMixin[[diffusers.loaders.Lumina2LoraLoaderMixin]]
#### diffusers.loaders.Lumina2LoraLoaderMixin[[diffusers.loaders.Lumina2LoraLoaderMixin]]
```python
diffusers.loaders.Lumina2LoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3706)
Carrega as camadas LoRA em [Lumina2Transformer2DModel](/docs/diffusers/main/pt/api/models/lumina2_transformer2d#diffusers.Lumina2Transformer2DModel). Específico para [Lumina2Pipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3872)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3809)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3773)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3714)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3836)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.Lumina2LoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3892)
Veja `unfuse_lora()` para mais detalhes.
## CogView4LoraLoaderMixin[[diffusers.loaders.CogView4LoraLoaderMixin]]
#### diffusers.loaders.CogView4LoraLoaderMixin[[diffusers.loaders.CogView4LoraLoaderMixin]]
```python
diffusers.loaders.CogView4LoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4617)
Carrega as camadas LoRA em [WanTransformer3DModel](/docs/diffusers/main/pt/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel). Específico para [CogView4Pipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4779)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4716)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4680)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4625)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4743)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.CogView4LoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4799)
Veja `unfuse_lora()` para mais detalhes.
## WanLoraLoaderMixin[[diffusers.loaders.WanLoraLoaderMixin]]
#### diffusers.loaders.WanLoraLoaderMixin[[diffusers.loaders.WanLoraLoaderMixin]]
```python
diffusers.loaders.WanLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4088)
Carrega as camadas LoRA em [WanTransformer3DModel](/docs/diffusers/main/pt/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel). Específico para [WanPipeline](/docs/diffusers/main/pt/api/pipelines/wan#diffusers.WanPipeline) e `[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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4324)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4261)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4202)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4096)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4288)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.WanLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4344)
Veja `unfuse_lora()` para mais detalhes.
## SkyReelsV2LoraLoaderMixin[[diffusers.loaders.SkyReelsV2LoraLoaderMixin]]
#### diffusers.loaders.SkyReelsV2LoraLoaderMixin[[diffusers.loaders.SkyReelsV2LoraLoaderMixin]]
```python
diffusers.loaders.SkyReelsV2LoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4351)
Carregue as camadas LoRA em [SkyReelsV2Transformer3DModel](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4590)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4527)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4467)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4359)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4554)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4610)
Veja `unfuse_lora()` para mais detalhes.
## AmusedLoraLoaderMixin[[diffusers.loaders.AmusedLoraLoaderMixin]]
#### diffusers.loaders.AmusedLoraLoaderMixin[[diffusers.loaders.AmusedLoraLoaderMixin]]
```python
diffusers.loaders.AmusedLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2206)
#### load_lora_into_transformer[[diffusers.loaders.AmusedLoraLoaderMixin.load_lora_into_transformer]]
```python
load_lora_into_transformer(state_dict, network_alphas, transformer, adapter_name = None, metadata = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2211)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L2298)
**Parâmetros:**
save_directory (`str` ou `os.PathLike`) : Diretório para salvar os parâmetros LoRA. Será criado se não existir.
unet_lora_layers (`dict[str, torch.nn.Module]` ou `dict[str, torch.Tensor]`) : State dict das camadas LoRA correspondentes ao `unet`.
text_encoder_lora_layers (`dict[str, torch.nn.Module]` ou `dict[str, torch.Tensor]`) : State dict das camadas LoRA correspondentes ao `text_encoder`. É necessário passar explicitamente o state dict do LoRA do text encoder, pois ele vem do 🤗 Transformers.
is_main_process (`bool`, *opcional*, padrão `True`) : Indica se o processo que está chamando esta função é o processo principal ou não. Útil durante o treinamento distribuído, quando é necessário chamar esta função em todos os processos. Nesse caso, defina `is_main_process=True` apenas no processo principal para evitar condições de corrida.
save_function (`Callable`) : A função a ser usada para salvar o dicionário de estado. Útil durante o treinamento distribuído quando você precisa substituir `torch.save` por outro método. Pode ser configurado com a variável de ambiente `DIFFUSERS_SAVE_MODE`.
safe_serialization (`bool`, *opcional*, padrão `True`) : Se o modelo deve ser salvo usando `safetensors` ou da maneira tradicional do PyTorch com `pickle`.
Salve os parâmetros do LoRA correspondentes ao UNet e ao codificador de texto.
## AnimaLoraLoaderMixin[[diffusers.loaders.AnimaLoraLoaderMixin]]
#### diffusers.loaders.AnimaLoraLoaderMixin[[diffusers.loaders.AnimaLoraLoaderMixin]]
```python
diffusers.loaders.AnimaLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5587)
Carregue as camadas LoRA em [CosmosTransformer3DModel](/docs/diffusers/main/pt/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel) e [AnimaTextConditioner](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5747)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5652)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5596)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### unfuse_lora[[diffusers.loaders.AnimaLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer', 'text_conditioner'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5766)
Veja `unfuse_lora()` para mais detalhes.
## AceStepLoraLoaderMixin[[diffusers.loaders.AceStepLoraLoaderMixin]]
#### diffusers.loaders.AceStepLoraLoaderMixin[[diffusers.loaders.AceStepLoraLoaderMixin]]
```python
diffusers.loaders.AceStepLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6941)
Carrega as camadas LoRA em [AceStepTransformer1DModel](/docs/diffusers/main/pt/api/models/ace_step_transformer#diffusers.AceStepTransformer1DModel). Específico para [AceStepPipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7105)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7042)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7006)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6949)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7069)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.AceStepLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7125)
Veja `unfuse_lora()` para mais detalhes.
## HiDreamImageLoraLoaderMixin[[diffusers.loaders.HiDreamImageLoraLoaderMixin]]
#### diffusers.loaders.HiDreamImageLoraLoaderMixin[[diffusers.loaders.HiDreamImageLoraLoaderMixin]]
```python
diffusers.loaders.HiDreamImageLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4806)
Carrega as camadas LoRA em [HiDreamImageTransformer2DModel](/docs/diffusers/main/pt/api/models/hidream_image_transformer#diffusers.HiDreamImageTransformer2DModel). Específico para [HiDreamImagePipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4971)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4908)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4872)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4814)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4935)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.HiDreamImageLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4991)
Veja `unfuse_lora()` para mais detalhes.
## QwenImageLoraLoaderMixin[[diffusers.loaders.QwenImageLoraLoaderMixin]]
#### diffusers.loaders.QwenImageLoraLoaderMixin[[diffusers.loaders.QwenImageLoraLoaderMixin]]
```python
diffusers.loaders.QwenImageLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4998)
Carrega as camadas LoRA em [QwenImageTransformer2DModel](/docs/diffusers/main/pt/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel). Específico para [QwenImagePipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5166)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5103)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5067)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5006)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5130)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.QwenImageLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5186)
Veja `unfuse_lora()` para mais detalhes.
## ZImageLoraLoaderMixin[[diffusers.loaders.ZImageLoraLoaderMixin]]
#### diffusers.loaders.ZImageLoraLoaderMixin[[diffusers.loaders.ZImageLoraLoaderMixin]]
```python
diffusers.loaders.ZImageLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5387)
Carrega as camadas LoRA em [ZImageTransformer2DModel](/docs/diffusers/main/pt/api/models/z_image_transformer2d#diffusers.ZImageTransformer2DModel). Específico para [ZImagePipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5560)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5497)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5461)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5395)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5524)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.ZImageLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5580)
Veja `unfuse_lora()` para mais detalhes.
## CosmosLoraLoaderMixin[[diffusers.loaders.CosmosLoraLoaderMixin]]
#### diffusers.loaders.CosmosLoraLoaderMixin[[diffusers.loaders.CosmosLoraLoaderMixin]]
```python
diffusers.loaders.CosmosLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6751)
Carregue as camadas LoRA em [CosmosTransformer3DModel](/docs/diffusers/main/pt/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel), específico para [Cosmos2_5_PredictBasePipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6914)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6851)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6815)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6760)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6878)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.CosmosLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6934)
Veja `unfuse_lora()` para mais detalhes.
## KandinskyLoraLoaderMixin[[diffusers.loaders.KandinskyLoraLoaderMixin]]
#### diffusers.loaders.KandinskyLoraLoaderMixin[[diffusers.loaders.KandinskyLoraLoaderMixin]]
```python
diffusers.loaders.KandinskyLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3899)
Carregue as camadas LoRA em `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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4061)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3998)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3962)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L3907)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4025)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.KandinskyLoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L4081)
Veja `unfuse_lora()` para mais detalhes.
## Ideogram4LoraLoaderMixin[[diffusers.loaders.Ideogram4LoraLoaderMixin]]
#### diffusers.loaders.Ideogram4LoraLoaderMixin[[diffusers.loaders.Ideogram4LoraLoaderMixin]]
```python
diffusers.loaders.Ideogram4LoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6355)
Carrega as camadas LoRA em [Ideogram4Transformer2DModel](/docs/diffusers/main/pt/api/models/ideogram4_transformer2d#diffusers.Ideogram4Transformer2DModel). Específico para [Ideogram4Pipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6524)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6461)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6425)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6363)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6488)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.Ideogram4LoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L6544)
Veja `unfuse_lora()` para mais detalhes.
## Krea2LoraLoaderMixin[[diffusers.loaders.Krea2LoraLoaderMixin]]
#### diffusers.loaders.Krea2LoraLoaderMixin[[diffusers.loaders.Krea2LoraLoaderMixin]]
```python
diffusers.loaders.Krea2LoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5193)
Carrega as camadas LoRA em [Krea2Transformer2DModel](/docs/diffusers/main/pt/api/models/krea2_transformer2d#diffusers.Krea2Transformer2DModel). Específico para [Krea2Pipeline](/docs/diffusers/main/pt/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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5360)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5297)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5261)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5201)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5324)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.Krea2LoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L5380)
Veja `unfuse_lora()` para mais detalhes.
## MiniMaxH3LoraLoaderMixin[[diffusers.loaders.MiniMaxH3LoraLoaderMixin]]
#### diffusers.loaders.MiniMaxH3LoraLoaderMixin[[diffusers.loaders.MiniMaxH3LoraLoaderMixin]]
```python
diffusers.loaders.MiniMaxH3LoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7132)
Carrega as camadas LoRA em [MiniMaxH3Transformer3DModel](/docs/diffusers/main/pt/api/models/minimax_h3_transformer3d#diffusers.MiniMaxH3Transformer3DModel). Específico para [MiniMaxH3ModularPipeline](/docs/diffusers/main/pt/api/pipelines/minimax_h3#diffusers.MiniMaxH3ModularPipeline).
MiniMax-H3 inclui duas partições DiT independentes com nomes de módulos idênticos (um LoRA para uma é carregado na outra e degrada a saída), portanto o roteamento é explícito: os dicionários de estado convertidos têm como destino `transformer.`; para acessar `transformer_ref`, use um arquivo com o prefixo `transformer_ref.` ou `load_into_transformer_ref=True`.
Os LoRAs do DiffSynth-Studio (por exemplo, [DiffSynth-Studio/MiniMax-H3-LoRA-LineartAnime](https://huggingface.co/DiffSynth-Studio/MiniMax-H3-LoRA-LineartAnime)) são treinados contra o QKV fundido e intercalado por cabeça do checkpoint bruto e são desintercalados na conversão. Seus fatores fp32 fazem com que o caminho de LoRA não fundido seja calculado em fp32; aplicar `.to(torch.bfloat16)` no modelo após o carregamento restaura o orçamento de memória em bf16.
LoRAs treinados contra um checkpoint podado (os arquivos `*_pruned_*` em [Comfy-Org/MiniMax-H3](https://huggingface.co/Comfy-Org/MiniMax-H3); [joyfox/MiniMax-H3-Turbo](https://huggingface.co/joyfox/MiniMax-H3-Turbo) é um deles) falham com um erro de incompatibilidade de tamanho. Arquivos sem `alpha` são carregados com `alpha == rank` (escala 1.0, a convenção declarada por, por exemplo, [larryvrh/MiniMax-H3-Turbo-Lora](https://huggingface.co/larryvrh/MiniMax-H3-Turbo-Lora)); uma entrada de `__metadata__` `alpha` (por exemplo, o arquivo de 8 passos de [lightx2v/Minimax-h3-Turbo](https://huggingface.co/lightx2v/Minimax-h3-Turbo)), quando presente, é respeitada em vez disso.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7489)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7389)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7416)
Carrega as camadas LoRA na partição `transformer_ref`. `prefix` é o nome do componente que as chaves carregam, sendo `transformer_ref` para um arquivo que nomeia a partição e `transformer` para um roteado para cá por `load_into_transformer_ref=True`. Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7274)
**Parâmetros:**
load_into_transformer_ref (`bool`, padrão `False`) : Carrega as camadas com o prefixo `transformer.` na partição `transformer_ref` — aquela com a qual o fluxo de trabalho `ref2va` realiza o desruído — em vez de `transformer`. Necessário apenas quando ambas as partições são carregadas: um pipeline que mantém apenas `transformer_ref` direciona para lá por conta própria.
Carrega as camadas LoRA em `transformer` ou, com `load_into_transformer_ref=True`, em `transformer_ref`. Consulte [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7159)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7446)
Salve as camadas LoRA de uma ou de ambas as partições do MiniMax-H3. A qual partição um LoRA pertence não é recuperável a partir de suas chaves, portanto, este é o único modo de publicar um LoRA do H3 que registre essa informação. Consulte [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
#### unfuse_lora[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.unfuse_lora]]
```python
unfuse_lora(components: list[str] = ['transformer', 'transformer_ref'], **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7508)
Veja `unfuse_lora()` para mais detalhes.
## PikaH3FlexLoraLoaderMixin[[diffusers.loaders.PikaH3FlexLoraLoaderMixin]]
#### diffusers.loaders.PikaH3FlexLoraLoaderMixin[[diffusers.loaders.PikaH3FlexLoraLoaderMixin]]
```python
diffusers.loaders.PikaH3FlexLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7515)
Carrega as camadas LoRA em [MiniMaxH3Transformer3DModel](/docs/diffusers/main/pt/api/models/minimax_h3_transformer3d#diffusers.MiniMaxH3Transformer3DModel). Específico para [PikaH3FlexModularPipeline](/docs/diffusers/main/pt/api/pipelines/pika_h3_flex#diffusers.PikaH3FlexModularPipeline).
A liberação Pika H3 Flex *é* um par de adaptadores rank-128 sobre as duas partições transformer do MiniMax-H3, publicados como dumps PEFT simples dos nomes de módulos do diffusers (`fl2va/adapter.safetensors` para `transformer`, `ref2va/adapter.safetensors` para `transformer_ref`). Os arquivos sem alpha são carregados em `alpha == rank` (escala 1.0), o próprio contrato dos adaptadores, e o carregamento, roteamento e salvamento são os de `MiniMaxH3LoraLoaderMixin`: o adaptador `fl2va` vai para `transformer`, e o adaptador `ref2va` para `transformer_ref` — sozinho quando o pipeline mantém apenas essa partição (`workflow="ref2va"`), com `load_into_transformer_ref=True` quando mantém ambas.
```py
pipe.load_lora_weights("Pika-Labs/Pika-H3-Flex", weight_name="fl2va/adapter.safetensors")
```
## LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]
#### diffusers.loaders.lora_base.LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]
```python
diffusers.loaders.lora_base.LoraBaseMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L491)
Classe utilitária para lidar com LoRAs.
#### delete_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.delete_adapters]]
```python
delete_adapters(adapter_names: list[str] | str)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L873)
**Parâmetros:**
adapter_names (`list[str, str]`) : Os nomes dos adaptadores a serem excluídos.
Exclua as camadas LoRA de um adaptador do pipeline.
Exemplo:
```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()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L813)
Desativa as camadas LoRA ativas do pipeline.
Exemplo:
```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()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L843)
Ativa as camadas LoRA ativas do pipeline.
Exemplo:
```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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L1020)
**Parâmetros:**
target_rank (`int`) : O maior rank entre todos os adaptadores que serão carregados.
check_compiled (`str`, *opcional*, padrão `"error"`) : Como lidar com um modelo que já está compilado. A verificação pode retornar as seguintes mensagens: - "error" (padrão): lança um erro - "warn": emite um aviso - "ignore": não faz nada
Troque adaptadores a quente sem acionar a recompilação de um modelo ou quando as classes dos adaptadores carregados forem diferentes.
#### fuse_lora[[diffusers.loaders.lora_base.LoraBaseMixin.fuse_lora]]
```python
fuse_lora(components: list[str] | None = None, lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L549)
**Parâmetros:**
components : (`list[str]`): lista dos componentes injetáveis de LoRA nos quais fundir os LoRAs.
lora_scale (`float`, padrão 1.0) : Controla o quanto os parâmetros LoRA influenciam as saídas.
safe_fusing (`bool`, padrão `False`) : Se deve verificar os pesos fundidos em busca de valores NaN antes da fusão e, se os valores forem NaN, não fundi-los.
adapter_names (`list[str]`, *opcional*) : Nomes dos adaptadores a serem usados para fusão. Se nada for passado, todos os adaptadores ativos serão fundidos.
Funde os parâmetros do LoRA nos parâmetros originais dos blocos correspondentes.
Exemplo:
```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()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L911)
Obtém a lista dos adaptadores ativos atuais.
Exemplo:
```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()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L944)
Obtém a lista atual de todos os adaptadores disponíveis no 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L698)
**Parâmetros:**
adapter_names (`list[str]` ou `str`) : Os nomes dos adaptadores a serem usados.
adapter_weights (`float`, `dict` ou `list`, *opcional*) : Pesos para os adaptadores. Um escalar escala todos os componentes compatíveis com LoRA. Um dicionário mapeia nomes de componentes (por exemplo, `"unet"`, `"transformer"` ou `"text_encoder"`) para pesos; o peso de um componente UNet também pode ser um dicionário aninhado de escalas de blocos. Um único escalar ou dicionário é aplicado a cada adaptador. Uma lista deve conter um escalar, dicionário ou `None` por adaptador, na ordem de `adapter_names`. `None` tem valor padrão de `1.0`, incluindo entradas de lista e pesos de componentes. Componentes não especificados e blocos UNet também têm valor padrão de `1.0`.
Defina os adaptadores atualmente ativos para uso no pipeline.
Exemplo:
```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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L966)
**Parâmetros:**
adapter_names (`list[str]`) : lista de adaptadores para enviar o dispositivo.
device (`torch.device | str | int`) : Dispositivo para onde enviar os adaptadores. Pode ser um dispositivo torch, uma str ou um inteiro.
Move os LoRAs listados em `adapter_names` para um dispositivo de destino. Útil para descarregar o LoRA para a CPU, caso você queira carregar vários adaptadores e liberar alguma memória de GPU.
Após descarregar os adaptadores LoRA para a CPU, desde que o restante do modelo ainda esteja na GPU, os adaptadores LoRA não podem mais ser usados para inferência, pois isso causaria uma incompatibilidade de dispositivos. Lembre-se de definir o dispositivo de volta para a GPU antes de usar esses adaptadores LoRA para inferência.
```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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L636)
**Parâmetros:**
components (`list[str]`) : lista de componentes injetáveis de LoRA dos quais desfazer a fusão do LoRA.
unfuse_unet (`bool`, padrão `True`) : Se deve desfazer a fusão dos parâmetros LoRA do UNet.
unfuse_text_encoder (`bool`, padrão `True`) : Se deve desfazer a fusão dos parâmetros LoRA do codificador de texto. Se o codificador de texto não foi modificado com os parâmetros LoRA, isso não terá nenhum efeito.
Reverte o efeito 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()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L526)
Descarrega os parâmetros do LoRA.
Exemplos:
```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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_base.py#L1043)
Escreve o state dict das camadas LoRA (opcionalmente com metadados) no disco.
# LoRA
LoRA é um método de treinamento rápido e leve que insere e treina um número significativamente menor de parâmetros, em vez de todos os parâmetros do modelo. Isso gera um arquivo menor (~100 MBs) e facilita o treinamento rápido de um modelo para aprender um novo conceito. Os pesos do LoRA são tipicamente carregados no denoiser, no text encoder ou em ambos. O denoiser geralmente corresponde a um UNet ([UNet2DConditionModel](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel), por exemplo) ou a um Transformer ([SD3Transformer2DModel](/docs/diffusers/main/pt/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel), por exemplo). Existem várias classes para carregar pesos do LoRA:
- `StableDiffusionLoraLoaderMixin` fornece funções para carregar e descarregar, fundir e desfazer a fusão, habilitar e desabilitar, além de outras funções para gerenciar pesos LoRA. Esta classe pode ser usada com qualquer modelo.
- `StableDiffusionXLLoraLoaderMixin` é uma versão [Stable Diffusion (SDXL)](../../api/pipelines/stable_diffusion/stable_diffusion_xl) da classe `StableDiffusionLoraLoaderMixin` para carregar e salvar pesos de LoRA. Ela só pode ser usada com o modelo SDXL.
- `SD3LoraLoaderMixin` fornece funções semelhantes para [Stable Diffusion 3](https://huggingface.co/blog/sd3).
- `FluxLoraLoaderMixin` fornece funções semelhantes para [Flux](../pipelines/flux).
- `CogVideoXLoraLoaderMixin` fornece funções semelhantes para [CogVideoX](../pipelines/cogvideox).
- `Mochi1LoraLoaderMixin` fornece funções semelhantes para [Mochi](../pipelines/mochi).
- `AuraFlowLoraLoaderMixin` fornece funções semelhantes para [AuraFlow](https://huggingface.co/fal/AuraFlow).
- `LTXVideoLoraLoaderMixin` fornece funções semelhantes para [LTX-Video](../pipelines/ltx_video).
- `SanaLoraLoaderMixin` fornece funções semelhantes para [Sana](../pipelines/sana).
- `HeliosLoraLoaderMixin` fornece funções semelhantes para [HunyuanVideo](../pipelines/helios).
- `HunyuanVideoLoraLoaderMixin` fornece funções semelhantes para [HunyuanVideo](../pipelines/hunyuan_video).
- `Lumina2LoraLoaderMixin` fornece funções semelhantes para [Lumina2](../pipelines/lumina2).
- `WanLoraLoaderMixin` fornece funções semelhantes para [Wan](../pipelines/wan).
- `SkyReelsV2LoraLoaderMixin` fornece funções semelhantes para [SkyReels-V2](../pipelines/skyreels_v2).
- `CogView4LoraLoaderMixin` fornece funções semelhantes para [CogView4](../pipelines/cogview4).
- `AmusedLoraLoaderMixin` é para o `AmusedPipeline`.
- `AnimaLoraLoaderMixin` fornece funções semelhantes para [Anima](../pipelines/anima).
- `AceStepLoraLoaderMixin` fornece funções semelhantes para [ACE-Step](../pipelines/ace_step).
- `HiDreamImageLoraLoaderMixin` fornece funções semelhantes para [HiDream Image](../pipelines/hidream)
- `QwenImageLoraLoaderMixin` fornece funções semelhantes para [Qwen Image](../pipelines/qwenimage).
- `ZImageLoraLoaderMixin` fornece funções semelhantes para [Z-Image](../pipelines/z_image).
- `Flux2LoraLoaderMixin` fornece funções semelhantes para [Flux2](../pipelines/flux2).
- `ErnieImageLoraLoaderMixin` fornece funções semelhantes para [Ernie-Image](../pipelines/ernie_image).
- `LTX2LoraLoaderMixin` fornece funções semelhantes para [Flux2](../pipelines/ltx2).
- `MiniMaxH3LoraLoaderMixin` fornece funções semelhantes para [MiniMax-H3](../pipelines/minimax_h3).
- `PikaH3FlexLoraLoaderMixin` fornece funções semelhantes para [Pika H3 Flex](../pipelines/pika_h3_flex).
- `RFD4ProteinaLoraLoaderMixin` fornece funções semelhantes para [RFD4-Proteína](../pipelines/rfd4_proteina).
- `BriaFibo2LoraLoaderMixin` fornece funções semelhantes para [fibo-2](../pipelines/bria_fibo2).
- `LoraBaseMixin` fornece uma classe base com vários métodos utilitários para fundir, desfazer a fusão, descarregar LoRAs e mais.
> [!TIP]
> Para saber mais sobre como carregar pesos LoRA, consulte o guia de carregamento de [LoRA](../../tutorials/using_peft_for_inference).
## RFD4ProteinaLoraLoaderMixin[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin]]
#### diffusers.loaders.RFD4ProteinaLoraLoaderMixin[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin]]
```python
diffusers.loaders.RFD4ProteinaLoraLoaderMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7532)
Carregue as camadas LoRA em [RFD4ProteinaTransformer](/docs/diffusers/main/pt/api/models/rfd4_proteina_transformer#diffusers.RFD4ProteinaTransformer).
O autoencoder é pareado com o checkpoint do denoiser e não é adaptado, portanto, o transformer é o único módulo carregável.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7694)
Veja `fuse_lora()` para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7631)
Veja [load_lora_into_unet()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7595)
Veja [load_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7543)
Veja [lora_state_dict()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) para mais detalhes.
#### 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)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L7658)
Veja [save_lora_weights()](/docs/diffusers/main/pt/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para mais informações.
Xet Storage Details
- Size:
- 162 kB
- Xet hash:
- 08f649a4e0629a12a3c13f6e231dcacc5e2fd2012dd4cb7a2b4fdf0b615d68a9
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.