Diffusers documentation
LoRA
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, por exemplo) ou a um Transformer (SD3Transformer2DModel, por exemplo). Existem várias classes para carregar pesos do LoRA:
StableDiffusionLoraLoaderMixinfornece 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) da classeStableDiffusionLoraLoaderMixinpara carregar e salvar pesos de LoRA. Ela só pode ser usada com o modelo SDXL.SD3LoraLoaderMixinfornece funções semelhantes para Stable Diffusion 3.FluxLoraLoaderMixinfornece funções semelhantes para Flux.CogVideoXLoraLoaderMixinfornece funções semelhantes para CogVideoX.Mochi1LoraLoaderMixinfornece funções semelhantes para Mochi.AuraFlowLoraLoaderMixinfornece funções semelhantes para AuraFlow.LTXVideoLoraLoaderMixinfornece funções semelhantes para LTX-Video.SanaLoraLoaderMixinfornece funções semelhantes para Sana.HeliosLoraLoaderMixinfornece funções semelhantes para HunyuanVideo.HunyuanVideoLoraLoaderMixinfornece funções semelhantes para HunyuanVideo.Lumina2LoraLoaderMixinfornece funções semelhantes para Lumina2.WanLoraLoaderMixinfornece funções semelhantes para Wan.SkyReelsV2LoraLoaderMixinfornece funções semelhantes para SkyReels-V2.CogView4LoraLoaderMixinfornece funções semelhantes para CogView4.AmusedLoraLoaderMixiné para oAmusedPipeline.AnimaLoraLoaderMixinfornece funções semelhantes para Anima.AceStepLoraLoaderMixinfornece funções semelhantes para ACE-Step.HiDreamImageLoraLoaderMixinfornece funções semelhantes para HiDream ImageQwenImageLoraLoaderMixinfornece funções semelhantes para Qwen Image.ZImageLoraLoaderMixinfornece funções semelhantes para Z-Image.Flux2LoraLoaderMixinfornece funções semelhantes para Flux2.ErnieImageLoraLoaderMixinfornece funções semelhantes para Ernie-Image.LTX2LoraLoaderMixinfornece funções semelhantes para Flux2.MiniMaxH3LoraLoaderMixinfornece funções semelhantes para MiniMax-H3.PikaH3FlexLoraLoaderMixinfornece funções semelhantes para Pika H3 Flex.RFD4ProteinaLoraLoaderMixinfornece funções semelhantes para RFD4-Proteína.BriaFibo2LoraLoaderMixinfornece funções semelhantes para fibo-2.LoraBaseMixinfornece uma classe base com vários métodos utilitários para fundir, desfazer a fusão, descarregar LoRAs e mais.
Para saber mais sobre como carregar pesos LoRA, consulte o guia de carregamento de LoRA.
RFD4ProteinaLoraLoaderMixin
Carregue as camadas LoRA em RFD4ProteinaTransformer.
O autoencoder é pareado com o checkpoint do denoiser e não é adaptado, portanto, o transformer é o único módulo carregável.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
LoraBaseMixin
Classe utilitária para lidar com LoRAs.
delete_adapters
< source >( adapter_names: list[str] | str )
Exclua as camadas LoRA de um adaptador do pipeline.
Exemplo:
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")Desativa as camadas LoRA ativas do pipeline.
Exemplo:
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()Ativa as camadas LoRA ativas do pipeline.
Exemplo:
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
< source >( **kwargs )
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): levanta um erro
- “warn”: emitir um aviso
- “ignore”: não fazer nada
Troque adaptadores a quente sem acionar a recompilação de um modelo ou quando as classes dos adaptadores carregados forem diferentes.
fuse_lora
< source >( components: list[str] | None = Nonelora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Parâmetros
- components — (
list[str]): lista de componentes injetáveis com LoRA nos quais fundir os LoRAs. - lora_scale (
float, padrão 1.0) — Controla o quanto os parâmetros do LoRA influenciam as saídas. - safe_fusing (
bool, padrãoFalse) — 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:
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)Obtém a lista dos adaptadores ativos atuais.
Obtém a lista atual de todos os adaptadores disponíveis no pipeline.
set_adapters
< source >( adapter_names: list[str] | stradapter_weights: float | dict[str, float | dict | None] | list[float | dict[str, float | dict | None] | None] | None = None )
Parâmetros
- adapter_names (
list[str]oustr) — Os nomes dos adaptadores a serem usados. - adapter_weights (
float,dictoulist, opcional) — Pesos para os adaptadores. Um escalar escala todos os componentes compatíveis com LoRA. Um dicionário mapeia nomes de componentes (p. ex.,"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 ouNonepor adaptador, na ordem deadapter_names.Nonetem valor padrão de1.0, incluindo entradas de lista e pesos de componentes. Componentes não especificados e blocos UNet também têm valor padrão de1.0.
Defina os adaptadores atualmente ativos para uso no pipeline.
Exemplo:
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
< source >( adapter_names: list[str]device: torch.device | str | int )
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 dispositivo. Lembre-se de definir o dispositivo de volta para a GPU antes de usar esses adaptadores LoRA para inferência.
>>> 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
< source >( components: list[str] | None = None**kwargs )
Parâmetros
- components (
list[str]) — lista dos componentes injetáveis de LoRA dos quais desfazer a fusão do LoRA. - unfuse_unet (
bool, padrãoTrue) — Se deve desfazer a fusão dos parâmetros LoRA do UNet. - unfuse_text_encoder (
bool, padrãoTrue) — 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().
Descarrega os parâmetros do LoRA.
write_lora_layers
< source >( state_dict: dict[str, torch.Tensor]save_directory: stris_main_process: boolweight_name: strsave_function: Callablesafe_serialization: boollora_adapter_metadata: dict | None = None )
Escreve o state dict das camadas LoRA (opcionalmente com metadados) no disco.
StableDiffusionLoraLoaderMixin
Carregue as camadas LoRA no UNet2DConditionModel e no CLIPTextModel do Stable Diffusion.
load_lora_into_text_encoder
< source >( state_dictnetwork_alphastext_encoderprefix = Nonelora_scale = 1.0adapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Parâmetros
- state_dict (
dict) — Um state dict padrão contendo os parâmetros das camadas lora. A chave deve ser prefixada com umtext_encoderadicional para distinguir entre as camadas lora do unet. - network_alphas (
dict[str, float]) — O valor do alpha da rede usado para aprendizado estável e prevenção de underflow. Este valor tem o mesmo significado que a opção--network_alphano script de treinamento do kohya-ss. Consulte este link. - text_encoder (
CLIPTextModel) — O modelo de codificador de texto no qual as camadas LoRA serão carregadas. - prefix (
str) — Prefixo esperado dotext_encodernostate_dict. - lora_scale (
float) — Quanto escalar a saída da camada linear lora antes de somá-la à 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á usadodefault_{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(). - metadata (
dict) — Metadados opcionais do adaptador LoRA. Quando fornecidos, os argumentos deLoraConfigdopeftnão serão derivados do state dict.
Isso carregará as camadas LoRA especificadas em state_dict em text_encoder
load_lora_into_unet
< source >( state_dictnetwork_alphasunetadapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
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 umunetadicional, o que pode ser usado para distinguir entre as camadas lora do text encoder. - network_alphas (
dict[str, float]) — O valor do alpha da rede usado para aprendizado estável e prevenção de underflow. Este valor tem o mesmo significado que a opção--network_alphano script de treinamento do kohya-ss. Consulte este link. - unet (
UNet2DConditionModel) — O modelo UNet em que as camadas LoRA serão carregadas. - adapter_name (
str, opcional) — Nome do adaptador a ser usado para referenciar o modelo de adaptador carregado. Se não for especificado, será usadodefault_{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(). - metadata (
dict) — Metadados opcionais do adaptador LoRA. Quando fornecidos, os argumentos deLoraConfigdopeftnão serão derivados do state dict.
Isso carregará as camadas LoRA especificadas em state_dict em unet.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Parâmetros
- pretrained_model_name_or_path_or_dict (
strouos.PathLikeoudict) — Veja 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á usadodefault_{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) — 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, oadapter_namedeve ser o nome de um adaptador já carregado.Se o novo adaptador e o antigo tiverem ranks e/ou alphas LoRA diferentes (ou seja, escalonamento), você precisa chamar um método adicional antes de carregar o adaptador:
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 nowObserve que a troca dinâmica (hotswap) de adaptadores do codificador de texto ainda não é suportada. 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().
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() para mais detalhes sobre como o state dict é carregado.
Veja load_lora_into_unet() para mais detalhes sobre como o state dict é carregado em self.unet.
Veja load_lora_into_text_encoder() para mais detalhes sobre como o state dict é carregado em self.text_encoder.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Parâmetros
- pretrained_model_name_or_path_or_dict (
strouos.PathLikeoudict) — Pode ser:- Uma string, o id do modelo (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(). - Um torch state dict.
- Uma string, o id do modelo (por exemplo,
- 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ãoFalse) — 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ãoFalse) — Se deve carregar apenas os pesos e arquivos de configuração do modelo localmente. Se definido comoTrue, o modelo não será baixado do Hub. - token (
strou bool, opcional) — O token a ser usado como autorização de bearer HTTP para arquivos remotos. SeTrue, o token gerado pordiffusers-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 também os metadados do adaptador LoRA, geralmente encontrados no state dict.
Retorna o state dict para os pesos do lora e os alfas da rede.
> Suportamos o carregamento de checkpoints LoRA no formato A1111 com capacidade limitada. > > Esta função é experimental e pode mudar no futuro.
save_lora_weights
< source >( save_directory: str | os.PathLikeunet_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Nonetext_encoder_lora_layers: dict[str, torch.nn.Module] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Trueunet_lora_adapter_metadata = Nonetext_encoder_lora_adapter_metadata = None )
Parâmetros
- save_directory (
strouos.PathLike) — Diretório para salvar os parâmetros LoRA. Será criado se não existir. - unet_lora_layers (
dict[str, torch.nn.Module]oudict[str, torch.Tensor]) — Dicionário de estado das camadas LoRA correspondentes aounet. - text_encoder_lora_layers (
dict[str, torch.nn.Module]oudict[str, torch.Tensor]) — State dict das camadas LoRA correspondentes aotext_encoder. É necessário passar explicitamente o state dict das LoRA do text encoder, pois ele vem do 🤗 Transformers. - is_main_process (
bool, opcional, padrãoTrue) — Indica se o processo que está chamando esta função é o processo principal ou não. Útil durante o treinamento distribuído quando você precisa chamar esta função em todos os processos. Nesse caso, definais_main_process=Trueapenas 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 substituirtorch.savepor outro método. Pode ser configurado com a variável de ambienteDIFFUSERS_SAVE_MODE. - safe_serialization (
bool, opcional, padrãoTrue) — Se o modelo deve ser salvo usandosafetensorsou da maneira tradicional do PyTorch compickle. - 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
Carregue as camadas LoRA no UNet2DConditionModel, no CLIPTextModel e no CLIPTextModelWithProjection do Stable Diffusion XL.
fuse_lora
< source >( components: list[str] = ['unet', 'text_encoder', 'text_encoder_2']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_text_encoder
< source >( state_dictnetwork_alphastext_encoderprefix = Nonelora_scale = 1.0adapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Parâmetros
- state_dict (
dict) — Um state dict padrão contendo os parâmetros das camadas lora. A chave deve ser prefixada com umtext_encoderadicional para distinguir entre as camadas lora do unet. - network_alphas (
dict[str, float]) — O valor do alpha da rede usado para aprendizado estável e prevenção de underflow. Este valor tem o mesmo significado que a opção--network_alphano script de treinamento do kohya-ss. Consulte este link. - text_encoder (
CLIPTextModel) — O modelo de codificador de texto no qual as camadas LoRA serão carregadas. - prefix (
str) — Prefixo esperado dotext_encodernostate_dict. - lora_scale (
float) — Quanto escalar a saída da camada linear lora antes de somá-la à 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á usadodefault_{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(). - metadata (
dict) — Metadados opcionais do adaptador LoRA. Quando fornecidos, os argumentos deLoraConfigdopeftnão serão derivados do state dict.
Isso carregará as camadas LoRA especificadas em state_dict em text_encoder
load_lora_into_unet
< source >( state_dictnetwork_alphasunetadapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
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 umunetadicional, o que pode ser usado para distinguir entre as camadas lora do text encoder. - network_alphas (
dict[str, float]) — O valor do alpha da rede usado para aprendizado estável e prevenção de underflow. Este valor tem o mesmo significado que a opção--network_alphano script de treinamento do kohya-ss. Consulte este link. - unet (
UNet2DConditionModel) — O modelo UNet em que as camadas LoRA serão carregadas. - adapter_name (
str, opcional) — Nome do adaptador a ser usado para referenciar o modelo de adaptador carregado. Se não for especificado, será usadodefault_{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(). - metadata (
dict) — Metadados opcionais do adaptador LoRA. Quando fornecidos, os argumentos deLoraConfigdopeftnão serão derivados do state dict.
Isso carregará as camadas LoRA especificadas em state_dict em unet.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Parâmetros
- pretrained_model_name_or_path_or_dict (
strouos.PathLikeoudict) — Pode ser:- Uma string, o id do modelo (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(). - Um torch state dict.
- Uma string, o id do modelo (por exemplo,
- 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ãoFalse) — 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ãoFalse) — Se deve carregar apenas os pesos e arquivos de configuração do modelo localmente. Se definido comoTrue, o modelo não será baixado do Hub. - token (
strou bool, opcional) — O token a ser usado como autorização de bearer HTTP para arquivos remotos. SeTrue, o token gerado pordiffusers-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 também os metadados do adaptador LoRA, geralmente encontrados no state dict.
Retorna o state dict para os pesos do lora e os alfas da rede.
> Suportamos o carregamento de checkpoints LoRA no formato A1111 com capacidade limitada. > > Esta função é experimental e pode mudar no futuro.
save_lora_weights
< source >( save_directory: str | os.PathLikeunet_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Nonetext_encoder_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Nonetext_encoder_2_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Trueunet_lora_adapter_metadata = Nonetext_encoder_lora_adapter_metadata = Nonetext_encoder_2_lora_adapter_metadata = None )
Veja save_lora_weights() para mais informações.
unfuse_lora
< source >( components: list[str] = ['unet', 'text_encoder', 'text_encoder_2']**kwargs )
Veja unfuse_lora() para mais detalhes.
SD3LoraLoaderMixin
Carregue as camadas LoRA em SD3Transformer2DModel, CLIPTextModel e CLIPTextModelWithProjection.
Específico para StableDiffusion3Pipeline.
fuse_lora
< source >( components: list[str] = ['transformer', 'text_encoder', 'text_encoder_2']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_text_encoder
< source >( state_dictnetwork_alphastext_encoderprefix = Nonelora_scale = 1.0adapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Parâmetros
- state_dict (
dict) — Um state dict padrão contendo os parâmetros das camadas lora. A chave deve ser prefixada com umtext_encoderadicional para distinguir entre as camadas lora do unet. - network_alphas (
dict[str, float]) — O valor do alpha da rede usado para aprendizado estável e prevenção de underflow. Este valor tem o mesmo significado que a opção--network_alphano script de treinamento do kohya-ss. Consulte este link. - text_encoder (
CLIPTextModel) — O modelo de codificador de texto no qual as camadas LoRA serão carregadas. - prefix (
str) — Prefixo esperado dotext_encodernostate_dict. - lora_scale (
float) — Quanto escalar a saída da camada linear lora antes de somá-la à 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á usadodefault_{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(). - metadata (
dict) — Metadados opcionais do adaptador LoRA. Quando fornecidos, os argumentos deLoraConfigdopeftnão serão derivados do state dict.
Isso carregará as camadas LoRA especificadas em state_dict em text_encoder
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Nonetext_encoder_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Nonetext_encoder_2_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata = Nonetext_encoder_lora_adapter_metadata = Nonetext_encoder_2_lora_adapter_metadata = None )
Veja save_lora_weights() para mais informações.
unfuse_lora
< source >( components: list[str] = ['transformer', 'text_encoder', 'text_encoder_2']**kwargs )
Veja unfuse_lora() para mais detalhes.
FluxLoraLoaderMixin
Carregue as camadas LoRA em FluxTransformer2DModel, CLIPTextModel.
Específico para FluxPipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja lora_state_dict() para mais detalhes.
load_lora_into_text_encoder
< source >( state_dictnetwork_alphastext_encoderprefix = Nonelora_scale = 1.0adapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Parâmetros
- state_dict (
dict) — Um state dict padrão contendo os parâmetros das camadas lora. A chave deve ser prefixada com umtext_encoderadicional para distinguir entre as camadas lora do unet. - network_alphas (
dict[str, float]) — O valor do alpha da rede usado para aprendizado estável e prevenção de underflow. Este valor tem o mesmo significado que a opção--network_alphano script de treinamento do kohya-ss. Consulte este link. - text_encoder (
CLIPTextModel) — O modelo de codificador de texto no qual as camadas LoRA serão carregadas. - prefix (
str) — Prefixo esperado dotext_encodernostate_dict. - lora_scale (
float) — Quanto escalar a saída da camada linear lora antes de somá-la à 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á usadodefault_{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(). - metadata (
dict) — Metadados opcionais do adaptador LoRA. Quando fornecidos, os argumentos deLoraConfigdopeftnão serão derivados do state dict.
Isso carregará as camadas LoRA especificadas em state_dict em text_encoder
load_lora_into_transformer
< source >( state_dictnetwork_alphastransformeradapter_name = Nonemetadata = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = False )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]return_alphas: bool = False**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Nonetext_encoder_lora_layers: dict[str, torch.nn.Module] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata = Nonetext_encoder_lora_adapter_metadata = None )
Parâmetros
- save_directory (
strouos.PathLike) — Diretório para salvar os parâmetros LoRA. Será criado se não existir. - transformer_lora_layers (
dict[str, torch.nn.Module]oudict[str, torch.Tensor]) — State dict das camadas LoRA correspondentes aotransformer. - text_encoder_lora_layers (
dict[str, torch.nn.Module]oudict[str, torch.Tensor]) — State dict das camadas LoRA correspondentes aotext_encoder. É necessário passar explicitamente o state dict das LoRA do text encoder, pois ele vem do 🤗 Transformers. - is_main_process (
bool, opcional, padrãoTrue) — Indica se o processo que está chamando esta função é o processo principal ou não. Útil durante o treinamento distribuído quando você precisa chamar esta função em todos os processos. Nesse caso, definais_main_process=Trueapenas 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 substituirtorch.savepor outro método. Pode ser configurado com a variável de ambienteDIFFUSERS_SAVE_MODE. - safe_serialization (
bool, opcional, padrãoTrue) — Se o modelo deve ser salvo usandosafetensorsou da maneira tradicional do PyTorch compickle. - 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
< source >( components: list[str] = ['transformer', 'text_encoder']**kwargs )
Reverte o efeito de pipe.fuse_lora().
unload_lora_weights
< source >( reset_to_overwritten_params = False )
Parâmetros
- reset_to_overwritten_params (
bool, padrãoFalse) — Se deve redefinir os módulos carregados com LoRA para seus parâmetros originais. Consulte a documentação do Flux para saber mais.
Descarrega os parâmetros do LoRA.
Flux2LoraLoaderMixin
Carrega as camadas LoRA em Flux2Transformer2DModel. Específico para Flux2Pipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
Flux3LoraLoaderMixin
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
BriaFibo2LoraLoaderMixin
Carrega as camadas LoRA em BriaFibo2Transformer2DModel. Específico para BriaFibo2Pipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
ErnieImageLoraLoaderMixin
Carrega as camadas LoRA em ErnieImageTransformer2DModel. Específico para ErnieImagePipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
LTX2LoraLoaderMixin
Carrega as camadas LoRA em LTX2VideoTransformer3DModel. Específico para LTX2Pipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = Noneprefix: str = 'transformer' )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
CogVideoXLoraLoaderMixin
Carrega as camadas LoRA em CogVideoXTransformer3DModel. Específico para CogVideoXPipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
Mochi1LoraLoaderMixin
Carrega as camadas LoRA em MochiTransformer3DModel. Específico para MochiPipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
AuraFlowLoraLoaderMixin
Carregar camadas LoRA em AuraFlowTransformer2DModel Específico para AuraFlowPipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
LTXVideoLoraLoaderMixin
Carrega as camadas LoRA em LTXVideoTransformer3DModel. Específico para LTXPipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
SanaLoraLoaderMixin
Carrega as camadas LoRA em SanaTransformer2DModel. Específico para SanaPipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
HeliosLoraLoaderMixin
Carrega as camadas LoRA em HeliosTransformer3DModel. Específico para HeliosPipeline e HeliosPyramidPipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
HunyuanVideoLoraLoaderMixin
Carrega as camadas LoRA em HunyuanVideoTransformer3DModel. Específico para HunyuanVideoPipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
Lumina2LoraLoaderMixin
Carrega as camadas LoRA em Lumina2Transformer2DModel. Específico para Lumina2Pipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
CogView4LoraLoaderMixin
Carrega as camadas LoRA em WanTransformer3DModel. Específico para CogView4Pipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
WanLoraLoaderMixin
Carrega as camadas LoRA em WanTransformer3DModel. Específico para WanPipeline e [WanImageToVideoPipeline].
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
SkyReelsV2LoraLoaderMixin
Carregue as camadas LoRA em SkyReelsV2Transformer3DModel.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
AmusedLoraLoaderMixin
load_lora_into_transformer
< source >( state_dictnetwork_alphastransformeradapter_name = Nonemetadata = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = False )
Veja load_lora_into_unet() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketext_encoder_lora_layers: dict[str, torch.nn.Module] = Nonetransformer_lora_layers: dict[str, torch.nn.Module] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = True )
Parâmetros
- save_directory (
strouos.PathLike) — Diretório para salvar os parâmetros LoRA. Será criado se não existir. - unet_lora_layers (
dict[str, torch.nn.Module]oudict[str, torch.Tensor]) — Dicionário de estado das camadas LoRA correspondentes aounet. - text_encoder_lora_layers (
dict[str, torch.nn.Module]oudict[str, torch.Tensor]) — State dict das camadas LoRA correspondentes aotext_encoder. É necessário passar explicitamente o state dict das LoRA do text encoder, pois ele vem do 🤗 Transformers. - is_main_process (
bool, opcional, padrãoTrue) — Indica se o processo que está chamando esta função é o processo principal ou não. Útil durante o treinamento distribuído quando você precisa chamar esta função em todos os processos. Nesse caso, definais_main_process=Trueapenas 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 substituirtorch.savepor outro método. Pode ser configurado com a variável de ambienteDIFFUSERS_SAVE_MODE. - safe_serialization (
bool, opcional, padrãoTrue) — Se o modelo deve ser salvo usandosafetensorsou da maneira tradicional do PyTorch compickle.
Salve os parâmetros do LoRA correspondentes ao UNet e ao codificador de texto.
AnimaLoraLoaderMixin
Carregue as camadas LoRA em CosmosTransformer3DModel e AnimaTextConditioner.
fuse_lora
< source >( components: list[str] = ['transformer', 'text_conditioner']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
Veja unfuse_lora() para mais detalhes.
AceStepLoraLoaderMixin
Carrega as camadas LoRA em AceStepTransformer1DModel. Específico para AceStepPipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
HiDreamImageLoraLoaderMixin
Carrega as camadas LoRA em HiDreamImageTransformer2DModel. Específico para HiDreamImagePipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
QwenImageLoraLoaderMixin
Carrega as camadas LoRA em QwenImageTransformer2DModel. Específico para QwenImagePipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
ZImageLoraLoaderMixin
Carrega as camadas LoRA em ZImageTransformer2DModel. Específico para ZImagePipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
CosmosLoraLoaderMixin
Carregue as camadas LoRA em CosmosTransformer3DModel, específico para Cosmos2_5_PredictBasePipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
KandinskyLoraLoaderMixin
Carregue as camadas LoRA em Kandinsky5Transformer3DModel,
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
Ideogram4LoraLoaderMixin
Carrega as camadas LoRA em Ideogram4Transformer2DModel. Específico para Ideogram4Pipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
Krea2LoraLoaderMixin
Carrega as camadas LoRA em Krea2Transformer2DModel. Específico para Krea2Pipeline.
fuse_lora
< source >( components: list[str] = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Veja load_lora_weights() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Veja save_lora_weights() para mais informações.
Veja unfuse_lora() para mais detalhes.
MiniMaxH3LoraLoaderMixin
Carrega as camadas LoRA em MiniMaxH3Transformer3DModel. Específico para 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)
são treinados contra o QKV fundido com cabeças intercaladas do checkpoint bruto e são desintercalados na conversão. Seus
fatores fp32 fazem o caminho de LoRA não fundido calcular em fp32; .to(torch.bfloat16) no modelo após o carregamento restaura
o orçamento de memória bf16.
LoRAs treinados contra um checkpoint podado (os arquivos *_pruned_* em Comfy-Org/MiniMax-H3; 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); uma entrada alpha em __metadata__ (por exemplo, o arquivo de 8 passos de lightx2v/Minimax-h3-Turbo), quando
presente, é respeitada em vez disso.
fuse_lora
< source >( components: list[str] = ['transformer', 'transformer_ref']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Veja load_lora_into_unet() para mais detalhes.
load_lora_into_transformer_ref
< source >( state_dicttransformer_refprefixadapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
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() para mais detalhes.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = Falseload_into_transformer_ref: bool = False**kwargs )
Parâmetros
- load_into_transformer_ref (
bool, padrãoFalse) — Carrega as camadas com o prefixotransformer.na partiçãotransformer_ref— aquela com a qual o workflowref2varealiza o denoising — em vez detransformer. Necessário apenas quando ambas as partições estão carregadas: um pipeline que mantém apenastransformer_refroteia 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() para mais detalhes.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Veja lora_state_dict() para mais detalhes.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Nonetransformer_ref_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = Nonetransformer_ref_lora_adapter_metadata: dict | None = None )
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() para mais informações.
Veja unfuse_lora() para mais detalhes.
PikaH3FlexLoraLoaderMixin
Carrega as camadas LoRA em MiniMaxH3Transformer3DModel. Específico para PikaH3FlexModularPipeline.
A liberação Pika H3 Flex é um par de adaptadores rank-128 sobre as duas partições transformer do MiniMax-H3, publicadas
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
contrato próprio 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.
LoraBaseMixin
Classe utilitária para lidar com LoRAs.
delete_adapters
< source >( adapter_names: list[str] | str )
Exclua as camadas LoRA de um adaptador do pipeline.
Exemplo:
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")Desativa as camadas LoRA ativas do pipeline.
Exemplo:
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()Ativa as camadas LoRA ativas do pipeline.
Exemplo:
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
< source >( **kwargs )
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): levanta um erro
- “warn”: emitir um aviso
- “ignore”: não fazer nada
Troque adaptadores a quente sem acionar a recompilação de um modelo ou quando as classes dos adaptadores carregados forem diferentes.
fuse_lora
< source >( components: list[str] | None = Nonelora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Parâmetros
- components — (
list[str]): lista de componentes injetáveis com LoRA nos quais fundir os LoRAs. - lora_scale (
float, padrão 1.0) — Controla o quanto os parâmetros do LoRA influenciam as saídas. - safe_fusing (
bool, padrãoFalse) — 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:
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)Obtém a lista dos adaptadores ativos atuais.
Obtém a lista atual de todos os adaptadores disponíveis no pipeline.
set_adapters
< source >( adapter_names: list[str] | stradapter_weights: float | dict[str, float | dict | None] | list[float | dict[str, float | dict | None] | None] | None = None )
Parâmetros
- adapter_names (
list[str]oustr) — Os nomes dos adaptadores a serem usados. - adapter_weights (
float,dictoulist, opcional) — Pesos para os adaptadores. Um escalar escala todos os componentes compatíveis com LoRA. Um dicionário mapeia nomes de componentes (p. ex.,"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 ouNonepor adaptador, na ordem deadapter_names.Nonetem valor padrão de1.0, incluindo entradas de lista e pesos de componentes. Componentes não especificados e blocos UNet também têm valor padrão de1.0.
Defina os adaptadores atualmente ativos para uso no pipeline.
Exemplo:
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
< source >( adapter_names: list[str]device: torch.device | str | int )
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 dispositivo. Lembre-se de definir o dispositivo de volta para a GPU antes de usar esses adaptadores LoRA para inferência.
>>> 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
< source >( components: list[str] | None = None**kwargs )
Parâmetros
- components (
list[str]) — lista dos componentes injetáveis de LoRA dos quais desfazer a fusão do LoRA. - unfuse_unet (
bool, padrãoTrue) — Se deve desfazer a fusão dos parâmetros LoRA do UNet. - unfuse_text_encoder (
bool, padrãoTrue) — 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().
Descarrega os parâmetros do LoRA.
write_lora_layers
< source >( state_dict: dict[str, torch.Tensor]save_directory: stris_main_process: boolweight_name: strsave_function: Callablesafe_serialization: boollora_adapter_metadata: dict | None = None )
Escreve o state dict das camadas LoRA (opcionalmente com metadados) no disco.