# Modèles

🤗 Diffusers fournit des modèles pré-entraînés pour des algorithmes populaires et des modules pour créer des systèmes de diffusion personnalisés. La fonction principale des modèles est de débruitiller un échantillon d'entrée, tel que modélisé par la distribution \\(p_{\theta}(x_{t-1}|x_{t})\\).

Tous les modèles sont construits à partir de la classe de base [ModelMixin](/docs/diffusers/v0.43.0/fr/api/models/overview#diffusers.ModelMixin), qui est un [`torch.nn.Module`](https://pytorch.org/docs/stable/generated/torch.nn.Module.html) fournissant des fonctionnalités de base pour l'enregistrement et le chargement des modèles, en local et depuis le Hugging Face Hub.

## ModelMixin[[diffusers.ModelMixin]]

#### diffusers.ModelMixin[[diffusers.ModelMixin]]

```python
diffusers.ModelMixin()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L240)

Classe de base pour tous les modèles.

[ModelMixin](/docs/diffusers/v0.43.0/fr/api/models/overview#diffusers.ModelMixin) gère le stockage de la configuration du modèle et fournit des méthodes pour charger, télécharger et enregistrer les modèles.

- **config_name** (`str`) -- Nom du fichier à enregistrer lors de l'appel à [save_pretrained()](/docs/diffusers/v0.43.0/fr/api/models/overview#diffusers.ModelMixin.save_pretrained).

#### compile_repeated_blocks[[diffusers.ModelMixin.compile_repeated_blocks]]

```python
compile_repeated_blocks(*args, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L1646)

Compile *uniquement* les sous-modules fréquemment répétés d'un modèle (par exemple, les couches Transformer) au lieu de compiler l'ensemble du modèle. Cette technique, souvent appelée **compilation régionale** (voir la recette PyTorch https://docs.pytorch.org/tutorials/recipes/regional_compilation.html), peut réduire considérablement le temps de compilation de bout en bout, tout en conservant les gains de vitesse d'exécution attendus d'un `torch.compile` complet.

L'ensemble des sous-modules à compiler est déterminé par la présence de l'attribut **`_repeated_blocks`** dans la définition du modèle. Définissez cet attribut sur votre sous-classe de modèle sous forme d'une liste/tuple de noms de classes (chaînes de caractères). Tout module dont le nom de classe correspond sera compilé.

Une fois identifiés, chaque sous-module correspondant est compilé en appelant `submodule.compile(*args, **kwargs)`. Tout argument positionnel ou par mot-clé fourni à `compile_repeated_blocks` est transmis tel quel à `torch.compile`.

#### cuda[[diffusers.ModelMixin.cuda]]

```python
cuda(*args, **kwargs)
```

Valeur factice pour un chemin pointé (par exemple `torch.float32`) : les chaînes d’accès aux attributs et les appels se comportent comme des décorateurs de pass-through, `repr` est le chemin pointé, et son utilisation comme classe de base substitue une base de `type` ordinaire (PEP 560 `__mro_entries__`), de sorte que les vraies sous-classes conservent un métaclasse normal et que `inspect.signature` lit leur `__init__` réel plutôt que celui d’une valeur factice.

#### dequantize[[diffusers.ModelMixin.dequantize]]

```python
dequantize()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L890)

Déquantiser éventuellement le modèle s'il a été quantisé par une méthode de quantisation prenant en charge la déquantisation.

#### disable_gradient_checkpointing[[diffusers.ModelMixin.disable_gradient_checkpointing]]

```python
disable_gradient_checkpointing()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L323)

Désactive le checkpointing des gradients pour le modèle actuel (également appelé *activation checkpointing* ou *checkpoint activations* dans d'autres frameworks).

#### disable_npu_flash_attention[[diffusers.ModelMixin.disable_npu_flash_attention]]

```python
disable_npu_flash_attention()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L354)

désactiver l'attention flash NPU depuis torch_npu

#### disable_xformers_memory_efficient_attention[[diffusers.ModelMixin.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L437)

Désactiver l'attention efficace en mémoire de [xFormers](https://facebookresearch.github.io/xformers/).

#### disable_xla_flash_attention[[diffusers.ModelMixin.disable_xla_flash_attention]]

```python
disable_xla_flash_attention()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L384)

Désactiver le noyau pallals de flash attention pour torch_xla.

#### enable_gradient_checkpointing[[diffusers.ModelMixin.enable_gradient_checkpointing]]

```python
enable_gradient_checkpointing(gradient_checkpointing_func: typing.Optional[typing.Callable] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L294)

**Paramètres :**

gradient_checkpointing_func (`Callable`, *facultatif*) : La fonction à utiliser pour le checkpointing des gradients. Si `None`, la fonction de checkpointing par défaut de PyTorch est utilisée (`torch.utils.checkpoint.checkpoint`).

Active le checkpointing des gradients pour le modèle actuel (également appelé *activation checkpointing* ou *checkpoint activations* dans d'autres frameworks).

#### enable_group_offload[[diffusers.ModelMixin.enable_group_offload]]

```python
enable_group_offload(onload_device: device, offload_device: device = torch.device(), offload_type: str = 'block_level', num_blocks_per_group: int | None = None, non_blocking: bool = False, use_stream: bool = False, record_stream: bool = False, low_cpu_mem_usage = False, offload_to_disk_path: str | None = None, block_modules: str | None = None, exclude_kwargs: str | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L528)

Active le déchargement par groupe pour le modèle actuel.

Voir [apply_group_offloading()](/docs/diffusers/v0.43.0/fr/api/utilities#diffusers.hooks.apply_group_offloading) pour plus d’informations.

Exemple :

```python
>>> from diffusers import CogVideoXTransformer3DModel

>>> transformer = CogVideoXTransformer3DModel.from_pretrained(
...     "THUDM/CogVideoX-5b", subfolder="transformer", torch_dtype=torch.bfloat16
... )

>>> transformer.enable_group_offload(
...     onload_device=torch.device("cuda"),
...     offload_device=torch.device("cpu"),
...     offload_type="leaf_level",
...     use_stream=True,
... )
```

#### enable_layerwise_casting[[diffusers.ModelMixin.enable_layerwise_casting]]

```python
enable_layerwise_casting(storage_dtype: dtype = torch.float8_e4m3fn, compute_dtype: typing.Optional[torch.dtype] = None, skip_modules_pattern: tuple[str, ...] | None = None, skip_modules_classes: tuple[typing.Type[torch.nn.Module], ...] | None = None, non_blocking: bool = False)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L443)

**Paramètres :**

storage_dtype (`torch.dtype`) : Le dtype auquel le modèle doit être converti pour le stockage.

compute_dtype (`torch.dtype`) : Le dtype auquel les poids du modèle doivent être convertis lors du passage avant.

skip_modules_pattern (`tuple[str, ...]`, *facultatif*) : Une liste de motifs pour correspondre aux noms des modules à ignorer lors du processus de conversion par couche. Si défini sur `None`, des motifs d'ignorance par défaut sont utilisés pour ignorer certaines couches internes des modules et les couches PEFT.

skip_modules_classes (`tuple[Type[torch.nn.Module], ...]`, *facultatif*) : Une liste de classes de modules à ignorer lors du processus de conversion par couche.

non_blocking (`bool`, *facultatif*, par défaut `False`) : Si `True`, les opérations de conversion de poids sont non bloquantes.

Active le castage par couche pour le modèle actuel.

Le cast par couche est une technique qui convertit les poids du modèle vers un dtype de précision inférieure pour le stockage, mais les remonte en précision (upcast) à la volée vers un dtype de précision supérieure pour le calcul. Ce processus peut réduire considérablement l’empreinte mémoire liée aux poids du modèle, mais peut entraîner une certaine dégradation de la qualité des sorties. La plupart des dégradations sont négligeables, résultant principalement du cast des poids dans les couches de normalisation et de modulation.

Par défaut, la plupart des modèles de diffusers définissent l'attribut `_skip_layerwise_casting_patterns` afin d'ignorer les couches d'incorporation de patch, d'incorporation positionnelle et de normalisation. Cela est dû au fait que ces couches sont très probablement sensibles à la précision en termes de qualité. Si vous souhaitez modifier ce comportement, vous pouvez définir l'attribut `_skip_layerwise_casting_patterns` sur `None`, ou appeler [apply_layerwise_casting()](/docs/diffusers/v0.43.0/fr/api/utilities#diffusers.hooks.apply_layerwise_casting) avec des arguments personnalisés.

Exemple :

En utilisant [enable_layerwise_casting()](/docs/diffusers/v0.43.0/fr/api/models/overview#diffusers.ModelMixin.enable_layerwise_casting) :

```python
>>> from diffusers import CogVideoXTransformer3DModel

>>> transformer = CogVideoXTransformer3DModel.from_pretrained(
...     "THUDM/CogVideoX-5b", subfolder="transformer", torch_dtype=torch.bfloat16
... )

>>> # Enable layerwise casting via the model, which ignores certain modules by default
>>> transformer.enable_layerwise_casting(storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16)
```

#### enable_npu_flash_attention[[diffusers.ModelMixin.enable_npu_flash_attention]]

```python
enable_npu_flash_attention()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L347)

Activer l'attention flash NPU depuis torch_npu

#### enable_xformers_memory_efficient_attention[[diffusers.ModelMixin.enable_xformers_memory_efficient_attention]]

```python
enable_xformers_memory_efficient_attention(attention_op: typing.Optional[typing.Callable] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L405)

**Paramètres :**

attention_op (`Callable`, *facultatif*) : Remplace l'opérateur par défaut `None` pour être utilisé comme argument `op` de la fonction [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) de xFormers.

Activer l'attention efficace en mémoire à partir de [xFormers](https://facebookresearch.github.io/xformers/).

Lorsque cette option est activée, vous devriez observer une réduction de l’utilisation de la mémoire GPU et une accélération potentielle lors de l’inférence. L’accélération lors de l’entraînement n’est pas garantie.

> [!WARNING] > ⚠️ Lorsque l'attention efficace en mémoire et l'attention par tranches sont toutes deux activées, l'attention efficace
attention prend > précédent.

Exemples :

```py
>>> import torch
>>> from diffusers import UNet2DConditionModel
>>> from xformers.ops import MemoryEfficientAttentionFlashAttentionOp

>>> model = UNet2DConditionModel.from_pretrained(
...     "stabilityai/stable-diffusion-2-1", subfolder="unet", torch_dtype=torch.float16
... )
>>> model = model.to("cuda")
>>> model.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)
```

#### enable_xla_flash_attention[[diffusers.ModelMixin.enable_xla_flash_attention]]

```python
enable_xla_flash_attention(partition_spec: typing.Optional[typing.Callable] = None, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L378)

