# Pipelines

Les pipelines offrent une méthode simple pour exécuter des modèles de diffusion de pointe en inférence en regroupant tous les composants nécessaires (plusieurs modèles entraînés indépendamment, planificateurs et processeurs) dans une unique classe de bout en bout. Les pipelines sont flexibles et peuvent être adaptés pour utiliser différents planificateurs ou même différents composants de modèle.

Tous les pipelines sont construits à partir de la classe de base [DiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.DiffusionPipeline), qui fournit les fonctionnalités de base pour charger, télécharger et enregistrer tous les composants. Les types de pipelines spécifiques (par exemple [StableDiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline)) chargés avec [from_pretrained()](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained) sont détectés automatiquement, et les composants du pipeline sont chargés puis transmis à la fonction `__init__` du pipeline.

> [!WARNING]
> Vous ne devriez pas utiliser la classe [DiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.DiffusionPipeline) pour l'entraînement. Les composants individuels (par exemple, [UNet2DModel](/docs/diffusers/v0.43.0/fr/api/models/unet2d#diffusers.UNet2DModel) et [UNet2DConditionModel](/docs/diffusers/v0.43.0/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) des pipelines de diffusion sont généralement entraînés séparément, nous vous suggérons donc de travailler directement avec eux.
>
> 
>
> Les pipelines ne proposent aucune fonctionnalité d'entraînement. Vous remarquerez que l'autograd de PyTorch est désactivé en décorant la méthode `__call__()` avec le décorateur [`torch.no_grad`](https://pytorch.org/docs/stable/generated/torch.no_grad.html), car les pipelines ne doivent pas être utilisés pour l'entraînement. Si vous êtes intéressé par l'entraînement, consultez plutôt les guides sur le [Training](../../training/overview) !

Utilisez **API > Pipelines** dans la barre latérale pour parcourir toutes les références de pipelines par modalité. Pour les flux de travail orientés tâches, commencez par le [Quickstart](../../quicktour) ou un guide tel que [text-to-image](../../using-diffusers/conditional_image_generation), [image-to-image](../../using-diffusers/img2img), [inpainting](../../using-diffusers/inpaint) ou [video generation](../../using-diffusers/text-img2vid).

## DiffusionPipeline[[diffusers.DiffusionPipeline]]

#### diffusers.DiffusionPipeline[[diffusers.DiffusionPipeline]]

```python
diffusers.DiffusionPipeline()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L198)

Classe de base pour tous les pipelines.

[DiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.DiffusionPipeline) stocke tous les composants (modèles, planificateurs et processeurs) des pipelines de diffusion et fournit des méthodes pour charger, télécharger et enregistrer les modèles. Il inclut également des méthodes pour :

- déplacer tous les modules PyTorch sur l'appareil de votre choix
- activer/désactiver la barre de progression pour l'itération de débruitage

Attributs de classe :

- **config_name** (`str`) -- Le nom du fichier de configuration qui stocke les noms de classe et de module de tous les composants du pipeline de diffusion.
- **_optional_components** (`List[str]`) -- Liste de tous les composants optionnels qui n'ont pas besoin d'être transmis au pipeline pour qu'il fonctionne (doit être redéfini par les sous-classes).

#### __appel__[[diffusers.DiffusionPipeline.__call__]]

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

Appeler self en tant que fonction.

#### device[[diffusers.DiffusionPipeline.device]]

```python
device()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L600)

**Retourne :** `torch.device`

Le dispositif torch sur lequel se trouve le pipeline. Lorsque les composants sont répartis sur plusieurs dispositifs (par exemple, les encodeurs de texte sur CPU tandis que le backbone de débruitage s'exécute sur un accélérateur), le dispositif de l'accélérateur est renvoyé.

#### vers[[diffusers.DiffusionPipeline.to]]

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L397)

**Paramètres :**

dtype (`torch.dtype`, *facultatif*) : Renvoie un pipeline avec le [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) spécifié

device (`torch.Device`, *facultatif*) : Retourne un pipeline avec le [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) spécifié

silence_dtype_warnings (`str`, *facultatif*, par défaut `False`) : Indique s'il faut omettre les avertissements si le `dtype` cible n'est pas compatible avec le `device` cible.

**Retourne :** [DiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.DiffusionPipeline)

Le pipeline converti en `dtype` et/ou `dtype` spécifié(s).

