diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_components.md

Composants et configurations

ComponentSpec[[diffusers.ComponentSpec]]

diffusers.ComponentSpec[[diffusers.ComponentSpec]]

diffusers.ComponentSpec(name: str | None = None, type_hint: typing.Optional[typing.Type] = None, description: str | None = None, config: diffusers.configuration_utils.FrozenDict | None = None, pretrained_model_name_or_path: str | list[str] | None = None, subfolder: str | None = '', variant: str | None = None, revision: str | None = None, default_creation_method: typing.Literal['from_config', 'from_pretrained'] = 'from_pretrained', repo: str | list[str] | None = None)

Source

Paramètres :

name : Nom du composant

type_hint : Type du composant (par exemple, UNet2DConditionModel)

description : Description facultative du composant

config : Dictionnaire de configuration facultatif pour la création de init

pretrained_model_name_or_path : Chemin optionnel pretrained_model_name_or_path pour la création via from_pretrained

subfolder : Sous-dossier facultatif dans pretrained_model_name_or_path

variant : variante facultative dans pretrained_model_name_or_path

revision : Révision facultative dans pretrained_model_name_or_path

default_creation_method : Méthode de création préférée - "from_config" ou "from_pretrained"

Spécification d'un composant de pipeline.

Un composant peut être créé de deux manières :

1. À partir de zéro en utilisant init avec un dictionnaire de configuration
2. en utilisant from_pretrained

create[[diffusers.ComponentSpec.create]]

create(config: diffusers.configuration_utils.FrozenDict | dict[str, typing.Any] | None = None, **kwargs)

Source

Créer un composant à l'aide de from_config avec config.

decode_load_id[[diffusers.ComponentSpec.decode_load_id]]

decode_load_id(load_id: str)

Source

Paramètres :

load_id : La chaîne load_id à décoder, format : "pretrained_model_name_or_path|subfolder|variant|revision" où les valeurs None sont représentées par "null"

Retourne :

Dictionnaire associant les noms des champs de chargement à leurs valeurs. Par exemple, { "pretrained_model_name_or_path": "path/to/repo", "subfolder": "subfolder", "variant": "variant", "revision": "revision" }. Si la valeur d'un segment est "null", elle est remplacée par None. Retourne None si load_id est "null" (indiquant que le composant n'a pas été créé avec la méthode load).

Décode une chaîne load_id en un dictionnaire de champs et de valeurs de chargement.

from_component[[diffusers.ComponentSpec.from_component]]

from_component(name: str, component: Any)

Source

Paramètres :

name : Nom du composant

component : Objet de composant à partir duquel créer la spécification

Retourne :

Objet ComponentSpec

Levée : ValueError

• ValueError -- Si le composant n'est pas pris en charge (par ex. nn.Module sans load_id, non-ConfigMixin)

Créer un ComponentSpec à partir d'un Component.

Prend actuellement en charge :

• Composants créés avec la méthode ComponentSpec.load()
• Les composants qui sont des sous-classes de ConfigMixin mais pas des nn.Modules (par exemple, les planificateurs, les guides)

load[[diffusers.ComponentSpec.load]]

load(**kwargs)

Source

Charger le composant à l'aide de from_pretrained.

loading_fields[[diffusers.ComponentSpec.loading_fields]]

loading_fields()

Source

