Buckets:
| # UNet | |
| Certaines méthodes d’entraînement – comme LoRA et Custom Diffusion – ciblent généralement les couches d’attention du UNet, mais ces méthodes peuvent également cibler d’autres couches non attentionnelles. Au lieu d’entraîner tous les paramètres d’un modèle, seul un sous-ensemble de paramètres est entraîné, ce qui est plus rapide et plus efficace. Cette classe est utile si vous chargez *uniquement* des poids dans un UNet. Si vous devez charger des poids dans l’encodeur de texte ou dans un encodeur de texte et un UNet, essayez plutôt d’utiliser la fonction [load_lora_weights()](/docs/diffusers/main/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights). | |
| La classe `UNet2DConditionLoadersMixin` fournit des fonctions pour charger et enregistrer les poids, fusionner et défusionner les LoRA, désactiver et activer les LoRA, ainsi que pour définir et supprimer des adaptateurs. | |
| > [!TIP] | |
| > Pour en savoir plus sur la manière de charger les poids LoRA, consultez le guide [LoRA](../../tutorials/using_peft_for_inference). | |
| ## UNet2DConditionLoadersMixin[[diffusers.loaders.UNet2DConditionLoadersMixin]] | |
| #### diffusers.loaders.UNet2DConditionLoadersMixin[[diffusers.loaders.UNet2DConditionLoadersMixin]] | |
| ```python | |
| diffusers.loaders.UNet2DConditionLoadersMixin() | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/unet.py#L53) | |
| Charger les couches LoRA dans un `UNet2DCondtionModel`. | |
| #### load_attn_procs[[diffusers.loaders.UNet2DConditionLoadersMixin.load_attn_procs]] | |
| ```python | |
| load_attn_procs(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], **kwargs) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/unet.py#L61) | |
| **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 répertoire (par exemple `./my_model_directory`) contenant les poids du modèle enregistrés avec [ModelMixin.save_pretrained()](/docs/diffusers/main/fr/api/models/overview#diffusers.ModelMixin.save_pretrained). - Un [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict). | |
| 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é. | |
| Chargez les couches de processeur d'attention Custom Diffusion préentraînées dans [UNet2DConditionModel](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel). Les couches de processeur d'attention doivent être définies dans [`attention_processor.py`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py) et être une classe `torch.nn.Module`. Pour charger des couches LoRA, utilisez plutôt [load_lora_adapter()](/docs/diffusers/main/fr/api/loaders/peft#diffusers.loaders.PeftAdapterMixin.load_lora_adapter). | |
| Exemple : | |
| ```py | |
| import torch | |
| from diffusers import DiffusionPipeline | |
| pipeline = DiffusionPipeline.from_pretrained( | |
| "CompVis/stable-diffusion-v1-4", | |
| torch_dtype=torch.float16, | |
| ).to("cuda") | |
| pipeline.unet.load_attn_procs("path-to-save-model", weight_name="pytorch_custom_diffusion_weights.bin") | |
| ``` | |
| #### save_attn_procs[[diffusers.loaders.UNet2DConditionLoadersMixin.save_attn_procs]] | |
| ```python | |
| save_attn_procs(save_directory: str | os.PathLike, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, **kwargs) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/unet.py#L252) | |
| **Paramètres :** | |
| save_directory (`str` ou `os.PathLike`) : Répertoire dans lequel enregistrer un processeur d'attention (sera créé s'il n'existe pas). | |
| 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 avec `pickle`. | |
| Enregistrez les couches de processeur d’attention de Custom Diffusion dans un répertoire afin qu’elles puissent être rechargées avec la méthode [load_attn_procs()](/docs/diffusers/main/fr/api/loaders/unet#diffusers.loaders.UNet2DConditionLoadersMixin.load_attn_procs). Pour enregistrer les couches LoRA, utilisez plutôt [save_lora_adapter()](/docs/diffusers/main/fr/api/loaders/peft#diffusers.loaders.PeftAdapterMixin.save_lora_adapter). | |
| Exemple : | |
| ```py | |
| import torch | |
| from diffusers import DiffusionPipeline | |
| pipeline = DiffusionPipeline.from_pretrained( | |
| "CompVis/stable-diffusion-v1-4", | |
| torch_dtype=torch.float16, | |
| ).to("cuda") | |
| pipeline.unet.load_attn_procs("path-to-save-model", weight_name="pytorch_custom_diffusion_weights.bin") | |
| pipeline.unet.save_attn_procs("path-to-save-model", weight_name="pytorch_custom_diffusion_weights.bin") | |
| ``` | |
Xet Storage Details
- Size:
- 7.16 kB
- Xet hash:
- 8f70c9b8bef4fea2b859d642535ccde06a6d45c1d326182b667792da920a7e0b
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.