Hugging Face's logo

Diffusers documentation

Pipelines

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.42.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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, 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) chargés avec from_pretrained() sont détectés automatiquement, et les composants du pipeline sont chargés puis transmis à la fonction __init__ du pipeline.

Vous ne devriez pas utiliser la classe DiffusionPipeline pour l’entraînement. Les composants individuels (par exemple, UNet2DModel et 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, car les pipelines ne doivent pas être utilisés pour l’entraînement. Si vous souhaitez vous initier à l’entraînement, consultez plutôt les guides Training !

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 ou un guide tel que text-to-image, image-to-image, inpainting ou video generation.

DiffusionPipeline

classe diffusers.DiffusionPipeline

< >

( )

Classe de base pour tous les pipelines.

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 à être transmis au pipeline pour qu’il fonctionne (doit être redéfini par les sous-classes).

__call__

( *args**kwargs )

Appeler self en tant que fonction.

device

< >

( ) → torch.device

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

à

< >

( *args**kwargs ) → DiffusionPipeline

Paramètres

  • dtype (torch.dtype, facultatif) — Retourne un pipeline avec le dtype spécifié
  • device (torch.Device, facultatif) — Retourne un pipeline avec le 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

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

> 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 spécifié
  • to(device, silence_dtype_warnings=False) → DiffusionPipeline pour renvoyer un pipeline avec le device spécifié
  • to(device=None, dtype=None, silence_dtype_warnings=False) → DiffusionPipeline pour renvoyer un pipeline avec le device et le dtype spécifiés

composants

< >

( )

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.

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

Exemples :

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

< >

( )

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

< >

( )

Désactiver l'attention efficace en mémoire de xFormers.

télécharger

< >

( pretrained_model_name**kwargs ) → os.PathLike

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 soit :

    • 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 de fichier d’un pipeline communautaire hébergé sur GitHub sous Community. Les noms de fichiers valides doivent correspondre au nom du fichier et non au script du pipeline (clip_guided_stable_diffusion plutôt que 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é.

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

  • 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 en local. 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, de manière 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é 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.
  • 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 manière forcée à 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 elle 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.

> Pour utiliser des modèles privés ou restreints, connectez-vous avec `hf > auth login

enable_attention_slicing

< >

( slice_size: str | int = 'auto' )

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, le nombre de tranches utilisé est 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.

> ⚠️ N’activez pas le découpage de l’attention si vous utilisez déjà scaled_dot_product_attention (SDPA) depuis PyTorch > 2.0 ou xFormers. Ces calculs d’attention sont déjà très économes en mémoire, vous n’avez donc pas besoin d’activer > cette fonction. Si vous activez le découpage de l’attention avec SDPA ou xFormers, cela peut entraîner de fortes baisses de performances !

Exemples :

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

< >

( onload_device: deviceoffload_device: device = torch.device()offload_type: str = 'block_level'num_blocks_per_group: int | None = Nonenon_blocking: bool = Falseuse_stream: bool = Falserecord_stream: bool = Falselow_cpu_mem_usage = Falseoffload_to_disk_path: str | None = Noneexclude_modules: str | list[str] | None = None )

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, par défaut None) — Le chemin du 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 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 plutôt qu’en les épinglant au préalable. 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 cela 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 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(). Elle fonctionne en déplaçant chaque composant d'un pipeline vers le CPU pour le stockage, puis en le rechargeant 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 disposer d'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 niveau feuille les plus bas du graphe de calcul vers le CPU pour le stockage, et en ne chargeant que les feuilles sur le dispositif d'accélération pour le calcul. Cela utilise la plus faible quantité de mémoire d'accélérateur, mais peut être plus lent en raison du nombre excessif de synchronisations de dispositifs.

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 du module. 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 rendue beaucoup plus rapide en utilisant des flux.

Exemple :

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

< >

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

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 inférieures à celles de enable_sequential_cpu_offload, mais les performances sont bien meilleures grâce à l'exécution itérative de unet.

enable_sequential_cpu_offload

< >

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

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 dictionnaires d'état 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

< >

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

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() de xFormers.

Activer l’attention efficace en mémoire de 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.

> ⚠️ Lorsque l'attention efficace en mémoire et l'attention par tranches sont toutes deux activées, l'attention efficace en mémoire a la > priorité.

Exemples :

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

< >

( pipeline**kwargs ) → DiffusionPipeline

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 :

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

< >

( pretrained_model_name_or_path: str | os.PathLike**kwargs )

Paramètres

  • pretrained_model_name_or_path (str ou os.PathLike, facultatif) — Peut être l'un des éléments suivants :
    • 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().
  • 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) —

    > 🧪 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 de fichier d’un pipeline communautaire hébergé sur GitHub sous Community. Les noms de fichiers valides doivent correspondre au nom du fichier et non au script du pipeline (clip_guided_stable_diffusion plutôt que 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 Chargement et ajout de pipelines personnalisés

  • 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, 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 en local. 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, de la même manière que revision lors du chargement d’un pipeline personnalisé depuis le Hub. Par défaut, la dernière version stable 🤗 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étermine comment les différents composants d'un pipeline doivent être répartis sur les dispositifs disponibles. Actuellement, seul le device_map « balanced » est pris en charge. Consultez ce lien pour en savoir plus.
  • max_memory (Dict, facultatif) — Un dictionnaire identifiant les appareils 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 vers lequel 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’une décharge sur disque est présente.
  • 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 permet é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. Uniquement pris en charge 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 manière forcée à 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 (dictionnaire restant 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 se trouve 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.

> Pour utiliser des modèles privés ou restreints, connectez-vous avec hf > auth login.

Exemples :

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

< >

( )

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

< >

( images )

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

remove_all_hooks

< >

( )

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

reset_device_map

< >

( )

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

save_pretrained

< >

( save_directory: str | os.PathLikesafe_serialization: bool = Truevariant: str | None = Nonemax_shard_size: int | str | None = Nonepush_to_hub: bool = Falseuse_flashpack: bool = False**kwargs )

Paramètres

  • save_directory (str ou os.PathLike) — Répertoire dans lequel enregistrer le pipeline. Il 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 la méthode traditionnelle de 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) — Taille maximale d'un checkpoint avant son fractionnement. Les shards du checkpoint auront chacun une taille inférieure à cette limite. Si exprimée sous forme de chaîne de caractères, elle doit être composée de chiffres suivis d'une unité (comme "5GB"). Si exprimée 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) afin de 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 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().

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().

diffusers.StableDiffusionMixin.enable_freeu

< >

( s1: floats2: floatb1: floatb2: float )

Paramètres

  • s1 (float) — Facteur d'échelle pour l'étape 1 afin d'atténuer les contributions des caractéristiques de saut. Cela permet de mitiger l'« effet de lissage excessif » dans le processus de débruitage amélioré.
  • s2 (float) — Facteur d'échelle de l'étape 2 pour atténuer les contributions des caractéristiques de saut. Cela permet de mitiger l'« effet de sur-lissage » 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 pour les combinaisons de valeurs qui fonctionnent bien avec différents pipelines tels que Stable Diffusion v1, v2 et Stable Diffusion XL.

diffusers.StableDiffusionMixin.disable_freeu

< >

( )

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

PushToHubMixin

classe diffusers.utils.PushToHubMixin

< >

( )

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

push_to_hub

< >

( repo_id: strcommit_message: str | None = Noneprivate: bool | None = Nonetoken: str | None = Nonecreate_pr: bool = Falsesafe_serialization: bool = Truevariant: str | None = Nonesubfolder: str | None = None )

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’un envoi vers une organisation. repo_id peut également être un chemin vers un répertoire local.
  • commit_message (str, facultatif) — Message à committer lors de la poussée. Par défaut, "Upload {object}".
  • private (bool, facultatif) — Indique s'il faut rendre le dépôt privé. Si 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 HTTP bearer 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 :

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

classe diffusers.callbacks.PipelineCallback

< >

( cutoff_step_ratio = 1.0cutoff_step_index = None )

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 ce qui suit : tensor_inputs : cette méthode doit renvoyer une liste des entrées tensorielles spécifiques à votre callback. 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 callback.

classe diffusers.callbacks.SDCFGCutoffCallback

< >

( cutoff_step_ratio = 1.0cutoff_step_index = None )

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.

classe diffusers.callbacks.SDXLCFGCutoffCallback

< >

( cutoff_step_ratio = 1.0cutoff_step_index = None )

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.

classe diffusers.callbacks.SDXLControlnetCFGCutoffCallback

< >

( cutoff_step_ratio = 1.0cutoff_step_index = None )

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.

classe diffusers.callbacks.IPAdapterScaleCutoffCallback

< >

( cutoff_step_ratio = 1.0cutoff_step_index = None )

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.

classe diffusers.callbacks.SD3CFGCutoffCallback

< >

( cutoff_step_ratio = 1.0cutoff_step_index = None )

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.

Update on GitHub

←VQModel AutoPipeline→