Effectue la conversion du dtype et/ou du device du Pipeline. Un torch.dtype et un torch.device sont inférés à partir des arguments de `self.to(*args, **kwargs).`

> [!TIP] > Si le pipeline possède déjà le torch.dtype et le torch.device corrects, il est renvoyé tel quel.
Sinon, > le pipeline renvoyé est une copie de self avec le torch.dtype et le torch.device souhaités.

Voici les façons d'appeler `to` :

- `to(dtype, silence_dtype_warnings=False) → DiffusionPipeline` pour renvoyer un pipeline avec le [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) spécifié
- `to(device, silence_dtype_warnings=False) → DiffusionPipeline` pour renvoyer un pipeline avec le [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) spécifié
- `to(device=None, dtype=None, silence_dtype_warnings=False) → DiffusionPipeline` pour renvoyer un pipeline avec le [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) et le [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) spécifiés

#### composants[[diffusers.DiffusionPipeline.components]]

```python
components()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1907)

La propriété `self.components` peut s’avérer utile pour exécuter différents pipelines avec les mêmes poids et configurations sans allouer de mémoire supplémentaire.

Returns (`dict`) : Un dictionnaire contenant tous les modules nécessaires pour initialiser le pipeline.

Exemples :

```py
>>> from diffusers import (
...     StableDiffusionPipeline,
...     StableDiffusionImg2ImgPipeline,
...     StableDiffusionInpaintPipeline,
... )

>>> text2img = StableDiffusionPipeline.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5")
>>> img2img = StableDiffusionImg2ImgPipeline(**text2img.components)
>>> inpaint = StableDiffusionInpaintPipeline(**text2img.components)
```

#### disable_attention_slicing[[diffusers.DiffusionPipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2067)

Désactive le calcul de l'attention par tranches. Si `enable_attention_slicing` a été appelé précédemment, l'attention est calculée en une seule étape.

#### disable_xformers_memory_efficient_attention[[diffusers.DiffusionPipeline.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2006)

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

#### télécharger[[diffusers.DiffusionPipeline.download]]

```python
download(pretrained_model_name, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1483)

**Paramètres :**

pretrained_model_name (`str` ou `os.PathLike`, *facultatif*) : Une chaîne de caractères, l'*identifiant du dépôt* (par exemple `CompVis/ldm-text2im-large-256`) d'un pipeline pré-entraîné hébergé sur le Hub.

custom_pipeline (`str`, *facultatif*) : Peut être :  - Une chaîne de caractères, l'*identifiant du dépôt* (par exemple `CompVis/ldm-text2im-large-256`) d'un pipeline pré-entraîné hébergé sur le Hub. Le dépôt doit contenir un fichier nommé `pipeline.py` qui définit le pipeline personnalisé.  - Une chaîne de caractères, le *nom du fichier* d'un pipeline communautaire hébergé sur GitHub sous [Community](https://github.com/huggingface/diffusers/tree/main/examples/community). Les noms de fichiers valides doivent correspondre au nom du fichier et non au script du pipeline (`clip_guided_stable_diffusion` au lieu de `clip_guided_stable_diffusion.py`). Les pipelines communautaires sont toujours chargés depuis la branche `main` actuelle de GitHub.  - Un chemin vers un *dossier* (`./my_pipeline_directory/`) contenant un pipeline personnalisé. Le dossier doit contenir un fichier nommé `pipeline.py` qui définit le pipeline personnalisé.  > [!WARNING] > 🧪 Il s'agit d'une fonctionnalité expérimentale qui peut évoluer à l'avenir.  Pour plus d'informations sur la manière de charger et de créer des pipelines personnalisés, consultez [Comment contribuer à un pipeline communautaire](https://huggingface.co/docs/diffusers/main/en/using-diffusers/contribute_pipeline).

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*, valeur 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.

custom_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 ou d'un identifiant de commit, similaire à `revision` lors du chargement d'un pipeline personnalisé depuis le Hub. Il peut s'agir d'une version de 🤗 Diffusers lors du chargement d'un pipeline personnalisé depuis GitHub, sinon il est par défaut `"main"` lors du chargement depuis le Hub.

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.

variant (`str`, *facultatif*) : Charge les poids depuis un nom de fichier de variante 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.

