# Pipeline

## ModularPipeline[[diffusers.ModularPipeline]]

#### diffusers.ModularPipeline[[diffusers.ModularPipeline]]

```python
diffusers.ModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

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

**Paramètres :**

blocks : ModularPipelineBlocks, les blocs à utiliser dans le pipeline

Classe de base pour tous les pipelines modulaires.

#### from_pretrained[[diffusers.ModularPipeline.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike | None, trust_remote_code: bool | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, **kwargs)
```

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

**Paramètres :**

pretrained_model_name_or_path (`str` ou `os.PathLike`, facultatif) : Chemin vers une configuration de pipeline préentraînée. Il tentera d’abord de charger la configuration depuis `modular_model_index.json`, puis basculera sur `model_index.json` pour la compatibilité avec les dépôts standard non modulaires. Si pretrained_model_name_or_path ne contient aucune configuration de pipeline, elle sera définie sur None lors de l’initialisation.

trust_remote_code (`bool`, optionnel) : Indique s'il faut faire confiance au code distant lors du chargement du pipeline. Doit être défini sur True si vous souhaitez créer des blocs de pipeline basés sur le code personnalisé de `pretrained_model_name_or_path`

components_manager (`ComponentsManager`, optionnel) : instance de ComponentsManager pour gérer plusieurs composants à travers différents pipelines et appliquer des stratégies de déchargement.

collection (`str`, optionnel) --` Nom de la collection pour organiser les composants dans le ComponentsManager.

workflow (`str`, optionnel) : Nom d'un workflow déclaré par les blocs du pipeline. S'il est fourni, les blocs sont élagués aux blocs d'exécution de ce workflow, de sorte que le pipeline n'attend — et que `load_components()` ne charge — que les composants utilisés par ce workflow.

Charger un ModularPipeline depuis un dépôt du hub Hugging Face.

#### get_component_spec[[diffusers.ModularPipeline.get_component_spec]]

```python
get_component_spec(name: str)
```

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

**Retourne :**

- une copie de l'objet ComponentSpec pour le nom de composant donné

#### load_components[[diffusers.ModularPipeline.load_components]]

```python
load_components(names: list[str] | str | None = None, workflow: str | None = None, **kwargs)
```

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

**Paramètres :**

names : liste des noms de composants à charger. Si None, tous les composants dont default_creation_method == "from_pretrained" seront chargés. Si fourni sous forme de liste ou de chaîne, seuls les composants spécifiés seront chargés.

workflow : nom d'un workflow déclaré par les blocs de pipeline. S'il est fourni, seuls les composants utilisés par les blocs d'exécution de ce workflow sont chargés. Ne peut pas être combiné avec `names`.

- ****kwargs** : kwargs supplémentaires à transmettre à `from_pretrained()`. Peut être : - une valeur unique à appliquer à tous les composants à charger, par exemple dtype=torch.bfloat16 - un dictionnaire, par exemple dtype={"unet": torch.bfloat16, "default": torch.float32} - si nécessaire, écrase ComponentSpec si un champ de chargement différent est passé dans kwargs, par exemple `pretrained_model_name_or_path`, `variant`, `revision`, etc. - si nécessaire, écrase ComponentSpec si un champ de chargement différent est passé dans kwargs, par exemple `pretrained_model_name_or_path`, `variant`, `revision`, etc.

Charger les composants sélectionnés à partir des spécifications.

#### register_components[[diffusers.ModularPipeline.register_components]]

```python
register_components(**kwargs)
```

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

**Paramètres :**

- ****kwargs** : Arguments par mot-clé où les clés sont les noms des composants et les valeurs sont les objets de composants. Par exemple, register_components(unet=unet_model, text_encoder=encoder_model)

Enregistrez les composants avec leurs spécifications correspondantes.

Cette méthode est responsable de :
1. Définit les objets de composant en tant qu'attributs du chargeur (par exemple, self.unet = unet)
2. Met à jour le dictionnaire de configuration, qui sera enregistré sous le nom `modular_model_index.json` lors de l'appel à `save_pretrained` (uniquement pour les composants from_pretrained)
3. Ajoute des composants au gestionnaire de composants si celui-ci est attaché (uniquement pour les composants from_pretrained)

Cette méthode est appelée lorsque :
- Les composants sont d'abord initialisés dans __init__ :
  - les composants de from_pretrained non chargés lors de __init__ sont enregistrés comme None ;
  - les composants non from_pretrained sont créés lors de __init__ et enregistrés en tant que l'objet lui-même
- Les composants sont mis à jour à l'aide de la méthode `update_components()` : par exemple, loader.update_components(unet=unet) ou loader.update_components(guider=guider_spec)
- (from_pretrained) Les composants sont chargés avec la méthode `load_components()` : par exemple, loader.load_components(names=["unet"]) ou loader.load_components() pour charger tous les composants par défaut

Remarques :
- Lors de l’enregistrement de None pour un composant, l’attribut est défini sur None, mais les spécifications sont toujours synchronisées avec le dictionnaire de configuration, qui sera enregistré sous la forme `modular_model_index.json` lors de l’appel à `save_pretrained`.
- Les component_specs sont mis à jour pour correspondre au nouveau composant en dehors de cette méthode, par exemple dans la méthode `update_components()`

#### save_pretrained[[diffusers.ModularPipeline.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, **kwargs)
```

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

