# Composants et configurations

## ComponentSpec[[diffusers.ComponentSpec]]

#### diffusers.ComponentSpec[[diffusers.ComponentSpec]]

```python
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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L98)

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

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L267)

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

#### decode_load_id[[diffusers.ComponentSpec.decode_load_id]]

```python
decode_load_id(load_id: str)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L228)

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

```python
from_component(name: str, component: Any)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L149)

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

```python
load(**kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L295)

Charger le composant à l'aide de from_pretrained.

#### loading_fields[[diffusers.ComponentSpec.loading_fields]]

```python
loading_fields()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L209)

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

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L360)

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

## ComponentsManager[[diffusers.ComponentsManager]]

#### diffusers.ComponentsManager[[diffusers.ComponentsManager]]

```python
diffusers.ComponentsManager()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L296)

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

[ComponentsManager](/docs/diffusers/main/fr/api/modular_diffusers/pipeline_components#diffusers.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.

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

Exemple :
```python
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]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L393)

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

```python
disable_auto_cpu_offload()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L795)

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

#### enable_auto_cpu_offload[[diffusers.ComponentsManager.enable_auto_cpu_offload]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L701)

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

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L1104)

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

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L1137)

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

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L1086)

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

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L812)

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

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L1041)

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

```python
remove(component_id: str = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L485)

**Paramètres :**

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

Supprimer un composant du ComponentsManager.

#### remove_from_collection[[diffusers.ComponentsManager.remove_from_collection]]

```python
remove_from_collection(component_id: str, collection: str)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L467)

Supprimer un composant d'une collection.

#### search_components[[diffusers.ComponentsManager.search_components]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L515)

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

```python
set_offload_strategy(offload_strategy)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L779)

**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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L60)