use_onnx (`bool`, *facultatif*, valeur par défaut `False`) : Si défini sur `True`, les poids ONNX seront toujours téléchargés s’ils sont présents. Si défini sur `False`, les poids ONNX ne seront jamais téléchargés. Par défaut, `use_onnx` prend la valeur de l’attribut de classe `_is_onnx`, qui est `False` pour les pipelines non-ONNX et `True` pour les pipelines ONNX. Les poids ONNX incluent à la fois les fichiers se terminant par `.onnx` et `.pb`.

trust_remote_code (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut autoriser les pipelines et composants personnalisés définis sur le Hub dans leurs propres fichiers. Cette option ne doit être définie sur `True` que pour les dépôts de confiance dont vous avez lu le code, car cela exécutera le code présent sur le Hub sur votre machine locale.

use_flashpack (`bool`, *facultatif*, valeur par défaut `False`) : Si défini sur `True`, les poids FlashPack seront toujours téléchargés s'ils sont présents. Si défini sur `False`, les poids FlashPack ne seront jamais téléchargés.

**Retourne :** `os.PathLike`

Chemin vers le pipeline téléchargé.

Télécharger et mettre en cache un pipeline de diffusion PyTorch à partir de poids de pipeline pré-entraînés.

> [!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

#### enable_attention_slicing[[diffusers.DiffusionPipeline.enable_attention_slicing]]

```python
enable_attention_slicing(slice_size: str | int = 'auto')
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2030)

**Paramètres :**

slice_size (`str` ou `int`, *facultatif*, par défaut `"auto"`) : lorsque la valeur est `"auto"`, l’entrée des têtes d’attention est divisée par deux, de sorte que l’attention est calculée en deux étapes. Si la valeur est `"max"`, la quantité maximale de mémoire est économisée en n’exécutant qu’une seule tranche à la fois. Si un nombre est fourni, autant de tranches sont utilisées que `attention_head_dim // slice_size`. Dans ce cas, `attention_head_dim` doit être un multiple de `slice_size`.

Active le calcul de l'attention par tranches. Lorsque cette option est activée, le module d'attention divise le tenseur d'entrée en tranches pour calculer l'attention en plusieurs étapes. Pour plus d'une tête d'attention, le calcul est effectué séquentiellement sur chaque tête. Cela est utile pour économiser de la mémoire au prix d'une légère diminution de la vitesse.

> [!WARNING] > ⚠️ N'activez pas le tranchage de l'attention si vous utilisez déjà `scaled_dot_product_attention` (SDPA)
de PyTorch > 2.0 ou xFormers. Ces calculs d'attention sont déjà très économes en mémoire, vous n'aurez donc pas besoin d'activer > cette fonction. Si vous activez le tranchage de l'attention avec SDPA ou xFormers, cela peut entraîner des ralentissements importants !

Exemples :

```py
>>> import torch
>>> from diffusers import StableDiffusionPipeline

>>> pipe = StableDiffusionPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5",
...     dtype=torch.float16,
...     use_safetensors=True,
... )

>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> pipe.enable_attention_slicing()
>>> image = pipe(prompt).images[0]
```

#### enable_group_offload[[diffusers.DiffusionPipeline.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, exclude_modules: str | list[str] | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1343)

**Paramètres :**

onload_device (`torch.device`) : L'appareil sur lequel le groupe de modules est chargé.

offload_device (`torch.device`, par défaut `torch.device("cpu")`) : L'appareil sur lequel le groupe de modules est déchargé. Il s'agit généralement du CPU. La valeur par défaut est le CPU.

offload_type (`str` ou `GroupOffloadingType`, par défaut "block_level") : Le type de déchargement à appliquer. Peut être "block_level" ou "leaf_level". La valeur par défaut est "block_level".

offload_to_disk_path (`str`, *facultatif*, valeur par défaut `None`) : Le chemin vers le répertoire où les paramètres seront déchargés. Définir cette option peut être utile dans des environnements à mémoire RAM limitée où un compromis raisonnable entre vitesse et mémoire est recherché.

num_blocks_per_group (`int`, *facultatif*) : Le nombre de blocs par groupe lors de l'utilisation de offload_type="block_level". Ce paramètre est requis lorsque offload_type="block_level" est utilisé.

non_blocking (`bool`, par défaut `False`) : Si True, le déchargement et le rechargement sont effectués avec un transfert de données non bloquant.

use_stream (`bool`, par défaut `False`) : Si True, le déchargement et le rechargement sont effectués de manière asynchrone à l'aide d'un flux CUDA. Cela peut être utile pour superposer le calcul et le transfert de données.

record_stream (`bool`, par défaut `False`) : lorsqu’il est activé avec `use_stream`, il marque le tenseur actuel comme ayant été utilisé par ce flux. C’est plus rapide au prix d’une utilisation légèrement plus importante de la mémoire. Consultez les [docs officielles de PyTorch](https://pytorch.org/docs/stable/generated/torch.Tensor.record_stream.html) pour plus de détails.

low_cpu_mem_usage (`bool`, par défaut `False`) : Si True, l'utilisation de la mémoire CPU est minimisée en épinglant les tenseurs à la volée au lieu de les pré-épingler. Cette option n'a d'importance que lors de l'utilisation du déchargement CPU en flux (c'est-à-dire `use_stream=True`). Cela peut être utile lorsque la mémoire CPU est un goulot d'étranglement, mais peut contrebalancer les avantages de l'utilisation de flux.

exclude_modules (`Union[str, List[str]]`, par défaut `None`) : Liste des modules à exclure du déchargement.

Applique le group offloading aux couches internes d'un module torch.nn.Module. Pour comprendre ce qu'est le group offloading et dans quels cas il est bénéfique, il faut d'abord fournir un contexte sur le fonctionnement des autres méthodes de offloading prises en charge.

En général, le déchargement est effectué à deux niveaux :
- Au niveau du module : dans Diffusers, cela peut être activé à l'aide de la méthode `ModelMixin::enable_model_cpu_offload()`. Il
fonctionne en déplaçant chaque composant d'un pipeline vers le CPU pour le stockage, puis en le chargeant sur l'appareil d'accélération lorsque cela est nécessaire pour le calcul. Cette méthode est plus efficace en termes de mémoire que de conserver tous les composants sur l'accélérateur, mais les exigences en mémoire restent tout de même assez élevées. Pour que cette méthode fonctionne, il faut une mémoire équivalente à la taille du modèle dans le type de données d'exécution + la taille des tenseurs d'activation intermédiaires les plus grands, afin de pouvoir terminer le passage avant.
- Niveau feuille : dans Diffusers, cela peut être activé à l'aide de la méthode `ModelMixin::enable_sequential_cpu_offload()`. Il
fonctionne en déplaçant les paramètres de plus bas niveau de la feuille du graphe de calcul vers le CPU pour le stockage, et en ne chargeant que les feuilles sur l’appareil d’accélération pour le calcul. Cela utilise la plus faible quantité de mémoire d’accélération, mais peut être plus lent en raison du nombre excessif de synchronisations d’appareils.

Le group offloading est un compromis entre les deux méthodes. Il fonctionne en déplaçant des groupes de couches internes (soit `torch.nn.ModuleList` ou `torch.nn.Sequential`). Cette méthode utilise moins de mémoire que le offloading au niveau des modules. Elle est également plus rapide que le offloading au niveau des feuilles/séquentiel, car le nombre de synchronisations de périphérique est réduit.

Une autre fonctionnalité prise en charge (pour les appareils CUDA prenant en charge les flux de transfert de données asynchrones) est la possibilité de superposer le transfert de données et le calcul afin de réduire le temps d’exécution global par rapport au déchargement séquentiel. Cela est activé grâce au préchargement des couches avec des flux, c’est-à-dire que la couche à exécuter ensuite commence à être chargée sur l’appareil accélérateur pendant que la couche actuelle est en cours d’exécution – cela augmente légèrement les exigences en mémoire. Notez que cette implémentation prend également en charge le déchargement au niveau des feuilles, mais peut être considérablement accélérée en utilisant des flux.

Exemple :
```python
>>> from diffusers import DiffusionPipeline
>>> import torch

>>> pipe = DiffusionPipeline.from_pretrained("Qwen/Qwen-Image", dtype=torch.bfloat16)

>>> pipe.enable_group_offload(
...     onload_device=torch.device("cuda"),
...     offload_device=torch.device("cpu"),
...     offload_type="leaf_level",
...     use_stream=True,
... )
>>> image = pipe("a beautiful sunset").images[0]
```

#### enable_model_cpu_offload[[diffusers.DiffusionPipeline.enable_model_cpu_offload]]

```python
enable_model_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1152)

**Paramètres :**

gpu_id (`int`, *facultatif*) : L'identifiant de l'accélérateur à utiliser pour l'inférence. S'il n'est pas spécifié, la valeur par défaut est 0.

device (`torch.Device` ou `str`, *facultatif*, par défaut None) : Le type d'appareil PyTorch de l'accélérateur à utiliser pour l'inférence. S'il n'est pas spécifié, l'accélérateur disponible sera détecté et utilisé automatiquement.

Décharge tous les modèles sur le CPU à l'aide de accelerate, réduisant ainsi l'utilisation de la mémoire avec un impact faible sur les performances. Par rapport à `enable_sequential_cpu_offload`, cette méthode déplace un modèle entier à la fois sur l'accélérateur lorsque sa méthode `forward` est appelée, et le modèle reste sur l'accélérateur jusqu'à l'exécution du modèle suivant. Les économies de mémoire sont moindres qu'avec `enable_sequential_cpu_offload`, mais les performances sont bien meilleures grâce à l'exécution itérative de `unet`.

#### enable_sequential_cpu_offload[[diffusers.DiffusionPipeline.enable_sequential_cpu_offload]]

```python
enable_sequential_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1273)

**Paramètres :**

gpu_id (`int`, *facultatif*) : L'identifiant de l'accélérateur à utiliser pour l'inférence. S'il n'est pas spécifié, la valeur par défaut est 0.

device (`torch.Device` ou `str`, *facultatif*, par défaut None) : Le type d'appareil PyTorch de l'accélérateur à utiliser pour l'inférence. S'il n'est pas spécifié, l'accélérateur disponible sera détecté et utilisé automatiquement.

Décharge tous les modèles sur le CPU à l’aide de 🤗 Accelerate, réduisant ainsi considérablement l’utilisation de la mémoire. Lors de l’appel, les state dicts de tous les composants `torch.nn.Module` (à l’exception de ceux dans `self._exclude_from_cpu_offload`) sont enregistrés sur le CPU, puis déplacés vers `torch.device('meta')` et chargés sur l’accélérateur uniquement lorsque la méthode `forward` de leur sous-module spécifique est appelée. La décharge s’effectue au niveau des sous-modules. Les économies de mémoire sont supérieures à celles de `enable_model_cpu_offload`, mais les performances sont inférieures.

#### enable_xformers_memory_efficient_attention[[diffusers.DiffusionPipeline.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/pipelines/pipeline_utils.py#L1975)

**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 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 DiffusionPipeline
>>> from xformers.ops import MemoryEfficientAttentionFlashAttentionOp

>>> pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1", dtype=torch.float16)
>>> pipe = pipe.to("cuda")
>>> pipe.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)
>>> # Workaround for not accepting attention shape using VAE for Flash Attention
>>> pipe.vae.enable_xformers_memory_efficient_attention(attention_op=None)
```

#### from_pipe[[diffusers.DiffusionPipeline.from_pipe]]

```python
from_pipe(pipeline, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2083)

**Paramètres :**

pipeline (`DiffusionPipeline`) : le pipeline à partir duquel créer un nouveau pipeline.

**Retourne :** `DiffusionPipeline`

Un nouveau pipeline avec les mêmes poids et configurations que `pipeline`.

Créez un nouveau pipeline à partir d'un pipeline donné. Cette méthode est utile pour créer un nouveau pipeline à partir des composants d'un pipeline existant sans allouer de mémoire supplémentaire.

Exemples :

```py
>>> from diffusers import StableDiffusionPipeline, StableDiffusionSAGPipeline

>>> pipe = StableDiffusionPipeline.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5")
>>> new_pipe = StableDiffusionSAGPipeline.from_pipe(pipe)
```

#### from_pretrained[[diffusers.DiffusionPipeline.from_pretrained]]

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L638)

**Paramètres :**

pretrained_model_name_or_path (`str` ou `os.PathLike`, *facultatif*) : Peut être : - Une chaîne de caractères, l'*identifiant du dépôt* (par exemple `CompVis/ldm-text2im-large-256`) d'un pipeline pré-entraîné hébergé sur le Hub. - Un chemin vers un *dossier* (par exemple `./my_pipeline_directory/`) contenant les poids du pipeline enregistrés à l'aide de [save_pretrained()](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.DiffusionPipeline.save_pretrained).

dtype (`torch.dtype` ou `dict[str, Union[str, torch.dtype]]`, *facultatif*) : Remplace le `torch.dtype` par défaut et charge le modèle avec un autre dtype. Pour charger des sous-modèles avec des dtypes différents, passez un `dict` (par exemple `{'transformer': torch.bfloat16, 'vae': torch.float16}`). Définissez le dtype par défaut pour les composants non spécifiés avec `default` (par exemple `{'transformer': torch.bfloat16, 'default': torch.float16}`). Si un composant n'est pas spécifié et qu'aucun défaut n'est défini, `torch.float32` est utilisé.

custom_pipeline (`str`, *facultatif*) : > [!WARNING] > 🧪 Il s'agit d'une fonctionnalité expérimentale qui peut évoluer à l'avenir.  Peut être :  - Une chaîne de caractères, l'*identifiant du dépôt* (par exemple `hf-internal-testing/diffusers-dummy-pipeline`) d'un pipeline personnalisé hébergé sur le Hub. Le dépôt doit contenir un fichier nommé pipeline.py qui définit le pipeline personnalisé. - Une chaîne de caractères, le *nom du fichier* d'un pipeline communautaire hébergé sur GitHub sous [Community](https://github.com/huggingface/diffusers/tree/main/examples/community). Les noms de fichiers valides doivent correspondre au nom du fichier et non au script du pipeline (`clip_guided_stable_diffusion` au lieu de `clip_guided_stable_diffusion.py`). Les pipelines communautaires sont toujours chargés depuis la branche main actuelle de GitHub. - Un chemin vers un répertoire (`./my_pipeline_directory/`) contenant un pipeline personnalisé. Le répertoire doit contenir un fichier nommé `pipeline.py` qui définit le pipeline personnalisé.  Pour plus d'informations sur la manière de charger et de créer des pipelines personnalisés, veuillez consulter [Charger et ajouter des pipelines personnalisés](https://huggingface.co/docs/diffusers/using-diffusers/custom_pipeline_overview)

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.

cache_dir (`Union[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é.

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*, valeur 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.

custom_revision (`str`, *facultatif*) : La version spécifique du modèle à utiliser. Il peut s'agir d'un nom de branche, d'un nom de tag ou d'un identifiant de commit, similaire à `revision` lors du chargement d'un pipeline personnalisé depuis le Hub. Par défaut, la dernière version stable de 🤗 Diffusers est utilisée.

mirror (`str`, *facultatif*) : Source miroir pour résoudre les problèmes d’accessibilité lors du téléchargement d’un modèle en Chine. Nous ne garantissons ni la réactivité ni la sécurité de la source ; veuillez consulter le site miroir pour plus d’informations.

device_map (`str`, *facultatif*) : Stratégie qui définit comment les différents composants d'un pipeline doivent être répartis sur les appareils disponibles. Actuellement, seul `device_map` "balanced" est pris en charge. Consultez [ce lien](https://huggingface.co/docs/diffusers/main/en/tutorials/inference_with_big_models#device-placement) pour en savoir plus.

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.

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.

use_onnx (`bool`, *facultatif*, valeur par défaut `None`) : Si défini sur `True`, les poids ONNX seront toujours téléchargés s’ils sont présents. Si défini sur `False`, les poids ONNX ne seront jamais téléchargés. Par défaut, `use_onnx` prend la valeur de l’attribut de classe `_is_onnx`, qui est `False` pour les pipelines non-ONNX et `True` pour les pipelines ONNX. Les poids ONNX incluent à la fois les fichiers se terminant par `.onnx` et `.pb`.

kwargs (reste du dictionnaire des arguments par mot-clé, *facultatif*) : peut être utilisé pour écraser les variables de chargement et de sauvegarde (les composants du pipeline de la classe de pipeline spécifique). Les composants écrasés sont transmis directement à la méthode `__init__` des pipelines. Voir l’exemple ci-dessous pour plus d’informations.

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

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.

Instanciez un pipeline de diffusion PyTorch à partir de poids de pipeline pré-entraînés.

Le pipeline est défini en mode évaluation (`model.eval()`) par défaut.

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

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

> [!TIP] > Pour utiliser des modèles privés ou [gated](https://huggingface.co/docs/hub/models-gated#gated-models), connectez-vous
avec `hf > auth login`.

Exemples :

```py
>>> from diffusers import DiffusionPipeline

>>> # Download pipeline from huggingface.co and cache.
>>> pipeline = DiffusionPipeline.from_pretrained("CompVis/ldm-text2im-large-256")

>>> # Download pipeline that requires an authorization token
>>> # For more information on access tokens, please refer to this section
>>> # of the documentation](https://huggingface.co/docs/hub/security-tokens)
>>> pipeline = DiffusionPipeline.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5")

>>> # Use a different scheduler
>>> from diffusers import LMSDiscreteScheduler

>>> scheduler = LMSDiscreteScheduler.from_config(pipeline.scheduler.config)
>>> pipeline.scheduler = scheduler
```

#### maybe_free_model_hooks[[diffusers.DiffusionPipeline.maybe_free_model_hooks]]

```python
maybe_free_model_hooks()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1250)

Méthode qui effectue les opérations suivantes :
- Décharge tous les composants.
- Supprime tous les hooks du modèle ajoutés lors de l'utilisation de `enable_model_cpu_offload`, puis les réapplique. Si le modèle n'a pas été déchargé, cette fonction est un no-op.
- Réinitialise les hooks à état des composants débruiteurs de diffusers s'ils ont été ajoutés avec `register_hook()`.

Assurez-vous d'ajouter cette fonction à la fin de la fonction `__call__` de votre pipeline afin qu'elle fonctionne correctement lors de l'application de `enable_model_cpu_offload`.

#### numpy_to_pil[[diffusers.DiffusionPipeline.numpy_to_pil]]

```python
numpy_to_pil(images)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1945)

Convertir une image NumPy ou un lot d'images en image PIL.

#### remove_all_hooks[[diffusers.DiffusionPipeline.remove_all_hooks]]

```python
remove_all_hooks()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1143)

Supprime tous les hooks ajoutés lors de l'utilisation de `enable_sequential_cpu_offload` ou `enable_model_cpu_offload`.

#### reset_device_map[[diffusers.DiffusionPipeline.reset_device_map]]

```python
reset_device_map()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1470)

Réinitialise les maps de dispositifs (le cas échéant) à None.

#### save_pretrained[[diffusers.DiffusionPipeline.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, safe_serialization: bool = True, variant: str | None = None, max_shard_size: int | str | None = None, push_to_hub: bool = False, use_flashpack: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L254)

**Paramètres :**

save_directory (`str` ou `os.PathLike`) : Répertoire dans lequel enregistrer un pipeline. Sera créé s'il n'existe pas.

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 `None`) : La taille maximale d'un point de contrôle avant qu'il ne soit fragmenté. Les fragments du point de contrôle auront 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 hub de modèles Hugging Face après l'avoir enregistré. Vous pouvez spécifier le dépôt auquel vous souhaitez pousser le modèle 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).

Enregistre toutes les variables du pipeline qui peuvent être sauvegardées dans un répertoire. Une variable de pipeline peut être sauvegardée et chargée si sa classe implémente à la fois une méthode de sauvegarde et une méthode de chargement. Le pipeline est facilement rechargé à l'aide de la méthode de classe [from_pretrained()](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained).

#### diffusers.StableDiffusionMixin.enable_freeu[[diffusers.StableDiffusionMixin.enable_freeu]]

```python
diffusers.StableDiffusionMixin.enable_freeu(s1: float, s2: float, b1: float, b2: float)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2267)