**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 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 son fractionnement. Les points de contrôle fractionnés auront chacun une taille inférieure à cette valeur. S'il est exprimé sous forme de chaîne, 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.

push_to_hub (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut publier le pipeline sur le Hugging Face model hub après l'avoir enregistré.

- ****kwargs** : Arguments supplémentaires par mot-clé : - `overwrite_modular_index` (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut mettre à jour `modular_model_index.json` afin que la spécification de chargement de chaque composant enregistré pointe vers la destination : `repo_id` lors de la publication sur le Hub, sinon `save_directory`. Les composants non chargés ne sont pas enregistrés et conservent toujours leurs spécifications de chargement enregistrées. Passez `False` pour conserver également les spécifications enregistrées des composants en cours d'enregistrement (par exemple pour un index qui référence délibérément d'autres dépôts) ; les composants sans identifiant de chargement (tels que les modèles personnalisés ajoutés avec `update_components`) sont toujours réécrits car ils n'ont pas de source enregistrée. - `repo_id` (`str`, *facultatif*) : L'identifiant du dépôt vers lequel publier le pipeline. Valeur par défaut : le dernier composant de `save_directory`. - `commit_message` (`str`, *facultatif*) : Message de commit pour l'opération de publication sur le Hub. - `private` (`bool`, *facultatif*) : Indique si le dépôt doit être privé. - `create_pr` (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut créer une demande de tirage (pull request) au lieu de publier directement. - `token` (`str`, *facultatif*) : Le jeton Hugging Face à utiliser pour l'authentification.

Enregistrez le pipeline et tous ses composants dans un répertoire afin qu’il puisse être rechargé à l’aide de la méthode de classe [from_pretrained()](/docs/diffusers/main/fr/api/modular_diffusers/pipeline#diffusers.ModularPipeline.from_pretrained).

#### vers[[diffusers.ModularPipeline.to]]

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

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

**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/main/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

#### unload_components[[diffusers.ModularPipeline.unload_components]]

```python
unload_components(names: list[str] | str)
```

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

**Paramètres :**

names : nom du composant ou liste de noms de composants à décharger.

Décharger les composants sélectionnés, libérant ainsi leur mémoire.

L'attribut component est réinitialisé à `None` et, si un ComponentsManager est attaché, le composant est retiré de celui-ci. La spécification du composant n'est pas modifiée, ce qui permet de le recharger ultérieurement avec `load_components()`.

#### update_components[[diffusers.ModularPipeline.update_components]]

```python
update_components(**kwargs)
```

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

**Paramètres :**

- ****kwargs** : Objets de composants ou valeurs de configuration à mettre à jour : - Objets de composants : Les modèles chargés avec `AutoModel.from_pretrained()` ou `ComponentSpec.load()` sont automatiquement étiquetés avec des informations de chargement. Les objets ConfigMixin sans poids (par exemple, les planificateurs, les guides) peuvent être passés directement. - Valeurs de configuration : Des valeurs simples pour mettre à jour les paramètres de configuration (par exemple, `requires_safety_checker=False`)

Mettre à jour les composants et les valeurs et spécifications de configuration après l'instantiation du pipeline.

Cette méthode vous permet de :
1. Remplacer les composants existants par de nouveaux (par exemple, mettre à jour `self.unet` ou `self.text_encoder`)
2. Mettre à jour les valeurs de configuration (par exemple, modifier le drapeau `self.requires_safety_checker`)

En plus de mettre à jour les composants et les valeurs de configuration en tant qu'attributs du pipeline, la méthode met également à jour :
- les spécifications correspondantes dans `_component_specs` et `_config_specs`
- le dictionnaire `config`, qui sera enregistré sous le nom `modular_model_index.json` lors de l'appel à `save_pretrained`

Exemples :
```python
# Update pre-trained model
pipeline.update_components(unet=new_unet_model, text_encoder=new_text_encoder)

# Update configuration values
pipeline.update_components(requires_safety_checker=False)
```

Remarques :
- Les composants chargés avec `AutoModel.from_pretrained()` ou `ComponentSpec.load()` auront
spécifications de chargement conservées pour la sérialisation. Les composants personnalisés ou chargés localement sans références au Hub verront leurs entrées dans `modular_model_index.json` mises à jour automatiquement lors de l'appel à `save_pretrained()`.
- Les objets ConfigMixin sans poids (par exemple, les planificateurs, les guides) peuvent être passés directement.