Buckets:
LoRA
LoRA est une méthode d'entraînement rapide et légère qui insère et entraîne un nombre de paramètres nettement inférieur à celui de tous les paramètres du modèle. Cela produit un fichier plus petit (~100 Mo) et facilite l'entraînement rapide d'un modèle pour qu'il apprenne un nouveau concept. Les poids LoRA sont généralement chargés dans le débruiteur, l'encodeur de texte ou les deux. Le débruiteur correspond généralement à un UNet (UNet2DConditionModel, par exemple) ou à un Transformer (SD3Transformer2DModel, par exemple). Il existe plusieurs classes pour charger les poids LoRA :
StableDiffusionLoraLoaderMixinfournit des fonctions pour charger et décharger, fusionner et défusionner, activer et désactiver, ainsi que d’autres fonctions pour gérer les poids LoRA. Cette classe peut être utilisée avec n’importe quel modèle.StableDiffusionXLLoraLoaderMixinest une version Stable Diffusion (SDXL) de la classeStableDiffusionLoraLoaderMixinpour charger et enregistrer les poids LoRA. Elle ne peut être utilisée qu’avec le modèle SDXL.SD3LoraLoaderMixinfournit des fonctions similaires pour Stable Diffusion 3.FluxLoraLoaderMixinfournit des fonctions similaires pour Flux.CogVideoXLoraLoaderMixinfournit des fonctions similaires pour CogVideoX.Mochi1LoraLoaderMixinfournit des fonctions similaires pour Mochi.AuraFlowLoraLoaderMixinfournit des fonctions similaires pour AuraFlow.LTXVideoLoraLoaderMixinfournit des fonctions similaires pour LTX-Video.SanaLoraLoaderMixinfournit des fonctions similaires pour Sana.HeliosLoraLoaderMixinfournit des fonctions similaires pour HunyuanVideo.HunyuanVideoLoraLoaderMixinfournit des fonctions similaires pour HunyuanVideo.Lumina2LoraLoaderMixinfournit des fonctions similaires pour Lumina2.WanLoraLoaderMixinfournit des fonctions similaires pour Wan.SkyReelsV2LoraLoaderMixinfournit des fonctions similaires pour SkyReels-V2.CogView4LoraLoaderMixinfournit des fonctions similaires pour CogView4.AmusedLoraLoaderMixinest destiné àAmusedPipeline.AnimaLoraLoaderMixinfournit des fonctions similaires pour Anima.AceStepLoraLoaderMixinfournit des fonctions similaires pour ACE-Step.HiDreamImageLoraLoaderMixinfournit des fonctions similaires pour HiDream ImageQwenImageLoraLoaderMixinfournit des fonctions similaires pour Qwen Image.ZImageLoraLoaderMixinfournit des fonctions similaires pour Z-Image.Flux2LoraLoaderMixinfournit des fonctions similaires pour Flux2.ErnieImageLoraLoaderMixinfournit des fonctions similaires pour Ernie-Image.LTX2LoraLoaderMixinfournit des fonctions similaires pour Flux2.MiniMaxH3LoraLoaderMixinfournit des fonctions similaires pour MiniMax-H3.PikaH3FlexLoraLoaderMixinfournit des fonctions similaires pour Pika H3 Flex.RFD4ProteinaLoraLoaderMixinfournit des fonctions similaires pour RFD4-Proteína.BriaFibo2LoraLoaderMixinfournit des fonctions similaires pour fibo-2.LoraBaseMixinfournit une classe de base avec plusieurs méthodes utilitaires pour fusionner, désfusionner, décharger des LoRAs et plus encore.
Pour en savoir plus sur la manière de charger les poids LoRA, consultez le guide de chargement LoRA.
RFD4ProteinaLoraLoaderMixin[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin]]
diffusers.loaders.RFD4ProteinaLoraLoaderMixin[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin]]
diffusers.loaders.RFD4ProteinaLoraLoaderMixin()
Charger les couches LoRA dans RFD4ProteinaTransformer.
L'autoencodeur est associé au point de contrôle du débruiteur et n'est pas adapté, de sorte que le transformeur est le seul module chargeable.
fuse_lora[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.fuse_lora]]
fuse_lora(components: list[str] = ['transformer'], lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.RFD4ProteinaLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]
diffusers.loaders.lora_base.LoraBaseMixin[[diffusers.loaders.lora_base.LoraBaseMixin]]
diffusers.loaders.lora_base.LoraBaseMixin()
Classe utilitaire pour la gestion des LoRA.
delete_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.delete_adapters]]
delete_adapters(adapter_names: list[str] | str)
Paramètres :
adapter_names (list[str, str]) : Les noms des adaptateurs à supprimer.
Supprimer les couches LoRA d'un adaptateur du pipeline.
Exemple :
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()
Désactive les couches LoRA actives du pipeline.
Exemple :
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()
Active les couches LoRA actives du pipeline.
Exemple :
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)
Paramètres :
target_rank (int) : Le rang le plus élevé parmi tous les adaptateurs qui seront chargés.
check_compiled (str, facultatif, par défaut "error") : Comment gérer un modèle déjà compilé. La vérification peut renvoyer les messages suivants : - "error" (par défaut) : lever une erreur - "warn" : émettre un avertissement - "ignore" : ne rien faire
Chauder les adaptateurs sans déclencher la recompilation d'un modèle ou si les rangs des adaptateurs chargés sont différents.
fuse_lora[[diffusers.loaders.lora_base.LoraBaseMixin.fuse_lora]]
fuse_lora(components: list[str] | None = None, lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Paramètres :
components : (list[str]) : liste des composants injectables par LoRA dans lesquels fusionner les LoRA.
lora_scale (float, par défaut 1.0) : Contrôle dans quelle mesure les paramètres LoRA influencent les sorties.
safe_fusing (bool, par défaut False) : Indique s'il faut vérifier les poids fusionnés pour détecter des valeurs NaN avant la fusion, et, si des valeurs sont NaN, de ne pas les fusionner.
adapter_names (list[str], facultatif) : Noms des adaptateurs à utiliser pour la fusion. Si rien n'est transmis, tous les adaptateurs actifs seront fusionnés.
Fond les paramètres LoRA dans les paramètres originaux des blocs correspondants.
Exemple :
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()
Renvoie la liste des adaptateurs actifs actuels.
Exemple :
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()
Renvoie la liste actuelle de tous les adaptateurs disponibles dans le 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)
Paramètres :
adapter_names (list[str] ou str) : Les noms des adaptateurs à utiliser.
adapter_weights (float, dict ou list, facultatif) : Poids pour les adaptateurs. Un scalaire met à l'échelle tous les composants compatibles LoRA. Un dictionnaire associe les noms de composants (par ex. "unet", "transformer" ou "text_encoder") à des poids ; le poids d'un composant UNet peut également être un dictionnaire imbriqué d'échelles de blocs. Un scalaire ou un dictionnaire unique est appliqué à chaque adaptateur. Une liste doit contenir un scalaire, un dictionnaire ou None par adaptateur, dans l'ordre de adapter_names. None est par défaut 1.0, y compris pour les entrées de liste et les poids des composants. Les composants non spécifiés et les blocs UNet sont également par défaut 1.0.
Définissez les adaptateurs actuellement actifs pour leur utilisation dans le pipeline.
Exemple :
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)
Paramètres :
adapter_names (list[str]) : liste des adaptateurs à envoyer vers l'appareil.
device (torch.device | str | int) : Appareil vers lequel envoyer les adaptateurs. Peut être un appareil torch, une chaîne de caractères ou un entier.
Déplace les LoRA listés dans adapter_names vers un appareil cible. Utile pour décharger le LoRA sur le CPU si vous souhaitez charger plusieurs adaptateurs et libérer de la mémoire GPU.
Après avoir déchargé les adaptateurs LoRA sur le CPU, tant que le reste du modèle est toujours sur le GPU, les adaptateurs LoRA ne peuvent plus être utilisés pour l'inférence, car cela provoquerait une incompatibilité de périphérique. Pensez à réinitialiser le périphérique sur le GPU avant d'utiliser ces adaptateurs LoRA pour l'inférence.
>>> 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)
Paramètres :
components (list[str]) : liste des composants injectables par LoRA dont il faut retirer l'injection de LoRA.
unfuse_unet (bool, par défaut True) : Indique s'il faut désfusionner les paramètres LoRA du UNet.
unfuse_text_encoder (bool, par défaut True) : Indique s'il faut désfusionner les paramètres LoRA de l'encodeur de texte. Si l'encodeur de texte n'a pas été modifié (monkey-patched) avec les paramètres LoRA, cela n'aura aucun effet.
Annule l'effet de pipe.fuse_lora().
unload_lora_weights[[diffusers.loaders.lora_base.LoraBaseMixin.unload_lora_weights]]
unload_lora_weights()
Décharge les paramètres LoRA.
Exemples :
>>> # 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)
Écrit le dictionnaire d'état des couches LoRA (éventuellement avec des métadonnées) sur le disque.
StableDiffusionLoraLoaderMixin[[diffusers.loaders.StableDiffusionLoraLoaderMixin]]
diffusers.loaders.StableDiffusionLoraLoaderMixin[[diffusers.loaders.StableDiffusionLoraLoaderMixin]]
diffusers.loaders.StableDiffusionLoraLoaderMixin()
Charger les couches LoRA dans le UNet2DConditionModel et le CLIPTextModel de 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)
Paramètres :
state_dict (dict) : Un state dict standard contenant les paramètres des couches lora. La clé doit être préfixée par text_encoder supplémentaire afin de distinguer les couches lora de unet.
network_alphas (dict[str, float]) : La valeur de l'alpha du réseau utilisée pour un apprentissage stable et la prévention du sous-débordement. Cette valeur a la même signification que l'option --network_alpha du script d'entraînement kohya-ss. Consultez ce lien.
text_encoder (CLIPTextModel) : le modèle d'encodeur de texte dans lequel charger les couches LoRA.
prefix (str) : Préfixe attendu du text_encoder dans le state_dict.
lora_scale (float) : Facteur d'échelle appliqué à la sortie de la couche linéaire lora avant son ajout à la sortie de la couche lora standard.
adapter_name (str, facultatif) : Nom de l'adaptateur à utiliser pour référencer le modèle d'adaptateur chargé. S'il n'est pas spécifié, default_{i} sera utilisé, où i est le nombre total d'adaptateurs chargés.
low_cpu_mem_usage (bool, facultatif) : Accélère le chargement du modèle en ne chargeant que les poids LoRA préentraînés et sans initialiser les poids aléatoires.
hotswap (bool, facultatif) : Voir load_lora_weights().
metadata (dict) : métadonnées facultatives de l’adaptateur LoRA. Si fournies, les arguments LoraConfig de peft ne seront pas dérivés du dictionnaire d’état.
Cela chargera les couches LoRA spécifiées dans state_dict dans text_encoder
load_lora_into_unet[[diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet]]
load_lora_into_unet(state_dict, network_alphas, unet, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Paramètres :
state_dict (dict) : Un state dict standard contenant les paramètres des couches lora. Les clés peuvent soit être indexées directement dans le unet, soit préfixées par un unet supplémentaire, ce qui permet de distinguer les couches lora des encodeurs de texte.
network_alphas (dict[str, float]) : La valeur de l'alpha du réseau utilisée pour un apprentissage stable et la prévention du sous-débordement. Cette valeur a la même signification que l'option --network_alpha du script d'entraînement kohya-ss. Consultez ce lien.
unet (UNet2DConditionModel) : Le modèle UNet dans lequel charger les couches LoRA.
adapter_name (str, facultatif) : Nom de l'adaptateur à utiliser pour référencer le modèle d'adaptateur chargé. S'il n'est pas spécifié, default_{i} sera utilisé, où i est le nombre total d'adaptateurs chargés.
low_cpu_mem_usage (bool, facultatif) : Accélère le chargement du modèle en ne chargeant que les poids LoRA préentraînés et sans initialiser les poids aléatoires.
hotswap (bool, facultatif) : Voir load_lora_weights().
metadata (dict) : métadonnées facultatives de l’adaptateur LoRA. Si fournies, les arguments LoraConfig de peft ne seront pas dérivés du dictionnaire d’état.
Cela chargera les couches LoRA spécifiées dans state_dict dans unet.
load_lora_weights[[diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Paramètres :
pretrained_model_name_or_path_or_dict (str ou os.PathLike ou dict) : Voir lora_state_dict().
adapter_name (str, facultatif) : Nom de l'adaptateur à utiliser pour référencer le modèle d'adaptateur chargé. S'il n'est pas spécifié, default_{i} sera utilisé, où i est le nombre total d'adaptateurs chargés.
low_cpu_mem_usage (bool, facultatif) : Accélère le chargement du modèle en ne chargeant que les poids LoRA préentraînés et sans initialiser les poids aléatoires.
hotswap (bool, facultatif) : La valeur par défaut est False. Indique s'il faut substituer un adaptateur (LoRA) existant par l'adaptateur nouvellement chargé, sur place. Cela signifie que, au lieu de charger un adaptateur supplémentaire, les poids de l'adaptateur existant seront remplacés par ceux du nouvel adaptateur. Cette approche peut être plus rapide et plus efficace en termes de mémoire. Cependant, l'avantage principal du hotswapping est que, lorsque le modèle est compilé avec torch.compile, le chargement du nouvel adaptateur ne nécessite pas de recompiler le modèle. Lors de l'utilisation du hotswapping, le adapter_name transmis doit être le nom d'un adaptateur déjà chargé. Si le nouvel adaptateur et l'ancien adaptateur ont des rangs et/ou des alphas LoRA (c'est-à-dire des échelles) différents, vous devez appeler une méthode supplémentaire avant de charger l'adaptateur : py pipeline = ... # load diffusers pipeline max_rank = ... # the highest rank among all LoRAs that you want to load # call *before* compiling and loading the LoRA adapter pipeline.enable_lora_hotswap(target_rank=max_rank) pipeline.load_lora_weights(file_name) # optionally compile the model now Notez que le hotswapping des adaptateurs de l'encodeur de texte n'est pas encore pris en charge. Cette technique comporte d'autres limitations, documentées ici : https://huggingface.co/docs/peft/main/en/package_reference/hotswap
kwargs (dict, facultatif) : Voir lora_state_dict().
Charge les poids LoRA spécifiés dans pretrained_model_name_or_path_or_dict dans self.unet et self.text_encoder.
Tous les kwargs sont transmis à self.lora_state_dict.
Voir lora_state_dict() pour plus de détails sur la manière dont le state dict est chargé.
Voir load_lora_into_unet() pour plus de détails sur la façon dont le state dict est chargé dans self.unet.
Voir load_lora_into_text_encoder() pour plus de détails sur la façon dont le state dict est chargé dans self.text_encoder.
lora_state_dict[[diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict]]
lora_state_dict(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs)
Paramètres :
pretrained_model_name_or_path_or_dict (str ou os.PathLike ou dict) : Peut être : - Une chaîne de caractères, l'identifiant du modèle (par exemple google/ddpm-celebahq-256) d'un modèle pré-entraîné hébergé sur le Hub. - Un chemin vers un dossier (par exemple ./my_model_directory) contenant les poids du modèle enregistrés avec ModelMixin.save_pretrained(). - Un dictionnaire d'état torch.
cache_dir (str | os.PathLike, facultatif) : Chemin vers un répertoire où la configuration d'un modèle pré-entraîné téléchargé est mise en cache si le cache standard n'est pas utilisé.
force_download (bool, facultatif, par défaut False) : Indique s'il faut forcer le (re)téléchargement des poids du modèle et des fichiers de configuration, en ignorant les versions mises en cache si elles existent.
proxies (dict[str, str], facultatif) : Un dictionnaire de serveurs proxy à utiliser par protocole ou point de terminaison, par exemple, {'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. Les proxys sont utilisés pour chaque requête.
local_files_only (bool, facultatif, par défaut False) : Indique s'il faut charger uniquement les poids et les fichiers de configuration du modèle locaux. Si défini sur True, le modèle ne sera pas téléchargé depuis le Hub.
token (str ou bool, facultatif) : Le jeton à utiliser comme autorisation bearer HTTP pour les fichiers distants. Si True, le jeton généré par diffusers-cli login (stocké dans ~/.huggingface) est utilisé.
revision (str, facultatif, par défaut "main") : La version spécifique du modèle à utiliser. Il peut s'agir d'un nom de branche, d'un nom de tag, d'un identifiant de commit ou de tout identifiant autorisé par Git.
subfolder (str, facultatif, valeur par défaut "") : Emplacement du sous-dossier du fichier de modèle au sein d'un dépôt de modèle plus large sur le Hub ou en local.
weight_name (str, facultatif, valeur par défaut None) : Nom du fichier de dictionnaire d'état sérialisé.
return_lora_metadata (bool, facultatif, valeur par défaut : False) : Si activé, renvoie également les métadonnées de l'adaptateur LoRA, généralement présentes dans le state dict.
Retourne le dictionnaire d'état pour les poids lora et les alphas du réseau.
> Nous prenons en charge le chargement de points de contrôle LoRA au format A1111 de manière limitée. > > Cette fonction est expérimental et susceptible de changer à l'avenir.
save_lora_weights[[diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights]]
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)
Paramètres :
save_directory (str ou os.PathLike) : Répertoire où enregistrer les paramètres LoRA. Sera créé s'il n'existe pas.
unet_lora_layers (dict[str, torch.nn.Module] ou dict[str, torch.Tensor]) : Dictionnaire d'état des couches LoRA correspondant à unet.
text_encoder_lora_layers (dict[str, torch.nn.Module] ou dict[str, torch.Tensor]) : Dictionnaire d'état des couches LoRA correspondant au text_encoder. Il est nécessaire de passer explicitement le dictionnaire d'état LoRA de l'encodeur de texte, car il provient de 🤗 Transformers.
is_main_process (bool, facultatif, par défaut True) : Indique si le processus qui appelle cette fonction est le processus principal ou non. Utile lors de l'entraînement distribué lorsque vous devez appeler cette fonction sur tous les processus. Dans ce cas, définissez is_main_process=True uniquement sur le processus principal pour éviter les conditions de course.
save_function (Callable) : La fonction à utiliser pour enregistrer le dictionnaire d'état. Utile lors de l'entraînement distribué lorsque vous devez remplacer torch.save par une autre méthode. Peut être configuré avec la variable d'environnement DIFFUSERS_SAVE_MODE.
safe_serialization (bool, facultatif, par défaut True) : Indique si le modèle doit être enregistré en utilisant safetensors ou de manière traditionnelle PyTorch avec pickle.
unet_lora_adapter_metadata : métadonnées de l'adaptateur LoRA associées au unet à sérialiser avec le state dict.
text_encoder_lora_adapter_metadata : métadonnées de l'adaptateur LoRA associées à l'encodeur de texte à sérialiser avec le dictionnaire d'état.
Enregistrez les paramètres LoRA correspondant à l'UNet et à l'encodeur de texte.
StableDiffusionXLLoraLoaderMixin[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin]]
diffusers.loaders.StableDiffusionXLLoraLoaderMixin[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin]]
diffusers.loaders.StableDiffusionXLLoraLoaderMixin()
Charger les couches LoRA dans le UNet2DConditionModel, le CLIPTextModel et le CLIPTextModelWithProjection de 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)
Voir fuse_lora() pour plus de détails.
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)
Paramètres :
state_dict (dict) : Un state dict standard contenant les paramètres des couches lora. La clé doit être préfixée par text_encoder supplémentaire afin de distinguer les couches lora de unet.
network_alphas (dict[str, float]) : La valeur de l'alpha du réseau utilisée pour un apprentissage stable et la prévention du sous-débordement. Cette valeur a la même signification que l'option --network_alpha du script d'entraînement kohya-ss. Consultez ce lien.
text_encoder (CLIPTextModel) : le modèle d'encodeur de texte dans lequel charger les couches LoRA.
prefix (str) : Préfixe attendu du text_encoder dans le state_dict.
lora_scale (float) : Facteur d'échelle appliqué à la sortie de la couche linéaire lora avant son ajout à la sortie de la couche lora standard.
adapter_name (str, facultatif) : Nom de l'adaptateur à utiliser pour référencer le modèle d'adaptateur chargé. S'il n'est pas spécifié, default_{i} sera utilisé, où i est le nombre total d'adaptateurs chargés.
low_cpu_mem_usage (bool, facultatif) : Accélère le chargement du modèle en ne chargeant que les poids LoRA préentraînés et sans initialiser les poids aléatoires.
hotswap (bool, facultatif) : Voir load_lora_weights().
metadata (dict) : métadonnées facultatives de l’adaptateur LoRA. Si fournies, les arguments LoraConfig de peft ne seront pas dérivés du dictionnaire d’état.
Cela chargera les couches LoRA spécifiées dans state_dict dans text_encoder
load_lora_into_unet[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_into_unet]]
load_lora_into_unet(state_dict, network_alphas, unet, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Paramètres :
state_dict (dict) : Un state dict standard contenant les paramètres des couches lora. Les clés peuvent soit être indexées directement dans le unet, soit préfixées par un unet supplémentaire, ce qui permet de distinguer les couches lora des encodeurs de texte.
network_alphas (dict[str, float]) : La valeur de l'alpha du réseau utilisée pour un apprentissage stable et la prévention du sous-débordement. Cette valeur a la même signification que l'option --network_alpha du script d'entraînement kohya-ss. Consultez ce lien.
unet (UNet2DConditionModel) : Le modèle UNet dans lequel charger les couches LoRA.
adapter_name (str, facultatif) : Nom de l'adaptateur à utiliser pour référencer le modèle d'adaptateur chargé. S'il n'est pas spécifié, default_{i} sera utilisé, où i est le nombre total d'adaptateurs chargés.
low_cpu_mem_usage (bool, facultatif) : Accélère le chargement du modèle en ne chargeant que les poids LoRA préentraînés et sans initialiser les poids aléatoires.
hotswap (bool, facultatif) : Voir load_lora_weights().
metadata (dict) : métadonnées facultatives de l’adaptateur LoRA. Si fournies, les arguments LoraConfig de peft ne seront pas dérivés du dictionnaire d’état.
Cela chargera les couches LoRA spécifiées dans state_dict dans unet.
load_lora_weights[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights]]
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
Voir load_lora_weights() pour plus de détails.
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)
Paramètres :
pretrained_model_name_or_path_or_dict (str ou os.PathLike ou dict) : Peut être : - Une chaîne de caractères, l'identifiant du modèle (par exemple google/ddpm-celebahq-256) d'un modèle pré-entraîné hébergé sur le Hub. - Un chemin vers un dossier (par exemple ./my_model_directory) contenant les poids du modèle enregistrés avec ModelMixin.save_pretrained(). - Un dictionnaire d'état torch.
cache_dir (str | os.PathLike, facultatif) : Chemin vers un répertoire où la configuration d'un modèle pré-entraîné téléchargé est mise en cache si le cache standard n'est pas utilisé.
force_download (bool, facultatif, par défaut False) : Indique s'il faut forcer le (re)téléchargement des poids du modèle et des fichiers de configuration, en ignorant les versions mises en cache si elles existent.
proxies (dict[str, str], facultatif) : Un dictionnaire de serveurs proxy à utiliser par protocole ou point de terminaison, par exemple, {'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. Les proxys sont utilisés pour chaque requête.
local_files_only (bool, facultatif, par défaut False) : Indique s'il faut charger uniquement les poids et les fichiers de configuration du modèle locaux. Si défini sur True, le modèle ne sera pas téléchargé depuis le Hub.
token (str ou bool, facultatif) : Le jeton à utiliser comme autorisation bearer HTTP pour les fichiers distants. Si True, le jeton généré par diffusers-cli login (stocké dans ~/.huggingface) est utilisé.
revision (str, facultatif, par défaut "main") : La version spécifique du modèle à utiliser. Il peut s'agir d'un nom de branche, d'un nom de tag, d'un identifiant de commit ou de tout identifiant autorisé par Git.
subfolder (str, facultatif, valeur par défaut "") : Emplacement du sous-dossier du fichier de modèle au sein d'un dépôt de modèle plus large sur le Hub ou en local.
weight_name (str, facultatif, valeur par défaut None) : Nom du fichier de dictionnaire d'état sérialisé.
return_lora_metadata (bool, facultatif, valeur par défaut : False) : Si activé, renvoie également les métadonnées de l'adaptateur LoRA, généralement présentes dans le state dict.
Retourne le dictionnaire d'état pour les poids lora et les alphas du réseau.
> Nous prenons en charge le chargement de points de contrôle LoRA au format A1111 de manière limitée. > > Cette fonction est expérimental et susceptible de changer à l'avenir.
save_lora_weights[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights]]
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.StableDiffusionXLLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['unet', 'text_encoder', 'text_encoder_2'], **kwargs)
Voir unfuse_lora() pour plus de détails.
SD3LoraLoaderMixin[[diffusers.loaders.SD3LoraLoaderMixin]]
diffusers.loaders.SD3LoraLoaderMixin[[diffusers.loaders.SD3LoraLoaderMixin]]
diffusers.loaders.SD3LoraLoaderMixin()
Charger les couches LoRA dans SD3Transformer2DModel, CLIPTextModel et CLIPTextModelWithProjection.
Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Paramètres :
state_dict (dict) : Un state dict standard contenant les paramètres des couches lora. La clé doit être préfixée par text_encoder supplémentaire afin de distinguer les couches lora de unet.
network_alphas (dict[str, float]) : La valeur de l'alpha du réseau utilisée pour un apprentissage stable et la prévention du sous-débordement. Cette valeur a la même signification que l'option --network_alpha du script d'entraînement kohya-ss. Consultez ce lien.
text_encoder (CLIPTextModel) : le modèle d'encodeur de texte dans lequel charger les couches LoRA.
prefix (str) : Préfixe attendu du text_encoder dans le state_dict.
lora_scale (float) : Facteur d'échelle appliqué à la sortie de la couche linéaire lora avant son ajout à la sortie de la couche lora standard.
adapter_name (str, facultatif) : Nom de l'adaptateur à utiliser pour référencer le modèle d'adaptateur chargé. S'il n'est pas spécifié, default_{i} sera utilisé, où i est le nombre total d'adaptateurs chargés.
low_cpu_mem_usage (bool, facultatif) : Accélère le chargement du modèle en ne chargeant que les poids LoRA préentraînés et sans initialiser les poids aléatoires.
hotswap (bool, facultatif) : Voir load_lora_weights().
metadata (dict) : métadonnées facultatives de l’adaptateur LoRA. Si fournies, les arguments LoraConfig de peft ne seront pas dérivés du dictionnaire d’état.
Cela chargera les couches LoRA spécifiées dans state_dict dans text_encoder
load_lora_into_transformer[[diffusers.loaders.SD3LoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, transformer, adapter_name = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False, metadata = None)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.SD3LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer', 'text_encoder', 'text_encoder_2'], **kwargs)
Voir unfuse_lora() pour plus de détails.
FluxLoraLoaderMixin[[diffusers.loaders.FluxLoraLoaderMixin]]
diffusers.loaders.FluxLoraLoaderMixin[[diffusers.loaders.FluxLoraLoaderMixin]]
diffusers.loaders.FluxLoraLoaderMixin()
Charger les couches LoRA dans FluxTransformer2DModel, CLIPTextModel.
Spécifique à 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)
Voir lora_state_dict() pour plus de détails.
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)
Paramètres :
state_dict (dict) : Un state dict standard contenant les paramètres des couches lora. La clé doit être préfixée par text_encoder supplémentaire afin de distinguer les couches lora de unet.
network_alphas (dict[str, float]) : La valeur de l'alpha du réseau utilisée pour un apprentissage stable et la prévention du sous-débordement. Cette valeur a la même signification que l'option --network_alpha du script d'entraînement kohya-ss. Consultez ce lien.
text_encoder (CLIPTextModel) : le modèle d'encodeur de texte dans lequel charger les couches LoRA.
prefix (str) : Préfixe attendu du text_encoder dans le state_dict.
lora_scale (float) : Facteur d'échelle appliqué à la sortie de la couche linéaire lora avant son ajout à la sortie de la couche lora standard.
adapter_name (str, facultatif) : Nom de l'adaptateur à utiliser pour référencer le modèle d'adaptateur chargé. S'il n'est pas spécifié, default_{i} sera utilisé, où i est le nombre total d'adaptateurs chargés.
low_cpu_mem_usage (bool, facultatif) : Accélère le chargement du modèle en ne chargeant que les poids LoRA préentraînés et sans initialiser les poids aléatoires.
hotswap (bool, facultatif) : Voir load_lora_weights().
metadata (dict) : métadonnées facultatives de l’adaptateur LoRA. Si fournies, les arguments LoraConfig de peft ne seront pas dérivés du dictionnaire d’état.
Cela chargera les couches LoRA spécifiées dans state_dict dans text_encoder
load_lora_into_transformer[[diffusers.loaders.FluxLoraLoaderMixin.load_lora_into_transformer]]
load_lora_into_transformer(state_dict, network_alphas, transformer, adapter_name = None, metadata = None, _pipeline = None, low_cpu_mem_usage = False, hotswap: bool = False)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Paramètres :
save_directory (str ou os.PathLike) : Répertoire où enregistrer les paramètres LoRA. Sera créé s'il n'existe pas.
transformer_lora_layers (dict[str, torch.nn.Module] ou dict[str, torch.Tensor]) : Dictionnaire d'état des couches LoRA correspondant au transformer.
text_encoder_lora_layers (dict[str, torch.nn.Module] ou dict[str, torch.Tensor]) : Dictionnaire d'état des couches LoRA correspondant au text_encoder. Il est nécessaire de passer explicitement le dictionnaire d'état LoRA de l'encodeur de texte, car il provient de 🤗 Transformers.
is_main_process (bool, facultatif, par défaut True) : Indique si le processus qui appelle cette fonction est le processus principal ou non. Utile lors de l'entraînement distribué lorsque vous devez appeler cette fonction sur tous les processus. Dans ce cas, définissez is_main_process=True uniquement sur le processus principal pour éviter les conditions de course.
save_function (Callable) : La fonction à utiliser pour enregistrer le dictionnaire d'état. Utile lors de l'entraînement distribué lorsque vous devez remplacer torch.save par une autre méthode. Peut être configuré avec la variable d'environnement DIFFUSERS_SAVE_MODE.
safe_serialization (bool, facultatif, par défaut True) : Indique si le modèle doit être enregistré en utilisant safetensors ou de manière traditionnelle PyTorch avec pickle.
transformer_lora_adapter_metadata : métadonnées de l'adaptateur LoRA associées au transformateur à sérialiser avec le dictionnaire d'état.
text_encoder_lora_adapter_metadata : métadonnées de l'adaptateur LoRA associées à l'encodeur de texte à sérialiser avec le dictionnaire d'état.
Enregistrez les paramètres LoRA correspondant à l'UNet et à l'encodeur de texte.
unfuse_lora[[diffusers.loaders.FluxLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer', 'text_encoder'], **kwargs)
Paramètres :
components (list[str]) : liste des composants injectables par LoRA dont il faut retirer l'injection de LoRA.
Annule l'effet de pipe.fuse_lora().
unload_lora_weights[[diffusers.loaders.FluxLoraLoaderMixin.unload_lora_weights]]
unload_lora_weights(reset_to_overwritten_params = False)
Paramètres :
reset_to_overwritten_params (bool, par défaut False) : Indique s'il faut réinitialiser les modules chargés avec LoRA à leurs paramètres d'origine. Consultez la documentation de Flux pour en savoir plus.
Décharge les paramètres LoRA.
Exemples :
>>> # 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()
Charge les couches LoRA dans Flux2Transformer2DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.Flux2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.Flux3LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
BriaFibo2LoraLoaderMixin[[diffusers.loaders.BriaFibo2LoraLoaderMixin]]
diffusers.loaders.BriaFibo2LoraLoaderMixin[[diffusers.loaders.BriaFibo2LoraLoaderMixin]]
diffusers.loaders.BriaFibo2LoraLoaderMixin()
Charge les couches LoRA dans BriaFibo2Transformer2DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.BriaFibo2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
ErnieImageLoraLoaderMixin[[diffusers.loaders.ErnieImageLoraLoaderMixin]]
diffusers.loaders.ErnieImageLoraLoaderMixin[[diffusers.loaders.ErnieImageLoraLoaderMixin]]
diffusers.loaders.ErnieImageLoraLoaderMixin()
Charge les couches LoRA dans ErnieImageTransformer2DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.ErnieImageLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
LTX2LoraLoaderMixin[[diffusers.loaders.LTX2LoraLoaderMixin]]
diffusers.loaders.LTX2LoraLoaderMixin[[diffusers.loaders.LTX2LoraLoaderMixin]]
diffusers.loaders.LTX2LoraLoaderMixin()
Charge les couches LoRA dans LTX2VideoTransformer3DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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')
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.LTX2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
CogVideoXLoraLoaderMixin[[diffusers.loaders.CogVideoXLoraLoaderMixin]]
diffusers.loaders.CogVideoXLoraLoaderMixin[[diffusers.loaders.CogVideoXLoraLoaderMixin]]
diffusers.loaders.CogVideoXLoraLoaderMixin()
Charge les couches LoRA dans CogVideoXTransformer3DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.CogVideoXLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
Mochi1LoraLoaderMixin[[diffusers.loaders.Mochi1LoraLoaderMixin]]
diffusers.loaders.Mochi1LoraLoaderMixin[[diffusers.loaders.Mochi1LoraLoaderMixin]]
diffusers.loaders.Mochi1LoraLoaderMixin()
Charge les couches LoRA dans MochiTransformer3DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.Mochi1LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
AuraFlowLoraLoaderMixin[[diffusers.loaders.AuraFlowLoraLoaderMixin]]
diffusers.loaders.AuraFlowLoraLoaderMixin[[diffusers.loaders.AuraFlowLoraLoaderMixin]]
diffusers.loaders.AuraFlowLoraLoaderMixin()
Charger les couches LoRA dans AuraFlowTransformer2DModel Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.AuraFlowLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer', 'text_encoder'], **kwargs)
Voir unfuse_lora() pour plus de détails.
LTXVideoLoraLoaderMixin[[diffusers.loaders.LTXVideoLoraLoaderMixin]]
diffusers.loaders.LTXVideoLoraLoaderMixin[[diffusers.loaders.LTXVideoLoraLoaderMixin]]
diffusers.loaders.LTXVideoLoraLoaderMixin()
Charge les couches LoRA dans LTXVideoTransformer3DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.LTXVideoLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
SanaLoraLoaderMixin[[diffusers.loaders.SanaLoraLoaderMixin]]
diffusers.loaders.SanaLoraLoaderMixin[[diffusers.loaders.SanaLoraLoaderMixin]]
diffusers.loaders.SanaLoraLoaderMixin()
Charge les couches LoRA dans SanaTransformer2DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.SanaLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
HeliosLoraLoaderMixin[[diffusers.loaders.HeliosLoraLoaderMixin]]
diffusers.loaders.HeliosLoraLoaderMixin[[diffusers.loaders.HeliosLoraLoaderMixin]]
diffusers.loaders.HeliosLoraLoaderMixin()
Charge les couches LoRA dans HeliosTransformer3DModel. Spécifique à HeliosPipeline et 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.HeliosLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
HunyuanVideoLoraLoaderMixin[[diffusers.loaders.HunyuanVideoLoraLoaderMixin]]
diffusers.loaders.HunyuanVideoLoraLoaderMixin[[diffusers.loaders.HunyuanVideoLoraLoaderMixin]]
diffusers.loaders.HunyuanVideoLoraLoaderMixin()
Charge les couches LoRA dans HunyuanVideoTransformer3DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.HunyuanVideoLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
Lumina2LoraLoaderMixin[[diffusers.loaders.Lumina2LoraLoaderMixin]]
diffusers.loaders.Lumina2LoraLoaderMixin[[diffusers.loaders.Lumina2LoraLoaderMixin]]
diffusers.loaders.Lumina2LoraLoaderMixin()
Charge les couches LoRA dans Lumina2Transformer2DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.Lumina2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
CogView4LoraLoaderMixin[[diffusers.loaders.CogView4LoraLoaderMixin]]
diffusers.loaders.CogView4LoraLoaderMixin[[diffusers.loaders.CogView4LoraLoaderMixin]]
diffusers.loaders.CogView4LoraLoaderMixin()
Charge les couches LoRA dans WanTransformer3DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.CogView4LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
WanLoraLoaderMixin[[diffusers.loaders.WanLoraLoaderMixin]]
diffusers.loaders.WanLoraLoaderMixin[[diffusers.loaders.WanLoraLoaderMixin]]
diffusers.loaders.WanLoraLoaderMixin()
Charge les couches LoRA dans WanTransformer3DModel. Spécifique à WanPipeline et [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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.WanLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
SkyReelsV2LoraLoaderMixin[[diffusers.loaders.SkyReelsV2LoraLoaderMixin]]
diffusers.loaders.SkyReelsV2LoraLoaderMixin[[diffusers.loaders.SkyReelsV2LoraLoaderMixin]]
diffusers.loaders.SkyReelsV2LoraLoaderMixin()
Charger les couches LoRA dans 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.SkyReelsV2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Paramètres :
save_directory (str ou os.PathLike) : Répertoire où enregistrer les paramètres LoRA. Sera créé s'il n'existe pas.
unet_lora_layers (dict[str, torch.nn.Module] ou dict[str, torch.Tensor]) : Dictionnaire d'état des couches LoRA correspondant à unet.
text_encoder_lora_layers (dict[str, torch.nn.Module] ou dict[str, torch.Tensor]) : Dictionnaire d'état des couches LoRA correspondant au text_encoder. Il est nécessaire de passer explicitement le dictionnaire d'état LoRA de l'encodeur de texte, car il provient de 🤗 Transformers.
is_main_process (bool, facultatif, par défaut True) : Indique si le processus qui appelle cette fonction est le processus principal ou non. Utile lors de l'entraînement distribué lorsque vous devez appeler cette fonction sur tous les processus. Dans ce cas, définissez is_main_process=True uniquement sur le processus principal pour éviter les conditions de course.
save_function (Callable) : La fonction à utiliser pour enregistrer le dictionnaire d'état. Utile lors de l'entraînement distribué lorsque vous devez remplacer torch.save par une autre méthode. Peut être configuré avec la variable d'environnement DIFFUSERS_SAVE_MODE.
safe_serialization (bool, facultatif, par défaut True) : Indique si le modèle doit être enregistré en utilisant safetensors ou de manière traditionnelle PyTorch avec pickle.
Enregistrez les paramètres LoRA correspondant à l'UNet et à l'encodeur de texte.
AnimaLoraLoaderMixin[[diffusers.loaders.AnimaLoraLoaderMixin]]
diffusers.loaders.AnimaLoraLoaderMixin[[diffusers.loaders.AnimaLoraLoaderMixin]]
diffusers.loaders.AnimaLoraLoaderMixin()
Charger les couches LoRA dans CosmosTransformer3DModel et 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
unfuse_lora[[diffusers.loaders.AnimaLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer', 'text_conditioner'], **kwargs)
Voir unfuse_lora() pour plus de détails.
AceStepLoraLoaderMixin[[diffusers.loaders.AceStepLoraLoaderMixin]]
diffusers.loaders.AceStepLoraLoaderMixin[[diffusers.loaders.AceStepLoraLoaderMixin]]
diffusers.loaders.AceStepLoraLoaderMixin()
Charge les couches LoRA dans AceStepTransformer1DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.AceStepLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
HiDreamImageLoraLoaderMixin[[diffusers.loaders.HiDreamImageLoraLoaderMixin]]
diffusers.loaders.HiDreamImageLoraLoaderMixin[[diffusers.loaders.HiDreamImageLoraLoaderMixin]]
diffusers.loaders.HiDreamImageLoraLoaderMixin()
Charge les couches LoRA dans HiDreamImageTransformer2DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.HiDreamImageLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
QwenImageLoraLoaderMixin[[diffusers.loaders.QwenImageLoraLoaderMixin]]
diffusers.loaders.QwenImageLoraLoaderMixin[[diffusers.loaders.QwenImageLoraLoaderMixin]]
diffusers.loaders.QwenImageLoraLoaderMixin()
Charge les couches LoRA dans QwenImageTransformer2DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.QwenImageLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
ZImageLoraLoaderMixin[[diffusers.loaders.ZImageLoraLoaderMixin]]
diffusers.loaders.ZImageLoraLoaderMixin[[diffusers.loaders.ZImageLoraLoaderMixin]]
diffusers.loaders.ZImageLoraLoaderMixin()
Charge les couches LoRA dans ZImageTransformer2DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.ZImageLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
CosmosLoraLoaderMixin[[diffusers.loaders.CosmosLoraLoaderMixin]]
diffusers.loaders.CosmosLoraLoaderMixin[[diffusers.loaders.CosmosLoraLoaderMixin]]
diffusers.loaders.CosmosLoraLoaderMixin()
Charger les couches LoRA dans CosmosTransformer3DModel, spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.CosmosLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
KandinskyLoraLoaderMixin[[diffusers.loaders.KandinskyLoraLoaderMixin]]
diffusers.loaders.KandinskyLoraLoaderMixin[[diffusers.loaders.KandinskyLoraLoaderMixin]]
diffusers.loaders.KandinskyLoraLoaderMixin()
Charger les couches LoRA dans 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.KandinskyLoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
Ideogram4LoraLoaderMixin[[diffusers.loaders.Ideogram4LoraLoaderMixin]]
diffusers.loaders.Ideogram4LoraLoaderMixin[[diffusers.loaders.Ideogram4LoraLoaderMixin]]
diffusers.loaders.Ideogram4LoraLoaderMixin()
Charge les couches LoRA dans Ideogram4Transformer2DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.Ideogram4LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
Krea2LoraLoaderMixin[[diffusers.loaders.Krea2LoraLoaderMixin]]
diffusers.loaders.Krea2LoraLoaderMixin[[diffusers.loaders.Krea2LoraLoaderMixin]]
diffusers.loaders.Krea2LoraLoaderMixin()
Charge les couches LoRA dans Krea2Transformer2DModel. Spécifique à 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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Voir load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Voir save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.Krea2LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer'], **kwargs)
Voir unfuse_lora() pour plus de détails.
MiniMaxH3LoraLoaderMixin[[diffusers.loaders.MiniMaxH3LoraLoaderMixin]]
diffusers.loaders.MiniMaxH3LoraLoaderMixin[[diffusers.loaders.MiniMaxH3LoraLoaderMixin]]
diffusers.loaders.MiniMaxH3LoraLoaderMixin()
Charge les couches LoRA dans MiniMaxH3Transformer3DModel. Spécifique à MiniMaxH3ModularPipeline.
MiniMax-H3 embarque deux partitions DiT indépendantes portant des noms de modules identiques (un LoRA destiné à l’une se charge dans l’autre et dégrade la sortie), la routage est donc explicite : les dictionnaires d’état convertis ciblent transformer. ; pour accéder à transformer_ref, utilisez un fichier préfixé par transformer_ref. ou load_into_transformer_ref=True.
Les LoRA de DiffSynth-Studio (par exemple DiffSynth-Studio/MiniMax-H3-LoRA-LineartAnime) sont entraînés sur le QKV fusionné par tête et entrelacé du point de contrôle brut, puis désentrelacés lors de la conversion. Leurs facteurs fp32 font que le chemin LoRA non fusionné effectue les calculs en fp32 ; l'application de .to(torch.bfloat16) au modèle après chargement restaure le budget mémoire bf16.
Les LoRAs entraînés sur un point de contrôle élagué (les fichiers *_pruned_* dans Comfy-Org/MiniMax-H3 ; joyfox/MiniMax-H3-Turbo en est un) échouent avec une erreur de correspondance de taille. Les fichiers sans alpha == rank sont chargés avec alpha == rank (échelle 1.0, la convention énoncée par exemple par larryvrh/MiniMax-H3-Turbo-Lora) ; une entrée __metadata__ alpha (par exemple le fichier 8 étapes de lightx2v/Minimax-h3-Turbo), lorsqu'elle est présente, est prise en compte à la place.
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)
Voir fuse_lora() pour plus de détails.
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)
Voir load_lora_into_unet() pour plus de détails.
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)
Chargez les couches LoRA dans la partition transformer_ref. prefix est le nom du composant porté par les clés, qui est transformer_ref pour un fichier qui nomme la partition et transformer pour un fichier routé ici par load_into_transformer_ref=True. Consultez load_lora_into_unet() pour plus de détails.
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)
Paramètres :
load_into_transformer_ref (bool, par défaut False) : Charge les couches préfixées par transformer. dans la partition transformer_ref — celle avec laquelle le workflow ref2va effectue le débruitage — au lieu de transformer. Nécessaire uniquement lorsque les deux partitions sont chargées : un pipeline qui ne détient que transformer_ref y achemine les opérations de lui-même.
Charge les couches LoRA dans transformer ou, avec load_into_transformer_ref=True, dans transformer_ref. Consultez load_lora_weights() pour plus de détails.
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)
Voir lora_state_dict() pour plus de détails.
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)
Enregistrez les couches LoRA d’une ou des deux partitions de MiniMax-H3. Il est impossible de déterminer à quelle partition appartient un LoRA à partir de ses clés ; c’est donc la seule manière de publier un LoRA H3 qui le consigne. Consultez save_lora_weights() pour plus d’informations.
unfuse_lora[[diffusers.loaders.MiniMaxH3LoraLoaderMixin.unfuse_lora]]
unfuse_lora(components: list[str] = ['transformer', 'transformer_ref'], **kwargs)
Voir unfuse_lora() pour plus de détails.
PikaH3FlexLoraLoaderMixin[[diffusers.loaders.PikaH3FlexLoraLoaderMixin]]
diffusers.loaders.PikaH3FlexLoraLoaderMixin[[diffusers.loaders.PikaH3FlexLoraLoaderMixin]]
diffusers.loaders.PikaH3FlexLoraLoaderMixin()
Charge les couches LoRA dans MiniMaxH3Transformer3DModel. Spécifique à PikaH3FlexModularPipeline.
La sortie Pika H3 Flex est une paire d'adaptateurs de rang 128 sur les deux partitions de transformeurs MiniMax-H3, publiées sous forme de dumps PEFT simples portant les noms de modules diffusers (fl2va/adapter.safetensors pour transformer, ref2va/adapter.safetensors pour transformer_ref). Les fichiers sans alpha se chargent avec alpha == rank (échelle 1.0), le contrat propre aux adaptateurs, et le chargement, le routage et la sauvegarde sont ceux de MiniMaxH3LoraLoaderMixin : l'adaptateur fl2va est placé dans transformer, et l'adaptateur ref2va dans transformer_ref — seul lorsque le pipeline détient cette partition à elle seule (workflow="ref2va"), avec load_into_transformer_ref=True lorsqu'il détient les deux.
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 utilitaire pour la gestion des LoRA.
delete_adapters[[diffusers.loaders.lora_base.LoraBaseMixin.delete_adapters]]
delete_adapters(adapter_names: list[str] | str)
Paramètres :
adapter_names (list[str, str]) : Les noms des adaptateurs à supprimer.
Supprimer les couches LoRA d'un adaptateur du pipeline.
Exemple :
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()
Désactive les couches LoRA actives du pipeline.
Exemple :
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()
Active les couches LoRA actives du pipeline.
Exemple :
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)
Paramètres :
target_rank (int) : Le rang le plus élevé parmi tous les adaptateurs qui seront chargés.
check_compiled (str, facultatif, par défaut "error") : Comment gérer un modèle déjà compilé. La vérification peut renvoyer les messages suivants : - "error" (par défaut) : lever une erreur - "warn" : émettre un avertissement - "ignore" : ne rien faire
Chauder les adaptateurs sans déclencher la recompilation d'un modèle ou si les rangs des adaptateurs chargés sont différents.
fuse_lora[[diffusers.loaders.lora_base.LoraBaseMixin.fuse_lora]]
fuse_lora(components: list[str] | None = None, lora_scale: float = 1.0, safe_fusing: bool = False, adapter_names: list[str] | None = None, **kwargs)
Paramètres :
components : (list[str]) : liste des composants injectables par LoRA dans lesquels fusionner les LoRA.
lora_scale (float, par défaut 1.0) : Contrôle dans quelle mesure les paramètres LoRA influencent les sorties.
safe_fusing (bool, par défaut False) : Indique s'il faut vérifier les poids fusionnés pour détecter des valeurs NaN avant la fusion, et, si des valeurs sont NaN, de ne pas les fusionner.
adapter_names (list[str], facultatif) : Noms des adaptateurs à utiliser pour la fusion. Si rien n'est transmis, tous les adaptateurs actifs seront fusionnés.
Fond les paramètres LoRA dans les paramètres originaux des blocs correspondants.
Exemple :
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()
Renvoie la liste des adaptateurs actifs actuels.
Exemple :
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()
Renvoie la liste actuelle de tous les adaptateurs disponibles dans le 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)
Paramètres :
adapter_names (list[str] ou str) : Les noms des adaptateurs à utiliser.
adapter_weights (float, dict ou list, facultatif) : Poids pour les adaptateurs. Un scalaire met à l'échelle tous les composants compatibles LoRA. Un dictionnaire associe les noms de composants (par ex. "unet", "transformer" ou "text_encoder") à des poids ; le poids d'un composant UNet peut également être un dictionnaire imbriqué d'échelles de blocs. Un scalaire ou un dictionnaire unique est appliqué à chaque adaptateur. Une liste doit contenir un scalaire, un dictionnaire ou None par adaptateur, dans l'ordre de adapter_names. None est par défaut 1.0, y compris pour les entrées de liste et les poids des composants. Les composants non spécifiés et les blocs UNet sont également par défaut 1.0.
Définissez les adaptateurs actuellement actifs pour leur utilisation dans le pipeline.
Exemple :
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)
Paramètres :
adapter_names (list[str]) : liste des adaptateurs à envoyer vers l'appareil.
device (torch.device | str | int) : Appareil vers lequel envoyer les adaptateurs. Peut être un appareil torch, une chaîne de caractères ou un entier.
Déplace les LoRA listés dans adapter_names vers un appareil cible. Utile pour décharger le LoRA sur le CPU si vous souhaitez charger plusieurs adaptateurs et libérer de la mémoire GPU.
Après avoir déchargé les adaptateurs LoRA sur le CPU, tant que le reste du modèle est toujours sur le GPU, les adaptateurs LoRA ne peuvent plus être utilisés pour l'inférence, car cela provoquerait une incompatibilité de périphérique. Pensez à réinitialiser le périphérique sur le GPU avant d'utiliser ces adaptateurs LoRA pour l'inférence.
>>> 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)
Paramètres :
components (list[str]) : liste des composants injectables par LoRA dont il faut retirer l'injection de LoRA.
unfuse_unet (bool, par défaut True) : Indique s'il faut désfusionner les paramètres LoRA du UNet.
unfuse_text_encoder (bool, par défaut True) : Indique s'il faut désfusionner les paramètres LoRA de l'encodeur de texte. Si l'encodeur de texte n'a pas été modifié (monkey-patched) avec les paramètres LoRA, cela n'aura aucun effet.
Annule l'effet de pipe.fuse_lora().
unload_lora_weights[[diffusers.loaders.lora_base.LoraBaseMixin.unload_lora_weights]]
unload_lora_weights()
Décharge les paramètres LoRA.
Exemples :
>>> # 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)
Écrit le dictionnaire d'état des couches LoRA (éventuellement avec des métadonnées) sur le disque.
Xet Storage Details
- Size:
- 166 kB
- Xet hash:
- cc242d16db22e17da3d0f85de427b7864c80a627fe845270230f64bf8cdc10fb
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.