**Paramètres :**

s1 (`float`) : Facteur d'échelle pour l'étape 1 afin d'atténuer les contributions des caractéristiques de saut. Cela permet d'atténuer l'« effet de lissage excessif » dans le processus de débruitage amélioré.

s2 (`float`) : Facteur d'échelle pour l'étape 2 afin d'atténuer les contributions des caractéristiques de saut. Cela permet de réduire l'« effet de lissage excessif » dans le processus de débruitage amélioré.

b1 (`float`) : Facteur d'échelle pour l'étape 1 afin d'amplifier les contributions des fonctionnalités du backbone.

b2 (`float`) : Facteur d'échelle pour l'étape 2 afin d'amplifier les contributions des fonctionnalités du backbone.

Active le mécanisme FreeU tel que décrit dans https://huggingface.co/papers/2309.11497.

Les suffixes qui suivent les facteurs d'échelle représentent les étapes où ils sont appliqués.

Veuillez consulter le [dépôt officiel](https://github.com/ChenyangSi/FreeU) pour les combinaisons de valeurs connues pour fonctionner correctement avec différents pipelines tels que Stable Diffusion v1, v2 et Stable Diffusion XL.

#### diffusers.StableDiffusionMixin.disable_freeu[[diffusers.StableDiffusionMixin.disable_freeu]]

```python
diffusers.StableDiffusionMixin.disable_freeu()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2289)

Désactive le mécanisme FreeU s'il est activé.

## 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")
```

## Callbacks[[diffusers.callbacks.PipelineCallback]]

#### diffusers.callbacks.PipelineCallback[[diffusers.callbacks.PipelineCallback]]

```python
diffusers.callbacks.PipelineCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L7)

Classe de base pour tous les callbacks officiels utilisés dans un pipeline. Cette classe fournit une structure pour implémenter des callbacks personnalisés et garantit que tous les callbacks disposent d'une interface cohérente.

Veuillez implémenter les éléments suivants : `tensor_inputs` : cette méthode doit renvoyer une liste des entrées tensorielles spécifiques à votre rappel. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline. `callback_fn` : cette méthode définit la fonctionnalité principale de votre rappel.

#### diffusers.callbacks.SDCFGCutoffCallback[[diffusers.callbacks.SDCFGCutoffCallback]]

```python
diffusers.callbacks.SDCFGCutoffCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L69)