Activer le noyau pallals de flash attention pour torch_xla.

#### from_pretrained[[diffusers.ModelMixin.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike | None, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L902)

**Paramètres :**

pretrained_model_name_or_path (`str` ou `os.PathLike`, *facultatif*) : 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 [save_pretrained()](/docs/diffusers/v0.43.0/fr/api/models/overview#diffusers.ModelMixin.save_pretrained).

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é.

dtype (`torch.dtype`, *facultatif*) : Remplace le `torch.dtype` par défaut et charge le modèle avec un autre dtype.

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.

output_loading_info (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut également retourner un dictionnaire contenant les clés manquantes, les clés inattendues et les messages d'erreur.

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.

mirror (`str`, *facultatif*) : Source miroir pour résoudre les problèmes d'accessibilité si vous téléchargez un modèle en Chine. Nous ne garantissons ni la réactivité ni la sécurité de la source, et vous devez consulter le site miroir pour plus d'informations.

device_map (`int | str | torch.device` ou `dict[str, int | str | torch.device]`, *facultatif*) : Une carte qui spécifie l'emplacement de chaque sous-module. Il n'est pas nécessaire de la définir pour chaque nom de paramètre/buffer ; dès qu'un nom de module est inclus, tous ses sous-modules seront envoyés sur le même appareil. La valeur par défaut est `None`, ce qui signifie que le modèle sera chargé sur le CPU. Exemples : ```py >>> from diffusers import AutoModel >>> import torch  >>> # This works. >>> model = AutoModel.from_pretrained( ...     "stabilityai/stable-diffusion-xl-base-1.0", subfolder="unet", device_map="cuda" ... ) >>> # This also works (integer accelerator device ID). >>> model = AutoModel.from_pretrained( ...     "stabilityai/stable-diffusion-xl-base-1.0", subfolder="unet", device_map=0 ... ) >>> # Specifying a supported offloading strategy like "auto" also works. >>> model = AutoModel.from_pretrained( ...     "stabilityai/stable-diffusion-xl-base-1.0", subfolder="unet", device_map="auto" ... ) >>> # Specifying a dictionary as `device_map` also works. >>> model = AutoModel.from_pretrained( ...     "stabilityai/stable-diffusion-xl-base-1.0", ...     subfolder="unet", ...     device_map={"": torch.device("cuda")}, ... ) ``` Définissez `device_map="auto"` pour que 🤗 Accelerate calcule automatiquement le `device_map` le plus optimisé. Pour plus d'informations sur chaque option, consultez [concevoir une carte d'appareils](https://huggingface.co/docs/accelerate/en/concept_guides/big_model_inference#the-devicemap). Vous pouvez également vous référer à la [documentation spécifique à Diffusers](https://huggingface.co/docs/diffusers/main/en/optimization/device_map) pour des exemples plus concrets.

max_memory (`Dict`, *facultatif*) : Un identifiant de dictionnaire de périphérique pour la mémoire maximale. Par défaut, la valeur est la mémoire maximale disponible pour chaque GPU et la RAM CPU disponible si non définie.

offload_folder (`str` ou `os.PathLike`, *facultatif*) : Le chemin pour décharger les poids si `device_map` contient la valeur `"disk"`.

offload_state_dict (`bool`, *facultatif*) : Si `True`, décharge temporairement le dictionnaire d'état CPU sur le disque dur pour éviter d'épuiser la RAM CPU si le poids du dictionnaire d'état CPU + le plus grand fragment du point de contrôle ne tient pas. La valeur par défaut est `True` lorsqu'il y a une décharge sur disque.

low_cpu_mem_usage (`bool`, *facultatif*, par défaut `True` si la version de torch est >= 1.9.0, sinon `False`) : Accélère le chargement du modèle en ne chargeant que les poids préentraînés et sans initialiser les poids. Cela tente également de ne pas utiliser plus de 1 fois la taille du modèle en mémoire CPU (y compris la mémoire de pointe) lors du chargement du modèle. Pris en charge uniquement pour PyTorch >= 1.9.0. Si vous utilisez une version plus ancienne de PyTorch, définir cet argument sur `True` déclenchera une erreur.

variant (`str`, *facultatif*) : Charge les poids depuis un nom de fichier `variant` spécifié, tel que `"fp16"` ou `"ema"`.

use_safetensors (`bool`, *facultatif*, valeur par défaut `None`) : Si défini sur `None`, les poids `safetensors` sont téléchargés s'ils sont disponibles **et** si la bibliothèque `safetensors` est installée. Si défini sur `True`, le modèle est chargé de force à partir des poids `safetensors`. Si défini sur `False`, les poids `safetensors` ne sont pas chargés.

disable_mmap ('bool', *facultatif*, valeur par défaut 'False') : Indique s'il faut désactiver mmap lors du chargement d'un modèle Safetensors. Cette option peut offrir de meilleures performances lorsque le modèle est situé sur un montage réseau ou un disque dur, qui peuvent ne pas gérer correctement les accès aléatoires (seek) de mmap.

use_flashpack (`bool`, *facultatif*, valeur par défaut `False`) : Si défini sur `True`, le modèle est chargé à partir des poids `flashpack`.

flashpack_kwargs(`dict[str, Any]`, *facultatif*, par défaut `{}`) : Kwargs transmis à [`flashpack.deserialization.assign_from_file`](https://github.com/fal-ai/flashpack/blob/f1aa91c5cd9532a3dbf5bcc707ab9b01c274b76c/src/flashpack/deserialization.py#L408-L422)

Instanciez un modèle PyTorch pré-entraîné à partir d'une configuration de modèle pré-entraîné.

Le modèle est configuré en mode évaluation - `model.eval()` - par défaut, et les modules dropout sont désactivés. Pour entraîner le modèle, le remettre en mode d'entraînement avec `model.train()`.

> [!TIP] > Pour utiliser des modèles privés ou [gated models](https://huggingface.co/docs/hub/models-gated#gated-models), connectez-vous
avec `hf > auth login`. Vous pouvez également activer le mode spécial > ["offline-mode"](https://huggingface.co/diffusers/installation.html#offline-mode) pour utiliser cette méthode dans un environnement > protégé par un pare-feu.

Exemple :

```py
from diffusers import UNet2DConditionModel

unet = UNet2DConditionModel.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5", subfolder="unet")
```

Si vous obtenez le message d’erreur ci-dessous, vous devez affiner les poids pour votre tâche en aval :

```bash
Some weights of UNet2DConditionModel were not initialized from the model checkpoint at stable-diffusion-v1-5/stable-diffusion-v1-5 and are newly initialized because the shapes did not match:
- conv_in.weight: found shape torch.Size([320, 4, 3, 3]) in the checkpoint and torch.Size([320, 9, 3, 3]) in the model instantiated
You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
```

#### get_memory_footprint[[diffusers.ModelMixin.get_memory_footprint]]

```python
get_memory_footprint(return_buffers = True)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L2154)

**Paramètres :**

return_buffers (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut inclure la taille des tenseurs de tampon dans le calcul de l'empreinte mémoire. Les tampons sont des tenseurs qui ne nécessitent pas de gradients et qui ne sont pas enregistrés en tant que paramètres. Par exemple, la moyenne et l'écart-type dans les couches de normalisation par lot. Voir : https://discuss.pytorch.org/t/what-pytorch-means-by-buffers/120266/2

Obtenir l’empreinte mémoire d’un modèle. Cette opération renvoie l’empreinte mémoire du modèle actuel en octets. Elle est utile pour mesurer l’empreinte mémoire du modèle actuel et concevoir des tests. Solution inspirée des discussions PyTorch : https://discuss.pytorch.org/t/gpu-memory-that-model-uses/56822/2

#### num_parameters[[diffusers.ModelMixin.num_parameters]]

```python
num_parameters(only_trainable: bool = False, exclude_embeddings: bool = False)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L2090)

**Paramètres :**

only_trainable (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut renvoyer uniquement le nombre de paramètres entraînables.

exclude_embeddings (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut retourner uniquement le nombre de paramètres non d'embedding.

**Retourne :** `int`

Le nombre de paramètres.

Obtenir le nombre de paramètres (entraînables ou non-embedding) du module.

Exemple :

```py
from diffusers import UNet2DConditionModel

model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
unet = UNet2DConditionModel.from_pretrained(model_id, subfolder="unet")
unet.num_parameters(only_trainable=True)
859520964
```

#### reset_attention_backend[[diffusers.ModelMixin.reset_attention_backend]]

```python
reset_attention_backend()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L663)

Réinitialise le backend d'attention pour le modèle. Les appels suivants à `forward` utiliseront la valeur par défaut de l'environnement, si elle est définie, ou l'attention par produit scalaire pondéré natif de torch.

#### save_pretrained[[diffusers.ModelMixin.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, is_main_process: bool = True, save_function: typing.Optional[typing.Callable] = None, safe_serialization: bool = True, variant: str | None = None, max_shard_size: int | str = '10GB', push_to_hub: bool = False, use_flashpack: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L682)

**Paramètres :**

save_directory (`str` ou `os.PathLike`) : Répertoire dans lequel enregistrer le modèle et son fichier de configuration. 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 de manière traditionnelle PyTorch avec `pickle`.

variant (`str`, *facultatif*) : Si spécifié, les poids sont enregistrés au format `pytorch_model.<variant>.bin`.

max_shard_size (`int` ou `str`, par défaut `"10GB"`) : La taille maximale d'un point de contrôle avant qu'il ne soit fragmenté. Les fragments du point de contrôle auront alors chacun une taille inférieure à cette limite. S'il est exprimé sous forme de chaîne de caractères, il doit être composé de chiffres suivis d'une unité (comme `"5GB"`). S'il est exprimé sous forme d'entier, l'unité est l'octet. Notez que cette limite sera réduite après une certaine période (à partir d'octobre 2024) pour permettre aux utilisateurs de passer à la dernière version de `diffusers`. Cela vise à établir une taille par défaut commune pour cet argument entre les différentes bibliothèques de l'écosystème Hugging Face (`transformers` et `accelerate`, par exemple).

push_to_hub (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut ou non pousser votre modèle sur le Hugging Face Hub après l'avoir enregistré. Vous pouvez spécifier le dépôt auquel vous souhaitez pousser avec `repo_id` (par défaut, il s'agit du nom de `save_directory` dans votre espace de noms).

kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires passés à la méthode [push_to_hub()](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.utils.PushToHubMixin.push_to_hub).

Enregistrer un modèle et son fichier de configuration dans un répertoire afin qu’il puisse être rechargé à l’aide de la méthode de classe [from_pretrained()](/docs/diffusers/v0.43.0/fr/api/models/overview#diffusers.ModelMixin.from_pretrained).

#### set_attention_backend[[diffusers.ModelMixin.set_attention_backend]]

```python
set_attention_backend(backend: str)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L604)

**Paramètres :**

backend (`str`) : Le nom du backend à définir. Doit être l'un des backends disponibles définis dans `AttentionBackendName`. Les backends disponibles peuvent être trouvés dans `diffusers.attention_dispatch.AttentionBackendName`. Par défaut, l'attention produit scalaire normalisé native de torch est utilisée comme backend.

Définissez le backend d'attention pour le modèle.

#### set_use_npu_flash_attention[[diffusers.ModelMixin.set_use_npu_flash_attention]]

```python
set_use_npu_flash_attention(valid: bool)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L331)

Définissez l’interrupteur pour l’attention flash du npu.

#### vers[[diffusers.ModelMixin.to]]

```python
to(*args, **kwargs)
```

Valeur factice pour un chemin pointé (par exemple `torch.float32`) : les chaînes d’accès aux attributs et les appels se comportent comme des décorateurs de pass-through, `repr` est le chemin pointé, et son utilisation comme classe de base substitue une base de `type` ordinaire (PEP 560 `__mro_entries__`), de sorte que les vraies sous-classes conservent un métaclasse normal et que `inspect.signature` lit leur `__init__` réel plutôt que celui d’une valeur factice.

## PushToHubMixin[[diffusers.utils.PushToHubMixin]]

#### diffusers.utils.PushToHubMixin[[diffusers.utils.PushToHubMixin]]

```python
diffusers.utils.PushToHubMixin()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/utils/hub_utils.py#L491)

Un Mixin pour pousser un modèle, un planificateur ou un pipeline vers le Hugging Face Hub.

#### push_to_hub[[diffusers.utils.PushToHubMixin.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, private: bool | None = None, token: str | None = None, create_pr: bool = False, safe_serialization: bool = True, variant: str | None = None, subfolder: str | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/utils/hub_utils.py#L526)

**Paramètres :**

repo_id (`str`) : Le nom du dépôt vers lequel vous souhaitez pousser vos fichiers de modèle, de planificateur ou de pipeline. Il doit contenir le nom de votre organisation lors d'une poussée vers une organisation. `repo_id` peut également être un chemin vers un répertoire local.

commit_message (`str`, *facultatif*) : Message à commiter lors de la poussée. Par défaut, `"Upload {object}"`.

private (`bool`, *facultatif*) : Indique si le dépôt doit être privé. Si la valeur est `None` (par défaut), le dépôt sera public, sauf si le défaut de l’organisation est privé. Cette valeur est ignorée si le dépôt existe déjà.

token (`str`, *facultatif*) : Le jeton à utiliser comme autorisation bearer HTTP pour les fichiers distants. Le jeton généré lors de l'exécution de `hf auth login` (stocké dans `~/.huggingface`).

create_pr (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct.

safe_serialization (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut convertir les poids du modèle au format `safetensors`.

variant (`str`, *facultatif*) : Si spécifié, les poids sont enregistrés au format `pytorch_model.<variant>.bin`.

Téléchargez des fichiers de modèle, de planificateur ou de pipeline sur le 🤗 Hugging Face Hub.

Exemples :

```python
from diffusers import UNet2DConditionModel

unet = UNet2DConditionModel.from_pretrained("stabilityai/stable-diffusion-2", subfolder="unet")

# Push the `unet` to your namespace with the name "my-finetuned-unet".
unet.push_to_hub("my-finetuned-unet")

# Push the `unet` to an organization with the name "my-finetuned-unet".
unet.push_to_hub("your-org/my-finetuned-unet")
```