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, 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[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin]]
diffusers.loaders.RFD4ProteinaLoraLoaderMixin[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin]]
diffusers.loaders.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[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]
diffusers.loaders.lora_base.LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]
diffusers.loaders.lora_base.LoraBaseMixin()
Classe utilitária para lidar com LoRAs.
delete_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.delete_adapters]]
delete_adapters(adapter_names: list[str] | str)
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:
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]]
disable_lora()
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()
enable_lora[[diffusers.loaders.lora_base.LoraBaseMixin.enable_lora]]
enable_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[[diffusers.loaders.lora_base.LoraBaseMixin.enable_lora_hotswap]]
enable_lora_hotswap(**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): 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]]
fuse_lora(components: list[str] | None = None, lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
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:
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]]
get_active_adapters()
Obtém a lista dos adaptadores ativos atuais.
Exemplo:
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]]
get_list_adapters()
Obtém a lista atual de todos os adaptadores disponíveis no pipeline.
set_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.set_adapters]]
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)
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:
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]]
set_lora_device(adapter_names: list[str], device: torch.device | str | int)
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.
>>> 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]]
unfuse_lora(components: list[str] | None = None, **kwargs)
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().
unload_lora_weights[[diffusers.loaders.lora_base.LoraBaseMixin.unload_lora_weights]]
unload_lora_weights()
Descarrega os parâmetros do LoRA.
Exemplos:
>>> # Assuming `pipeline` is already loaded with the LoRA parameters.
>>> pipeline.unload_lora_weights()
>>> ...
write_lora_layers[[diffusers.loaders.lora_base.LoraBaseMixin.write_lora_layers]]
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)
Escreve o state dict das camadas LoRA (opcionalmente com metadados) no disco.
StableDiffusionLoraLoaderMixin[[diffusers.loaders.StableDiffusionLoraLoaderMixin]]
diffusers.loaders.StableDiffusionLoraLoaderMixin[[diffusers.loaders.StableDiffusionLoraLoaderMixin]]
diffusers.loaders.StableDiffusionLoraLoaderMixin()
Carregue as camadas LoRA no UNet2DConditionModel e no CLIPTextModel do Stable Diffusion.
load_lora_into_text_encoder[[diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_text_encoder]]
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)
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.
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().
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]]
load_lora_into_unet(state_dict, network_alphas, unet, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = 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 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.
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().
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]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Parâmetros:
pretrained_model_name_or_path_or_dict (str ou os.PathLike ou dict) : 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á 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().
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[[diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
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(). - Um torch 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.
> 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]]
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)
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]]
diffusers.loaders.StableDiffusionXLLoraLoaderMixin()
Carregue as camadas LoRA no UNet2DConditionModel, no CLIPTextModel e no CLIPTextModelWithProjection do Stable Diffusion XL.
fuse_lora[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.fuse_lora]]
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)
Veja fuse_lora() para mais detalhes.
load_lora_into_text_encoder[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_into_text_encoder]]
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)
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.
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().
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]]
load_lora_into_unet(state_dict, network_alphas, unet, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = 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 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.
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().
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]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
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(). - Um torch 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.
> 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]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['unet', 'text_encoder', 'text_encoder_2'], **kwargs)
Veja unfuse_lora() para mais detalhes.
SD3LoraLoaderMixin[[diffusers.loaders.SD3LoraLoaderMixin]]
diffusers.loaders.SD3LoraLoaderMixin[[diffusers.loaders.SD3LoraLoaderMixin]]
diffusers.loaders.SD3LoraLoaderMixin()
Carregue as camadas LoRA em SD3Transformer2DModel, CLIPTextModel e CLIPTextModelWithProjection.
Específico para StableDiffusion3Pipeline.
fuse_lora[[diffusers.loaders.SD3LoraLoaderMixin.fuse_lora]]
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)
Veja fuse_lora() para mais detalhes.
load_lora_into_text_encoder[[diffusers.loaders.SD3LoraLoaderMixin.load_lora_into_text_encoder]]
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)
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.
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().
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]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.SD3LoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.SD3LoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.SD3LoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.SD3LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer', 'text_encoder', 'text_encoder_2'], **kwargs)
Veja unfuse_lora() para mais detalhes.
FluxLoraLoaderMixin[[diffusers.loaders.FluxLoraLoaderMixin]]
diffusers.loaders.FluxLoraLoaderMixin[[diffusers.loaders.FluxLoraLoaderMixin]]
diffusers.loaders.FluxLoraLoaderMixin()
Carregue as camadas LoRA em FluxTransformer2DModel, CLIPTextModel.
Específico para FluxPipeline.
fuse_lora[[diffusers.loaders.FluxLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja lora_state_dict() para mais detalhes.
load_lora_into_text_encoder[[diffusers.loaders.FluxLoraLoaderMixin.load_lora_into_text_encoder]]
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)
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.
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().
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]]
load_lora_into_transformer(state_dict, network_alphas, transformer, adapter_name = None, metadata = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.FluxLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.FluxLoraLoaderMixin.lora_state_dict]]
lora_state_dict(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[[diffusers.loaders.FluxLoraLoaderMixin.save_lora_weights]]
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)
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]]
unfuse_lora(components: list[str] = ['transformer', 'text_encoder'], **kwargs)
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().
unload_lora_weights[[diffusers.loaders.FluxLoraLoaderMixin.unload_lora_weights]]
unload_lora_weights(reset_to_overwritten_params = False)
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 para saber mais.
Descarrega os parâmetros do LoRA.
Exemplos:
>>> # Assuming `pipeline` is already loaded with the LoRA parameters.
>>> pipeline.unload_lora_weights()
>>> ...
Flux2LoraLoaderMixin[[diffusers.loaders.Flux2LoraLoaderMixin]]
diffusers.loaders.Flux2LoraLoaderMixin[[diffusers.loaders.Flux2LoraLoaderMixin]]
diffusers.loaders.Flux2LoraLoaderMixin()
Carrega as camadas LoRA em Flux2Transformer2DModel. Específico para Flux2Pipeline.
fuse_lora[[diffusers.loaders.Flux2LoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.Flux2LoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.Flux2LoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.Flux2LoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.Flux2LoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.Flux2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
Flux3LoraLoaderMixin[[diffusers.loaders.Flux3LoraLoaderMixin]]
diffusers.loaders.Flux3LoraLoaderMixin[[diffusers.loaders.Flux3LoraLoaderMixin]]
diffusers.loaders.Flux3LoraLoaderMixin()
fuse_lora[[diffusers.loaders.Flux3LoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.Flux3LoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.Flux3LoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
save_lora_weights[[diffusers.loaders.Flux3LoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.Flux3LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
BriaFibo2LoraLoaderMixin[[diffusers.loaders.BriaFibo2LoraLoaderMixin]]
diffusers.loaders.BriaFibo2LoraLoaderMixin[[diffusers.loaders.BriaFibo2LoraLoaderMixin]]
diffusers.loaders.BriaFibo2LoraLoaderMixin()
Carrega as camadas LoRA em BriaFibo2Transformer2DModel. Específico para BriaFibo2Pipeline.
fuse_lora[[diffusers.loaders.BriaFibo2LoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.BriaFibo2LoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.BriaFibo2LoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.BriaFibo2LoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.BriaFibo2LoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.BriaFibo2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
ErnieImageLoraLoaderMixin[[diffusers.loaders.ErnieImageLoraLoaderMixin]]
diffusers.loaders.ErnieImageLoraLoaderMixin[[diffusers.loaders.ErnieImageLoraLoaderMixin]]
diffusers.loaders.ErnieImageLoraLoaderMixin()
Carrega as camadas LoRA em ErnieImageTransformer2DModel. Específico para ErnieImagePipeline.
fuse_lora[[diffusers.loaders.ErnieImageLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.ErnieImageLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.ErnieImageLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.ErnieImageLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.ErnieImageLoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.ErnieImageLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
LTX2LoraLoaderMixin[[diffusers.loaders.LTX2LoraLoaderMixin]]
diffusers.loaders.LTX2LoraLoaderMixin[[diffusers.loaders.LTX2LoraLoaderMixin]]
diffusers.loaders.LTX2LoraLoaderMixin()
Carrega as camadas LoRA em LTX2VideoTransformer3DModel. Específico para LTX2Pipeline.
fuse_lora[[diffusers.loaders.LTX2LoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.LTX2LoraLoaderMixin.load_lora_into_transformer]]
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')
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.LTX2LoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.LTX2LoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.LTX2LoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.LTX2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
CogVideoXLoraLoaderMixin[[diffusers.loaders.CogVideoXLoraLoaderMixin]]
diffusers.loaders.CogVideoXLoraLoaderMixin[[diffusers.loaders.CogVideoXLoraLoaderMixin]]
diffusers.loaders.CogVideoXLoraLoaderMixin()
Carrega as camadas LoRA em CogVideoXTransformer3DModel. Específico para CogVideoXPipeline.
fuse_lora[[diffusers.loaders.CogVideoXLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.CogVideoXLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.CogVideoXLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.CogVideoXLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.CogVideoXLoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.CogVideoXLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
Mochi1LoraLoaderMixin[[diffusers.loaders.Mochi1LoraLoaderMixin]]
diffusers.loaders.Mochi1LoraLoaderMixin[[diffusers.loaders.Mochi1LoraLoaderMixin]]
diffusers.loaders.Mochi1LoraLoaderMixin()
Carrega as camadas LoRA em MochiTransformer3DModel. Específico para MochiPipeline.
fuse_lora[[diffusers.loaders.Mochi1LoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.Mochi1LoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.Mochi1LoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.Mochi1LoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.Mochi1LoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.Mochi1LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
AuraFlowLoraLoaderMixin[[diffusers.loaders.AuraFlowLoraLoaderMixin]]
diffusers.loaders.AuraFlowLoraLoaderMixin[[diffusers.loaders.AuraFlowLoraLoaderMixin]]
diffusers.loaders.AuraFlowLoraLoaderMixin()
Carregar camadas LoRA em AuraFlowTransformer2DModel Específico para AuraFlowPipeline.
fuse_lora[[diffusers.loaders.AuraFlowLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.AuraFlowLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.AuraFlowLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.AuraFlowLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.AuraFlowLoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.AuraFlowLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer', 'text_encoder'], **kwargs)
Veja unfuse_lora() para mais detalhes.
LTXVideoLoraLoaderMixin[[diffusers.loaders.LTXVideoLoraLoaderMixin]]
diffusers.loaders.LTXVideoLoraLoaderMixin[[diffusers.loaders.LTXVideoLoraLoaderMixin]]
diffusers.loaders.LTXVideoLoraLoaderMixin()
Carrega as camadas LoRA em LTXVideoTransformer3DModel. Específico para LTXPipeline.
fuse_lora[[diffusers.loaders.LTXVideoLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.LTXVideoLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.LTXVideoLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.LTXVideoLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.LTXVideoLoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.LTXVideoLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
SanaLoraLoaderMixin[[diffusers.loaders.SanaLoraLoaderMixin]]
diffusers.loaders.SanaLoraLoaderMixin[[diffusers.loaders.SanaLoraLoaderMixin]]
diffusers.loaders.SanaLoraLoaderMixin()
Carrega as camadas LoRA em SanaTransformer2DModel. Específico para SanaPipeline.
fuse_lora[[diffusers.loaders.SanaLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.SanaLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.SanaLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.SanaLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.SanaLoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.SanaLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
HeliosLoraLoaderMixin[[diffusers.loaders.HeliosLoraLoaderMixin]]
diffusers.loaders.HeliosLoraLoaderMixin[[diffusers.loaders.HeliosLoraLoaderMixin]]
diffusers.loaders.HeliosLoraLoaderMixin()
Carrega as camadas LoRA em HeliosTransformer3DModel. Específico para HeliosPipeline e HeliosPyramidPipeline.
fuse_lora[[diffusers.loaders.HeliosLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.HeliosLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.HeliosLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.HeliosLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.HeliosLoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.HeliosLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
HunyuanVideoLoraLoaderMixin[[diffusers.loaders.HunyuanVideoLoraLoaderMixin]]
diffusers.loaders.HunyuanVideoLoraLoaderMixin[[diffusers.loaders.HunyuanVideoLoraLoaderMixin]]
diffusers.loaders.HunyuanVideoLoraLoaderMixin()
Carrega as camadas LoRA em HunyuanVideoTransformer3DModel. Específico para HunyuanVideoPipeline.
fuse_lora[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
Lumina2LoraLoaderMixin[[diffusers.loaders.Lumina2LoraLoaderMixin]]
diffusers.loaders.Lumina2LoraLoaderMixin[[diffusers.loaders.Lumina2LoraLoaderMixin]]
diffusers.loaders.Lumina2LoraLoaderMixin()
Carrega as camadas LoRA em Lumina2Transformer2DModel. Específico para Lumina2Pipeline.
fuse_lora[[diffusers.loaders.Lumina2LoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.Lumina2LoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.Lumina2LoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.Lumina2LoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.Lumina2LoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.Lumina2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
CogView4LoraLoaderMixin[[diffusers.loaders.CogView4LoraLoaderMixin]]
diffusers.loaders.CogView4LoraLoaderMixin[[diffusers.loaders.CogView4LoraLoaderMixin]]
diffusers.loaders.CogView4LoraLoaderMixin()
Carrega as camadas LoRA em WanTransformer3DModel. Específico para CogView4Pipeline.
fuse_lora[[diffusers.loaders.CogView4LoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.CogView4LoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.CogView4LoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.CogView4LoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.CogView4LoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.CogView4LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
WanLoraLoaderMixin[[diffusers.loaders.WanLoraLoaderMixin]]
diffusers.loaders.WanLoraLoaderMixin[[diffusers.loaders.WanLoraLoaderMixin]]
diffusers.loaders.WanLoraLoaderMixin()
Carrega as camadas LoRA em WanTransformer3DModel. Específico para WanPipeline e [WanImageToVideoPipeline].
fuse_lora[[diffusers.loaders.WanLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.WanLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.WanLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.WanLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.WanLoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.WanLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
SkyReelsV2LoraLoaderMixin[[diffusers.loaders.SkyReelsV2LoraLoaderMixin]]
diffusers.loaders.SkyReelsV2LoraLoaderMixin[[diffusers.loaders.SkyReelsV2LoraLoaderMixin]]
diffusers.loaders.SkyReelsV2LoraLoaderMixin()
Carregue as camadas LoRA em SkyReelsV2Transformer3DModel.
fuse_lora[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
AmusedLoraLoaderMixin[[diffusers.loaders.AmusedLoraLoaderMixin]]
diffusers.loaders.AmusedLoraLoaderMixin[[diffusers.loaders.AmusedLoraLoaderMixin]]
diffusers.loaders.AmusedLoraLoaderMixin()
load_lora_into_transformer[[diffusers.loaders.AmusedLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, network_alphas, transformer, adapter_name = None, metadata = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False)
Veja load_lora_into_unet() para mais detalhes.
save_lora_weights[[diffusers.loaders.AmusedLoraLoaderMixin.save_lora_weights]]
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)
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]]
diffusers.loaders.AnimaLoraLoaderMixin()
Carregue as camadas LoRA em CosmosTransformer3DModel e AnimaTextConditioner.
fuse_lora[[diffusers.loaders.AnimaLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer', 'text_conditioner'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_weights[[diffusers.loaders.AnimaLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.AnimaLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
unfuse_lora[[diffusers.loaders.AnimaLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer', 'text_conditioner'], **kwargs)
Veja unfuse_lora() para mais detalhes.
AceStepLoraLoaderMixin[[diffusers.loaders.AceStepLoraLoaderMixin]]
diffusers.loaders.AceStepLoraLoaderMixin[[diffusers.loaders.AceStepLoraLoaderMixin]]
diffusers.loaders.AceStepLoraLoaderMixin()
Carrega as camadas LoRA em AceStepTransformer1DModel. Específico para AceStepPipeline.
fuse_lora[[diffusers.loaders.AceStepLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.AceStepLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.AceStepLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.AceStepLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.AceStepLoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.AceStepLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
HiDreamImageLoraLoaderMixin[[diffusers.loaders.HiDreamImageLoraLoaderMixin]]
diffusers.loaders.HiDreamImageLoraLoaderMixin[[diffusers.loaders.HiDreamImageLoraLoaderMixin]]
diffusers.loaders.HiDreamImageLoraLoaderMixin()
Carrega as camadas LoRA em HiDreamImageTransformer2DModel. Específico para HiDreamImagePipeline.
fuse_lora[[diffusers.loaders.HiDreamImageLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.HiDreamImageLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.HiDreamImageLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.HiDreamImageLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.HiDreamImageLoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.HiDreamImageLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
QwenImageLoraLoaderMixin[[diffusers.loaders.QwenImageLoraLoaderMixin]]
diffusers.loaders.QwenImageLoraLoaderMixin[[diffusers.loaders.QwenImageLoraLoaderMixin]]
diffusers.loaders.QwenImageLoraLoaderMixin()
Carrega as camadas LoRA em QwenImageTransformer2DModel. Específico para QwenImagePipeline.
fuse_lora[[diffusers.loaders.QwenImageLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.QwenImageLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.QwenImageLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.QwenImageLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.QwenImageLoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.QwenImageLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
ZImageLoraLoaderMixin[[diffusers.loaders.ZImageLoraLoaderMixin]]
diffusers.loaders.ZImageLoraLoaderMixin[[diffusers.loaders.ZImageLoraLoaderMixin]]
diffusers.loaders.ZImageLoraLoaderMixin()
Carrega as camadas LoRA em ZImageTransformer2DModel. Específico para ZImagePipeline.
fuse_lora[[diffusers.loaders.ZImageLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.ZImageLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.ZImageLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.ZImageLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.ZImageLoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.ZImageLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
CosmosLoraLoaderMixin[[diffusers.loaders.CosmosLoraLoaderMixin]]
diffusers.loaders.CosmosLoraLoaderMixin[[diffusers.loaders.CosmosLoraLoaderMixin]]
diffusers.loaders.CosmosLoraLoaderMixin()
Carregue as camadas LoRA em CosmosTransformer3DModel, específico para Cosmos2_5_PredictBasePipeline.
fuse_lora[[diffusers.loaders.CosmosLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.CosmosLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.CosmosLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.CosmosLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.CosmosLoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.CosmosLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
KandinskyLoraLoaderMixin[[diffusers.loaders.KandinskyLoraLoaderMixin]]
diffusers.loaders.KandinskyLoraLoaderMixin[[diffusers.loaders.KandinskyLoraLoaderMixin]]
diffusers.loaders.KandinskyLoraLoaderMixin()
Carregue as camadas LoRA em Kandinsky5Transformer3DModel,
fuse_lora[[diffusers.loaders.KandinskyLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.KandinskyLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.KandinskyLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.KandinskyLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.KandinskyLoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.KandinskyLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
Ideogram4LoraLoaderMixin[[diffusers.loaders.Ideogram4LoraLoaderMixin]]
diffusers.loaders.Ideogram4LoraLoaderMixin[[diffusers.loaders.Ideogram4LoraLoaderMixin]]
diffusers.loaders.Ideogram4LoraLoaderMixin()
Carrega as camadas LoRA em Ideogram4Transformer2DModel. Específico para Ideogram4Pipeline.
fuse_lora[[diffusers.loaders.Ideogram4LoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.Ideogram4LoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.Ideogram4LoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.Ideogram4LoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.Ideogram4LoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.Ideogram4LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
Krea2LoraLoaderMixin[[diffusers.loaders.Krea2LoraLoaderMixin]]
diffusers.loaders.Krea2LoraLoaderMixin[[diffusers.loaders.Krea2LoraLoaderMixin]]
diffusers.loaders.Krea2LoraLoaderMixin()
Carrega as camadas LoRA em Krea2Transformer2DModel. Específico para Krea2Pipeline.
fuse_lora[[diffusers.loaders.Krea2LoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.Krea2LoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_weights[[diffusers.loaders.Krea2LoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Veja load_lora_weights() para mais detalhes.
lora_state_dict[[diffusers.loaders.Krea2LoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.Krea2LoraLoaderMixin.save_lora_weights]]
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)
Veja save_lora_weights() para mais informações.
unfuse_lora[[diffusers.loaders.Krea2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Veja unfuse_lora() para mais detalhes.
MiniMaxH3LoraLoaderMixin[[diffusers.loaders.MiniMaxH3LoraLoaderMixin]]
diffusers.loaders.MiniMaxH3LoraLoaderMixin[[diffusers.loaders.MiniMaxH3LoraLoaderMixin]]
diffusers.loaders.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 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; 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 de __metadata__ alpha (por exemplo, o arquivo de 8 passos de lightx2v/Minimax-h3-Turbo), quando presente, é respeitada em vez disso.
fuse_lora[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer', 'transformer_ref'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Veja fuse_lora() para mais detalhes.
load_lora_into_transformer[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Veja load_lora_into_unet() para mais detalhes.
load_lora_into_transformer_ref[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_into_transformer_ref]]
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)
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[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.load_lora_weights]]
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)
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() para mais detalhes.
lora_state_dict[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Veja lora_state_dict() para mais detalhes.
save_lora_weights[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.save_lora_weights]]
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)
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.
unfuse_lora[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer', 'transformer_ref'], **kwargs)
Veja unfuse_lora() para mais detalhes.
PikaH3FlexLoraLoaderMixin[[diffusers.loaders.PikaH3FlexLoraLoaderMixin]]
diffusers.loaders.PikaH3FlexLoraLoaderMixin[[diffusers.loaders.PikaH3FlexLoraLoaderMixin]]
diffusers.loaders.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, 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.
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]]
diffusers.loaders.lora_base.LoraBaseMixin()
Classe utilitária para lidar com LoRAs.
delete_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.delete_adapters]]
delete_adapters(adapter_names: list[str] | str)
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:
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]]
disable_lora()
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()
enable_lora[[diffusers.loaders.lora_base.LoraBaseMixin.enable_lora]]
enable_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[[diffusers.loaders.lora_base.LoraBaseMixin.enable_lora_hotswap]]
enable_lora_hotswap(**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): 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]]
fuse_lora(components: list[str] | None = None, lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
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:
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]]
get_active_adapters()
Obtém a lista dos adaptadores ativos atuais.
Exemplo:
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]]
get_list_adapters()
Obtém a lista atual de todos os adaptadores disponíveis no pipeline.
set_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.set_adapters]]
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)
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:
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]]
set_lora_device(adapter_names: list[str], device: torch.device | str | int)
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.
>>> 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]]
unfuse_lora(components: list[str] | None = None, **kwargs)
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().
unload_lora_weights[[diffusers.loaders.lora_base.LoraBaseMixin.unload_lora_weights]]
unload_lora_weights()
Descarrega os parâmetros do LoRA.
Exemplos:
>>> # Assuming `pipeline` is already loaded with the LoRA parameters.
>>> pipeline.unload_lora_weights()
>>> ...
write_lora_layers[[diffusers.loaders.lora_base.LoraBaseMixin.write_lora_layers]]
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)
Escreve o state dict das camadas LoRA (opcionalmente com metadados) no disco.
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.