Fonction de rappel pour les pipelines Stable Diffusion. Après un certain nombre d'étapes (défini par `cutoff_step_ratio` ou `cutoff_step_index`), cette fonction de rappel désactive le CFG.

Note : ce callback modifie le pipeline en changeant l'attribut `_guidance_scale` en 0.0 après l'étape de coupure.

#### diffusers.callbacks.SDXLCFGCutoffCallback[[diffusers.callbacks.SDXLCFGCutoffCallback]]

```python
diffusers.callbacks.SDXLCFGCutoffCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L98)

Fonction de rappel pour les pipelines de base Stable Diffusion XL. Après un certain nombre d'étapes (défini par `cutoff_step_ratio` ou `cutoff_step_index`), cette fonction de rappel désactive le CFG.

Note : ce callback modifie le pipeline en changeant l'attribut `_guidance_scale` en 0.0 après l'étape de coupure.

#### diffusers.callbacks.SDXLControlnetCFGCutoffCallback[[diffusers.callbacks.SDXLControlnetCFGCutoffCallback]]

```python
diffusers.callbacks.SDXLControlnetCFGCutoffCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L140)

Fonction de rappel pour les pipelines Controlnet Stable Diffusion XL. Après un certain nombre d'étapes (défini par `cutoff_step_ratio` ou `cutoff_step_index`), cette fonction de rappel désactive le CFG.

