Diffusers documentation
LoRA
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
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
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
LoraBaseMixin
Classe utilitaire pour la gestion des LoRA.
delete_adapters
< source >( adapter_names: list[str] | str )
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")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()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
< source >( **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
Basculez entre les adaptateurs sans déclencher la recompilation d'un modèle ou si les rangs des adaptateurs chargés sont différents.
fuse_lora
< source >( components: list[str] | None = Nonelora_scale: float = 1.0safe_fusing: bool = Falseadapter_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 l'influence des paramètres LoRA sur les sorties. - safe_fusing (
bool, par défautFalse) — Indique s'il faut vérifier les poids fusionnés à la recherche de 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)Renvoie la liste des adaptateurs actifs actuels.
Renvoie la liste actuelle de tous les adaptateurs disponibles dans le pipeline.
set_adapters
< source >( adapter_names: list[str] | stradapter_weights: float | dict[str, float | dict | None] | list[float | dict[str, float | dict | None] | None] | None = None )
Paramètres
- adapter_names (
list[str]oustr) — Les noms des adaptateurs à utiliser. - adapter_weights (
float,dictoulist, facultatif) — Poids des adaptateurs. Un scalaire met à l’échelle tous les composants compatibles LoRA. Un dictionnaire associe les noms des 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 ouNonepar adaptateur, dans l’ordre deadapter_names.Noneest par défaut1.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éfaut1.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
< source >( adapter_names: list[str]device: torch.device | str | int )
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
< source >( components: list[str] | None = None**kwargs )
Paramètres
- components (
list[str]) — liste des composants injectables par LoRA dont on veut retirer l'injection de LoRA. - unfuse_unet (
bool, par défautTrue) — Indique s'il faut défusionner les paramètres LoRA du UNet. - unfuse_text_encoder (
bool, par défautTrue) — Indique s'il faut défusionner 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().
Décharge les paramètres LoRA.
write_lora_layers
< source >( state_dict: dict[str, torch.Tensor]save_directory: stris_main_process: boolweight_name: strsave_function: Callablesafe_serialization: boollora_adapter_metadata: dict | None = None )
Écrit le dictionnaire d'état des couches LoRA (éventuellement avec des métadonnées) sur le disque.
StableDiffusionLoraLoaderMixin
Charger les couches LoRA dans le UNet2DConditionModel et le CLIPTextModel de Stable Diffusion.
load_lora_into_text_encoder
< source >( state_dictnetwork_alphastext_encoderprefix = Nonelora_scale = 1.0adapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Paramètres
- state_dict (
dict) — Un state dict standard contenant les paramètres des couches lora. La clé doit être préfixée par untext_encodersupplémentaire afin de distinguer les couches lora de l'unet. - network_alphas (
dict[str, float]) — La valeur de l'alpha du réseau utilisée pour un apprentissage stable et pour prévenir le sous-débordement. Cette valeur a la même signification que l'option--network_alphadu 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 dutext_encoderdans lestate_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 argumentsLoraConfigdepeftne 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
< source >( state_dictnetwork_alphasunetadapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = 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 l'unet, soit préfixées par ununetsupplémentaire, ce qui permet de distinguer les couches lora de l'encodeur de texte. - network_alphas (
dict[str, float]) — La valeur de l'alpha du réseau utilisée pour un apprentissage stable et pour prévenir le sous-débordement. Cette valeur a la même signification que l'option--network_alphadu 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 argumentsLoraConfigdepeftne 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
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Paramètres
- pretrained_model_name_or_path_or_dict (
strouos.PathLikeoudict) — 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) — Valeur par défaut :False. Indique s'il faut remplacer un adaptateur (LoRA) existant par l'adaptateur nouvellement chargé, en 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 hotswap 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 hotswap, leadapter_namedoit correspondre au nom d'un adaptateur déjà chargé.Si le nouvel adaptateur et l’ancien adaptateur ont des rangs et/ou des alphas LoRA (c.-à-d. un facteur d’échelle) différents, vous devez appeler une méthode supplémentaire avant de charger l’adaptateur :
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
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Paramètres
- pretrained_model_name_or_path_or_dict (
strouos.PathLikeoudict) — Peut être l'un des éléments suivants :- 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.
- Une chaîne de caractères, l'identifiant du modèle (par exemple
- 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éfautFalse) — 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éfautFalse) — Indique s'il faut charger uniquement les poids et les fichiers de configuration du modèle en local. Si défini surTrue, le modèle ne sera pas téléchargé depuis le Hub. - token (
strou bool, facultatif) — Le jeton à utiliser comme autorisation bearer HTTP pour les fichiers distants. SiTrue, le jeton généré pardiffusers-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, par défaut"") — L’emplacement du sous-dossier d’un 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, par défaut None) — Nom du fichier de dictionnaire d'état sérialisé. - return_lora_metadata (
bool, facultatif, valeur par défaut False) — Lorsqu’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, dans une mesure limitée. > > Cette fonction est expérimentale et pourrait évoluer à l'avenir.
save_lora_weights
< source >( save_directory: str | os.PathLikeunet_lora_layers: dict = Nonetext_encoder_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Trueunet_lora_adapter_metadata = Nonetext_encoder_lora_adapter_metadata = None )
Paramètres
- save_directory (
strouos.PathLike) — Répertoire dans lequel enregistrer les paramètres LoRA. Sera créé s'il n'existe pas. - unet_lora_layers (
dict[str, torch.nn.Module]oudict[str, torch.Tensor]) — Dictionnaire d'état des couches LoRA correspondant àunet. - text_encoder_lora_layers (
dict[str, torch.nn.Module]oudict[str, torch.Tensor]) — Dictionnaire d’état des couches LoRA correspondant àtext_encoder. Il est nécessaire de passer explicitement le dictionnaire d’état des couches LoRA de l’encodeur de texte, car il provient de 🤗 Transformers. - is_main_process (
bool, facultatif, par défautTrue) — 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éfinissezis_main_process=Trueuniquement 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 remplacertorch.savepar une autre méthode. Peut être configurée avec la variable d'environnementDIFFUSERS_SAVE_MODE. - safe_serialization (
bool, facultatif, par défautTrue) — Indique si le modèle doit être enregistré en utilisantsafetensorsou la méthode traditionnelle de PyTorch avecpickle. - 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
Charger les couches LoRA dans le UNet2DConditionModel, le CLIPTextModel et le CLIPTextModelWithProjection de Stable Diffusion XL.
fuse_lora
< source >( components: list = ['unet', 'text_encoder', 'text_encoder_2']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_text_encoder
< source >( state_dictnetwork_alphastext_encoderprefix = Nonelora_scale = 1.0adapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Paramètres
- state_dict (
dict) — Un state dict standard contenant les paramètres des couches lora. La clé doit être préfixée par untext_encodersupplémentaire afin de distinguer les couches lora de l'unet. - network_alphas (
dict[str, float]) — La valeur de l'alpha du réseau utilisée pour un apprentissage stable et pour prévenir le sous-débordement. Cette valeur a la même signification que l'option--network_alphadu 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 dutext_encoderdans lestate_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 argumentsLoraConfigdepeftne 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
< source >( state_dictnetwork_alphasunetadapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = 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 l'unet, soit préfixées par ununetsupplémentaire, ce qui permet de distinguer les couches lora de l'encodeur de texte. - network_alphas (
dict[str, float]) — La valeur de l'alpha du réseau utilisée pour un apprentissage stable et pour prévenir le sous-débordement. Cette valeur a la même signification que l'option--network_alphadu 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 argumentsLoraConfigdepeftne 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
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Paramètres
- pretrained_model_name_or_path_or_dict (
strouos.PathLikeoudict) — Peut être l'un des éléments suivants :- 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.
- Une chaîne de caractères, l'identifiant du modèle (par exemple
- 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éfautFalse) — 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éfautFalse) — Indique s'il faut charger uniquement les poids et les fichiers de configuration du modèle en local. Si défini surTrue, le modèle ne sera pas téléchargé depuis le Hub. - token (
strou bool, facultatif) — Le jeton à utiliser comme autorisation bearer HTTP pour les fichiers distants. SiTrue, le jeton généré pardiffusers-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, par défaut"") — L’emplacement du sous-dossier d’un 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, par défaut None) — Nom du fichier de dictionnaire d'état sérialisé. - return_lora_metadata (
bool, facultatif, valeur par défaut False) — Lorsqu’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, dans une mesure limitée. > > Cette fonction est expérimentale et pourrait évoluer à l'avenir.
save_lora_weights
< source >( save_directory: str | os.PathLikeunet_lora_layers: dict = Nonetext_encoder_lora_layers: dict = Nonetext_encoder_2_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Trueunet_lora_adapter_metadata = Nonetext_encoder_lora_adapter_metadata = Nonetext_encoder_2_lora_adapter_metadata = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
SD3LoraLoaderMixin
Charger les couches LoRA dans SD3Transformer2DModel, CLIPTextModel et CLIPTextModelWithProjection.
Spécifique à StableDiffusion3Pipeline.
fuse_lora
< source >( components: list = ['transformer', 'text_encoder', 'text_encoder_2']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_text_encoder
< source >( state_dictnetwork_alphastext_encoderprefix = Nonelora_scale = 1.0adapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Paramètres
- state_dict (
dict) — Un state dict standard contenant les paramètres des couches lora. La clé doit être préfixée par untext_encodersupplémentaire afin de distinguer les couches lora de l'unet. - network_alphas (
dict[str, float]) — La valeur de l'alpha du réseau utilisée pour un apprentissage stable et pour prévenir le sous-débordement. Cette valeur a la même signification que l'option--network_alphadu 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 dutext_encoderdans lestate_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 argumentsLoraConfigdepeftne 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
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Nonetext_encoder_lora_layers: dict = Nonetext_encoder_2_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata = Nonetext_encoder_lora_adapter_metadata = Nonetext_encoder_2_lora_adapter_metadata = None )
Voir save_lora_weights() pour plus d’informations.
unfuse_lora
< source >( components: list = ['transformer', 'text_encoder', 'text_encoder_2']**kwargs )
Voir unfuse_lora() pour plus de détails.
FluxLoraLoaderMixin
Charger les couches LoRA dans FluxTransformer2DModel, CLIPTextModel.
Spécifique à FluxPipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir lora_state_dict() pour plus de détails.
load_lora_into_text_encoder
< source >( state_dictnetwork_alphastext_encoderprefix = Nonelora_scale = 1.0adapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Paramètres
- state_dict (
dict) — Un state dict standard contenant les paramètres des couches lora. La clé doit être préfixée par untext_encodersupplémentaire afin de distinguer les couches lora de l'unet. - network_alphas (
dict[str, float]) — La valeur de l'alpha du réseau utilisée pour un apprentissage stable et pour prévenir le sous-débordement. Cette valeur a la même signification que l'option--network_alphadu 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 dutext_encoderdans lestate_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 argumentsLoraConfigdepeftne 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
< source >( state_dictnetwork_alphastransformeradapter_name = Nonemetadata = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = False )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Nonetext_encoder_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata = Nonetext_encoder_lora_adapter_metadata = None )
Paramètres
- save_directory (
strouos.PathLike) — Répertoire dans lequel enregistrer les paramètres LoRA. Sera créé s'il n'existe pas. - transformer_lora_layers (
dict[str, torch.nn.Module]oudict[str, torch.Tensor]) — Dictionnaire d'état des couches LoRA correspondant autransformer. - text_encoder_lora_layers (
dict[str, torch.nn.Module]oudict[str, torch.Tensor]) — Dictionnaire d’état des couches LoRA correspondant àtext_encoder. Il est nécessaire de passer explicitement le dictionnaire d’état des couches LoRA de l’encodeur de texte, car il provient de 🤗 Transformers. - is_main_process (
bool, facultatif, par défautTrue) — 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éfinissezis_main_process=Trueuniquement 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 remplacertorch.savepar une autre méthode. Peut être configurée avec la variable d'environnementDIFFUSERS_SAVE_MODE. - safe_serialization (
bool, facultatif, par défautTrue) — Indique si le modèle doit être enregistré en utilisantsafetensorsou la méthode traditionnelle de PyTorch avecpickle. - transformer_lora_adapter_metadata — métadonnées de l'adaptateur LoRA associées au transformer, à 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
< source >( components: list = ['transformer', 'text_encoder']**kwargs )
Annule l'effet de pipe.fuse_lora().
unload_lora_weights
< source >( reset_to_overwritten_params = False )
Paramètres
- reset_to_overwritten_params (
bool, par défautFalse) — 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.
Flux2LoraLoaderMixin
Charge les couches LoRA dans Flux2Transformer2DModel. Spécifique à Flux2Pipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
Flux3LoraLoaderMixin
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
save_lora_weights
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
BriaFibo2LoraLoaderMixin
Charge les couches LoRA dans BriaFibo2Transformer2DModel. Spécifique à BriaFibo2Pipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
ErnieImageLoraLoaderMixin
Charge les couches LoRA dans ErnieImageTransformer2DModel. Spécifique à ErnieImagePipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
LTX2LoraLoaderMixin
Charge les couches LoRA dans LTX2VideoTransformer3DModel. Spécifique à LTX2Pipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = Noneprefix: str = 'transformer' )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
CogVideoXLoraLoaderMixin
Charge les couches LoRA dans CogVideoXTransformer3DModel. Spécifique à CogVideoXPipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
Mochi1LoraLoaderMixin
Charge les couches LoRA dans MochiTransformer3DModel. Spécifique à MochiPipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
AuraFlowLoraLoaderMixin
Charger les couches LoRA dans AuraFlowTransformer2DModel Spécifique à AuraFlowPipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
LTXVideoLoraLoaderMixin
Charge les couches LoRA dans LTXVideoTransformer3DModel. Spécifique à LTXPipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
SanaLoraLoaderMixin
Charge les couches LoRA dans SanaTransformer2DModel. Spécifique à SanaPipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
HeliosLoraLoaderMixin
Charge les couches LoRA dans HeliosTransformer3DModel. Spécifique à HeliosPipeline et HeliosPyramidPipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
HunyuanVideoLoraLoaderMixin
Charge les couches LoRA dans HunyuanVideoTransformer3DModel. Spécifique à HunyuanVideoPipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
Lumina2LoraLoaderMixin
Charge les couches LoRA dans Lumina2Transformer2DModel. Spécifique à Lumina2Pipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
CogView4LoraLoaderMixin
Charge les couches LoRA dans WanTransformer3DModel. Spécifique à CogView4Pipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
WanLoraLoaderMixin
Charge les couches LoRA dans WanTransformer3DModel. Spécifique à WanPipeline et [WanImageToVideoPipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
SkyReelsV2LoraLoaderMixin
Charger les couches LoRA dans SkyReelsV2Transformer3DModel.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
AmusedLoraLoaderMixin
load_lora_into_transformer
< source >( state_dictnetwork_alphastransformeradapter_name = Nonemetadata = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = False )
Voir load_lora_into_unet() pour plus de détails.
save_lora_weights
< source >( save_directory: str | os.PathLiketext_encoder_lora_layers: dict = Nonetransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = True )
Paramètres
- save_directory (
strouos.PathLike) — Répertoire dans lequel enregistrer les paramètres LoRA. Sera créé s'il n'existe pas. - unet_lora_layers (
dict[str, torch.nn.Module]oudict[str, torch.Tensor]) — Dictionnaire d'état des couches LoRA correspondant àunet. - text_encoder_lora_layers (
dict[str, torch.nn.Module]oudict[str, torch.Tensor]) — Dictionnaire d’état des couches LoRA correspondant àtext_encoder. Il est nécessaire de passer explicitement le dictionnaire d’état des couches LoRA de l’encodeur de texte, car il provient de 🤗 Transformers. - is_main_process (
bool, facultatif, par défautTrue) — 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éfinissezis_main_process=Trueuniquement 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 remplacertorch.savepar une autre méthode. Peut être configurée avec la variable d'environnementDIFFUSERS_SAVE_MODE. - safe_serialization (
bool, facultatif, par défautTrue) — Indique si le modèle doit être enregistré en utilisantsafetensorsou la méthode traditionnelle de PyTorch avecpickle.
Enregistrez les paramètres LoRA correspondant à l'UNet et à l'encodeur de texte.
AnimaLoraLoaderMixin
Charger les couches LoRA dans CosmosTransformer3DModel et AnimaTextConditioner.
fuse_lora
< source >( components: list = ['transformer', 'text_conditioner']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]**kwargs )
Voir lora_state_dict() pour plus de détails.
Voir unfuse_lora() pour plus de détails.
AceStepLoraLoaderMixin
Charge les couches LoRA dans AceStepTransformer1DModel. Spécifique à AceStepPipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
HiDreamImageLoraLoaderMixin
Charge les couches LoRA dans HiDreamImageTransformer2DModel. Spécifique à HiDreamImagePipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
QwenImageLoraLoaderMixin
Charge les couches LoRA dans QwenImageTransformer2DModel. Spécifique à QwenImagePipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
ZImageLoraLoaderMixin
Charge les couches LoRA dans ZImageTransformer2DModel. Spécifique à ZImagePipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
CosmosLoraLoaderMixin
Charger les couches LoRA dans CosmosTransformer3DModel, spécifique à Cosmos2_5_PredictBasePipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
KandinskyLoraLoaderMixin
Charger les couches LoRA dans Kandinsky5Transformer3DModel,
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
Ideogram4LoraLoaderMixin
Charge les couches LoRA dans Ideogram4Transformer2DModel. Spécifique à Ideogram4Pipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
Krea2LoraLoaderMixin
Charge les couches LoRA dans Krea2Transformer2DModel. Spécifique à Krea2Pipeline.
fuse_lora
< source >( components: list = ['transformer']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = False**kwargs )
Voir load_lora_weights() pour plus de détails.
lora_state_dict
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = None )
Voir save_lora_weights() pour plus d’informations.
Voir unfuse_lora() pour plus de détails.
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), le 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 les QKV fusionnés par tête et entrelacés 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 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
< source >( components: list = ['transformer', 'transformer_ref']lora_scale: float = 1.0safe_fusing: bool = Falseadapter_names: list[str] | None = None**kwargs )
Voir fuse_lora() pour plus de détails.
load_lora_into_transformer
< source >( state_dicttransformeradapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Voir load_lora_into_unet() pour plus de détails.
load_lora_into_transformer_ref
< source >( state_dicttransformer_refprefixadapter_name = None_pipeline = Nonelow_cpu_mem_usage = Falsehotswap: bool = Falsemetadata = None )
Charge 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. Voir load_lora_into_unet() pour plus de détails.
load_lora_weights
< source >( pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor]adapter_name: str | None = Nonehotswap: bool = Falseload_into_transformer_ref: bool = False**kwargs )
Paramètres
- load_into_transformer_ref (
bool, par défautFalse) — Charge les couches préfixées partransformer.dans la partitiontransformer_ref— celle avec laquelle le workflowref2vaeffectue le débruitage — au lieu detransformer. Nécessaire uniquement lorsque les deux partitions sont chargées : un pipeline qui ne contient quetransformer_refy achemine les données 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
< source >( 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
< source >( save_directory: str | os.PathLiketransformer_lora_layers: dict = Nonetransformer_ref_lora_layers: dict = Noneis_main_process: bool = Trueweight_name: str = Nonesave_function: typing.Callable = Nonesafe_serialization: bool = Truetransformer_lora_adapter_metadata: dict | None = Nonetransformer_ref_lora_adapter_metadata: dict | None = None )
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.
Voir unfuse_lora() pour plus de détails.
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 transformeur 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 va dans transformer, et l’adaptateur ref2va dans transformer_ref — seul lorsque le pipeline
ne détient que cette partition (workflow="ref2va"), avec load_into_transformer_ref=True lorsqu’il détient les deux.
LoraBaseMixin
Classe utilitaire pour la gestion des LoRA.
delete_adapters
< source >( adapter_names: list[str] | str )
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")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()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
< source >( **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
Basculez entre les adaptateurs sans déclencher la recompilation d'un modèle ou si les rangs des adaptateurs chargés sont différents.
fuse_lora
< source >( components: list[str] | None = Nonelora_scale: float = 1.0safe_fusing: bool = Falseadapter_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 l'influence des paramètres LoRA sur les sorties. - safe_fusing (
bool, par défautFalse) — Indique s'il faut vérifier les poids fusionnés à la recherche de 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)Renvoie la liste des adaptateurs actifs actuels.
Renvoie la liste actuelle de tous les adaptateurs disponibles dans le pipeline.
set_adapters
< source >( adapter_names: list[str] | stradapter_weights: float | dict[str, float | dict | None] | list[float | dict[str, float | dict | None] | None] | None = None )
Paramètres
- adapter_names (
list[str]oustr) — Les noms des adaptateurs à utiliser. - adapter_weights (
float,dictoulist, facultatif) — Poids des adaptateurs. Un scalaire met à l’échelle tous les composants compatibles LoRA. Un dictionnaire associe les noms des 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 ouNonepar adaptateur, dans l’ordre deadapter_names.Noneest par défaut1.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éfaut1.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
< source >( adapter_names: list[str]device: torch.device | str | int )
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
< source >( components: list[str] | None = None**kwargs )
Paramètres
- components (
list[str]) — liste des composants injectables par LoRA dont on veut retirer l'injection de LoRA. - unfuse_unet (
bool, par défautTrue) — Indique s'il faut défusionner les paramètres LoRA du UNet. - unfuse_text_encoder (
bool, par défautTrue) — Indique s'il faut défusionner 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().
Décharge les paramètres LoRA.
write_lora_layers
< source >( state_dict: dict[str, torch.Tensor]save_directory: stris_main_process: boolweight_name: strsave_function: Callablesafe_serialization: boollora_adapter_metadata: dict | None = None )
Écrit le dictionnaire d'état des couches LoRA (éventuellement avec des métadonnées) sur le disque.