Retourne les noms de tous les champs liés au chargement (c'est-à-dire ceux dont field.metadata["loading"] est True).

ConfigSpec[[diffusers.ConfigSpec]]

diffusers.ConfigSpec[[diffusers.ConfigSpec]]

diffusers.ConfigSpec(name: str, default: Any, description: str | None = None)

Source

Spécification d'un paramètre de configuration de pipeline.

ComponentsManager[[diffusers.ComponentsManager]]

diffusers.ComponentsManager[[diffusers.ComponentsManager]]

diffusers.ComponentsManager()

Source

Un registre central et un système de gestion pour les composants de modèles à travers plusieurs pipelines.

ComponentsManager offre une méthode unifiée pour enregistrer, suivre et réutiliser des composants de modèle (tels que UNet, VAE, encodeurs de texte, etc.) à travers différents pipelines modulaires. Il inclut des fonctionnalités de détection des doublons, de gestion de la mémoire et d’organisation des composants.

> Il s'agit d'une fonctionnalité expérimentale susceptible d'évoluer à l'avenir.

Exemple :

from diffusers import ComponentsManager

# Create a components manager
cm = ComponentsManager()

# Add components
cm.add("unet", unet_model, collection="sdxl")
cm.add("vae", vae_model, collection="sdxl")

# Enable auto offloading
cm.enable_auto_cpu_offload()

# Retrieve components
unet = cm.get_one(name="unet", collection="sdxl")

ajouter[[diffusers.ComponentsManager.add]]

add(name: str, component: Any, collection: str | None = None)

Source

Paramètres :

name (str) : Le nom du composant

component (Any) : le composant à ajouter

collection (str | None) : La collection à laquelle ajouter le composant

Retourne : str

L'identifiant unique du composant, généré sous la forme "{name}_{id(component)}", où id(component) est l'identifiant unique intégré de Python pour l'objet

Ajouter un composant au ComponentsManager.

disable_auto_cpu_offload[[diffusers.ComponentsManager.disable_auto_cpu_offload]]

disable_auto_cpu_offload()

Source

Désactiver le déchargement automatique sur CPU pour tous les composants.

enable_auto_cpu_offload[[diffusers.ComponentsManager.enable_auto_cpu_offload]]

enable_auto_cpu_offload(device: str | int | torch.device = None, memory_reserve_margin = '3GB', offload_strategy = None)

Source

Paramètres :

device (str | int | torch.device) : L'appareil d'exécution sur lequel les modèles sont déplacés pour les passes avant

memory_reserve_margin (str) : Marge de réserve mémoire à utiliser, par défaut 3 Go. Il s'agit de la quantité de mémoire à laisser libre sur l'appareil pour éviter d'épuiser la mémoire pendant l'exécution du modèle (par exemple, pour les activations intermédiaires, les gradients, etc.)

offload_strategy : Tout appelable ayant la signature (hooks, model_id, model, execution_device) -> hooks, renvoyant les modèles résidents à décharger avant le chargement du modèle entrant. La valeur par défaut est AutoOffloadStrategy, qui libère la combinaison minimale suffisante.

Activer le déchargement automatique sur CPU pour tous les composants.

L'algorithme fonctionne comme suit :

1. Tous les modèles démarrent sur le CPU par défaut
2. Lorsque le passage avant d'un modèle est appelé, il est déplacé vers l'appareil d'exécution
3. En cas de mémoire insuffisante, les autres modèles sur l'appareil sont transférés à nouveau vers le CPU
4. Le système tente de décharger la plus petite combinaison de modèles qui libère suffisamment de mémoire
5. Les modèles restent sur l'appareil d'exécution jusqu'à ce qu'un autre modèle ait besoin de mémoire et les force à en être retirés

Un modèle déchargé par groupe participe à ce processus, mais se place lui-même : il peut toujours libérer de l’espace en déplaçant d’autres modèles, et n’est jamais déplacé pour leur faire de la place. Les deux ordres fonctionnent — le déchargement par groupe avant ou après l’activation de cette option. AutoOffloadStrategy calibre ses décisions à partir de l’empreinte mémoire des modèles, ce qui ne décrit pas un modèle tenant un groupe à la fois ; passez donc un offload_strategy qui décide à partir du flux de travail.

get_components_by_ids[[diffusers.ComponentsManager.get_components_by_ids]]

get_components_by_ids(ids: list[str], return_dict_with_names: bool | None = True)

Source

Paramètres :

ids (list[str]) : liste d'identifiants de composants

return_dict_with_names (bool | None) : Indique s'il faut retourner un dictionnaire dont les clés sont les noms des composants :

Retourne : dict[str, Any]

Dictionnaire de composants.

• Si return_dict_with_names=True, les clés sont les noms des composants.
• Si return_dict_with_names=False, les clés sont les identifiants des composants.

Levée : ValueError

• ValueError -- Si des noms de composants en double sont trouvés dans les résultats de recherche lorsque return_dict_with_names=True

Récupérer des composants à partir d'une liste d'identifiants.

get_components_by_names[[diffusers.ComponentsManager.get_components_by_names]]

get_components_by_names(names: list[str], collection: str | None = None)

Source

Paramètres :

names (list[str]) : liste de noms de composants

collection (str | None) : Collection facultative pour filtrer

Retourne : dict[str, Any]

Dictionnaire de composants avec les noms de composants en tant que clés

Levée : ValueError

• ValueError -- Si des noms de composants en double sont trouvés dans les résultats de recherche

Récupérer des composants à partir d'une liste de noms, éventuellement filtrée par collection.

get_ids[[diffusers.ComponentsManager.get_ids]]

get_ids(names: str | list[str] = None, collection: str | None = None)

Source

Paramètres :

names (str | list[str]) : liste de noms de composants

collection (str | None) : Collection facultative pour filtrer

Retourne : list[str]

liste d'identifiants de composants

Obtenir les identifiants de composants à partir d'une liste de noms, éventuellement filtrée par collection.

get_model_info[[diffusers.ComponentsManager.get_model_info]]

get_model_info(component_id: str, fields: str | list[str] | None = None)

Source

Paramètres :

component_id (str) : Nom du composant pour lequel obtenir des informations

fields (str | list[str] | None) : Champ(s) à retourner. Peut être une chaîne de caractères pour un champ unique ou une liste de champs. Si None, utilise le paramètre available_info_fields.

Retourne :

Dictionnaire contenant les métadonnées des composants demandés. Si fields est spécifié, renvoie uniquement ces champs. Sinon, renvoie tous les champs.

Obtenez des informations complètes sur un composant.

get_one[[diffusers.ComponentsManager.get_one]]

get_one(component_id: str | None = None, name: str | None = None, collection: str | None = None, load_id: str | None = None)

Source

Paramètres :

component_id (str | None) : ID de composant facultatif à récupérer

name (str | None) : Nom ou motif du composant

collection (str | None) : Collection facultative pour filtrer

load_id (str | None) : load_id facultatif pour filtrer

Retourne :

Un composant unique

Levée : ValueError

• ValueError -- Si aucun composant ne correspond ou si plusieurs composants correspondent

Obtenir un composant unique en :

• recherche par nom (correspondance de motif), collection ou load_id.
• en passant un component_id Lève une erreur si plusieurs composants correspondent ou si aucun n'est trouvé.

supprimer[[diffusers.ComponentsManager.remove]]

remove(component_id: str = None)

Source

Paramètres :

component_id (str) : l'identifiant du composant à supprimer

Supprimer un composant du ComponentsManager.

remove_from_collection[[diffusers.ComponentsManager.remove_from_collection]]

remove_from_collection(component_id: str, collection: str)

Source

Supprimer un composant d'une collection.

search_components[[diffusers.ComponentsManager.search_components]]

search_components(names: str | None = None, collection: str | None = None, load_id: str | None = None, return_dict_with_names: bool = True)

Source

Paramètres :

names : Nom(s) de composant(s) ou motif(s) Motifs : - "unet" : correspond à tout composant dont le nom de base est "unet" (par ex. unet_123abc) - "!unet" : tout sauf les composants dont le nom de base est "unet" - "unet*" : tout composant dont le nom de base commence par "unet" - "!unet*" : tout composant dont le nom de base ne commence PAS par "unet" - "unet" : tout composant dont le nom de base contient "unet" - "!unet" : tout composant dont le nom de base ne contient PAS "unet" - "refiner|vae|unet" : tout composant dont le nom de base correspond exactement à "refiner", "vae" ou "unet" - "!refiner|vae|unet" : tout composant dont le nom de base ne correspond PAS exactement à "refiner", "vae" ou "unet" - "unet*|vae*" : tout composant dont le nom de base commence par "unet" OU par "vae"

collection : Collection facultative pour filtrer

load_id : load_id facultatif pour filtrer par

return_dict_with_names : Si True, renvoie un dictionnaire dont les clés sont les noms des composants et lève une erreur si plusieurs composants portant le même nom sont trouvés. Si False, renvoie un dictionnaire dont les clés sont les identifiants des composants.

Retourne :

Dictionnaire associant les noms des composants aux composants si return_dict_with_names=True, ou un dictionnaire associant les identifiants des composants aux composants si return_dict_with_names=False

Recherchez des composants par nom à l'aide d'une correspondance de motifs simple. Filtrez éventuellement par collection ou load_id.

set_offload_strategy[[diffusers.ComponentsManager.set_offload_strategy]]

set_offload_strategy(offload_strategy)

Source

Paramètres :

offload_strategy : Tout appelable ayant la signature (hooks, model_id, model, execution_device) -> hooks : il reçoit les hooks des modèles actuellement sur l’appareil et renvoie ceux à décharger avant le chargement du modèle entrant. La valeur par défaut est AutoOffloadStrategy, qui libère la combinaison minimale suffisante.

Remplace la stratégie de déchargement sur tous les modèles gérés. Valable uniquement lorsque le déchargement automatique sur CPU est activé.

InsertableDict[[diffusers.modular_pipelines.InsertableDict]]

diffusers.modular_pipelines.InsertableDict[[diffusers.modular_pipelines.InsertableDict]]

Source