Note : ce callback modifie le pipeline en changeant l'attribut `_guidance_scale` en 0.0 après l'étape de coupure.

#### diffusers.callbacks.IPAdapterScaleCutoffCallback[[diffusers.callbacks.IPAdapterScaleCutoffCallback]]

```python
diffusers.callbacks.IPAdapterScaleCutoffCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L188)

Fonction de rappel pour tout pipeline qui hérite de `IPAdapterMixin`. Après un certain nombre d'étapes (défini par `cutoff_step_ratio` ou `cutoff_step_index`), cette fonction de rappel définit l'échelle de l'IP Adapter à `0.0`.

Note : Ce callback modifie les processeurs d'attention de l'IP Adapter en définissant l'échelle à 0.0 après l'étape de coupure.

#### diffusers.callbacks.SD3CFGCutoffCallback[[diffusers.callbacks.SD3CFGCutoffCallback]]

```python
diffusers.callbacks.SD3CFGCutoffCallback(cutoff_step_ratio = 1.0, cutoff_step_index = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/callbacks.py#L212)

Fonction de rappel pour les pipelines Stable Diffusion 3. Après un certain nombre d'étapes (défini par `cutoff_step_ratio` ou `cutoff_step_index`), cette fonction de rappel désactive le CFG.

Note : ce callback modifie le pipeline en changeant l'attribut `_guidance_scale` en 0.0 après l'étape de coupure.