# Pipelines et composants de la communauté

Les pipelines communautaires sont des classes [DiffusionPipeline](/docs/diffusers/main/fr/api/pipelines/overview#diffusers.DiffusionPipeline) qui diffèrent de l'implémentation de l'article original. Ils offrent des fonctionnalités supplémentaires ou étendent l'implémentation du pipeline original.

> [!TIP]
> Consultez les pipelines de la communauté dans [diffusers/examples/community](https://github.com/huggingface/diffusers/tree/main/examples/community), qui proposent des exemples d’inférence et d’entraînement pour vous montrer comment les utiliser.

Les pipelines communautaires sont stockés sur le Hub ou dans le dépôt GitHub de Diffusers. Les pipelines du Hub sont entièrement personnalisables (planificateur, modèles, code du pipeline, etc.), tandis que les pipelines GitHub sont limités au code du pipeline personnalisé uniquement. Comparez les deux types de pipelines dans le tableau ci-dessous.

|  | GitHub | Hub |
|---|---|---|
| Utilisation | `custom_pipeline="<filename_without_.py>"` | ID du dépôt Hub ou `trust_remote_code=True` lorsque `_class_name` pointe vers du code personnalisé |
| Processus de révision | Ouvrez une Pull Request sur GitHub et soumettez-la à un processus de revue par l'équipe Diffusers avant la fusion. Cette option est plus lente. | Téléversez directement dans un dépôt du Hub sans révision. C'est l'option la plus rapide. |
| Visibilité | Inclus dans le dépôt et la documentation officiels de Diffusers. | Inclus dans votre profil Hub et dépend de votre propre utilisation et de votre promotion pour gagner en visibilité. |

## Chargement d'un pipeline communautaire

Chargez l’un ou l’autre type de pipeline communautaire en passant `custom_pipeline` à [from_pretrained()](/docs/diffusers/main/fr/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained).

```py
import torch
from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-3-medium-diffusers",
    custom_pipeline="pipeline_stable_diffusion_3_instruct_pix2pix",
    dtype=torch.float16,
    device_map="cuda"  # or "mps", "xpu", "cpu"
)
```

Ajoutez l'argument `custom_revision` à [from_pretrained()](/docs/diffusers/main/fr/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained) pour charger un pipeline communautaire à partir d'une version spécifique (par exemple, `v0.30.0` ou `main`). Par défaut, les pipelines communautaires sont chargés à partir de la dernière version stable de Diffusers.

```py
import torch
from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-3-medium-diffusers",
    custom_pipeline="pipeline_stable_diffusion_3_instruct_pix2pix",
    custom_revision="main",
    dtype=torch.float16,
    device_map="cuda"  # or "mps", "xpu", "cpu"
)
```

> [!WARNING]
> Pendant que le Hugging Face Hub [scanne](https://huggingface.co/docs/hub/security-malware) les fichiers, vous devez toujours inspecter le code du pipeline du Hub et vous assurer qu'il est sûr.

Il existe plusieurs façons de charger un pipeline de la communauté.

- Transmettez un chemin vers `custom_pipeline` pour charger un pipeline communautaire local. Le répertoire doit contenir un fichier `pipeline.py` contenant la classe du pipeline.

  ```py
  import torch
  from diffusers import DiffusionPipeline

  pipeline = DiffusionPipeline.from_pretrained(
      "stabilityai/stable-diffusion-3-medium-diffusers",
      custom_pipeline="path/to/pipeline_directory",
      trust_remote_code=True,
      dtype=torch.float16,
      device_map="cuda"  # or "mps", "xpu", "cpu"
  )
  ```

- L'argument `custom_pipeline` est également pris en charge par [from_pipe()](/docs/diffusers/main/fr/api/pipelines/overview#diffusers.DiffusionPipeline.from_pipe), ce qui est utile pour [réutiliser des pipelines](./loading#reusing-models-in-multiple-pipelines) sans consommer de mémoire supplémentaire. Il limite l'utilisation de la mémoire au seul pipeline le plus volumineux chargé.

  ```py
  import torch
  from diffusers import DiffusionPipeline

  pipeline_sd = DiffusionPipeline.from_pretrained(
      "emilianJR/CyberRealistic_V3", dtype=torch.float16, device_map="cuda"  # or "mps", "xpu", "cpu"
  )
  pipeline_lpw = DiffusionPipeline.from_pipe(
      pipeline_sd, custom_pipeline="lpw_stable_diffusion"
  )
  ```

  La méthode [from_pipe()](/docs/diffusers/main/fr/api/pipelines/overview#diffusers.DiffusionPipeline.from_pipe) est particulièrement utile pour charger les pipelines de la communauté, car beaucoup d’entre eux ne disposent pas de poids préentraînés. Les pipelines de la communauté ajoutent généralement une fonctionnalité par-dessus un pipeline existant.

## Composants de la communauté

Les composants communautaires vous permettent de construire des pipelines avec des transformeurs, des UNets, des VAE et des planificateurs non pris en charge par Diffusers. Ces composants nécessitent leurs propres modules Python.

Cette section montre comment les utilisateurs peuvent utiliser des composants de la communauté pour construire un pipeline communautaire, en prenant [showlab/show-1-base](https://huggingface.co/showlab/show-1-base) comme exemple.

1. Chargez les composants requis, à savoir le planificateur et le processeur d'images. L'encodeur de texte est généralement importé depuis [Transformers](https://huggingface.co/docs/transformers/index).

```python
from transformers import T5Tokenizer, T5EncoderModel, CLIPImageProcessor
from diffusers import DPMSolverMultistepScheduler

pipeline_id = "showlab/show-1-base"
tokenizer = T5Tokenizer.from_pretrained(pipeline_id, subfolder="tokenizer")
text_encoder = T5EncoderModel.from_pretrained(pipeline_id, subfolder="text_encoder")
scheduler = DPMSolverMultistepScheduler.from_pretrained(pipeline_id, subfolder="scheduler")
feature_extractor = CLIPImageProcessor.from_pretrained(pipeline_id, subfolder="feature_extractor")
```

> [!WARNING]
> Aux étapes 2 et 3, l'implémentation personnalisée de [UNet](https://github.com/showlab/Show-1/blob/main/showone/models/unet_3d_condition.py) et de [pipeline](https://huggingface.co/sayakpaul/show-1-base-with-code/blob/main/unet/showone_unet_3d_condition.py) doit correspondre au format présenté dans leurs fichiers respectifs pour que cet exemple fonctionne.

2. Chargez un [UNet personnalisé](https://github.com/showlab/Show-1/blob/main/showone/models/unet_3d_condition.py) déjà implémenté dans [showone_unet_3d_condition.py](https://huggingface.co/sayakpaul/show-1-base-with-code/blob/main/unet/showone_unet_3d_condition.py). Le nom de la classe [UNet3DConditionModel](/docs/diffusers/main/fr/api/models/unet3d-cond#diffusers.UNet3DConditionModel) est renommé en `ShowOneUNet3DConditionModel` pour l’implémentation personnalisée, car [UNet3DConditionModel](/docs/diffusers/main/fr/api/models/unet3d-cond#diffusers.UNet3DConditionModel) existe déjà dans Diffusers. Tous les composants requis pour la classe `ShowOneUNet3DConditionModel` doivent être placés dans `showone_unet_3d_condition.py`.

```python
from showone_unet_3d_condition import ShowOneUNet3DConditionModel

unet = ShowOneUNet3DConditionModel.from_pretrained(pipeline_id, subfolder="unet")
```

3. Chargez le code du pipeline personnalisé (déjà implémenté dans [pipeline_t2v_base_pixel.py](https://huggingface.co/sayakpaul/show-1-base-with-code/blob/main/pipeline_t2v_base_pixel.py)). Ce script contient une classe `TextToVideoIFPipeline` personnalisée pour générer des vidéos à partir de texte. Tout comme pour le UNet personnalisé, tout le code requis pour `TextToVideoIFPipeline` doit être placé dans `pipeline_t2v_base_pixel.py`.

Initialiser `TextToVideoIFPipeline` avec `ShowOneUNet3DConditionModel`.

```python
import torch
from pipeline_t2v_base_pixel import TextToVideoIFPipeline

pipeline = TextToVideoIFPipeline(
    unet=unet,
    text_encoder=text_encoder,
    tokenizer=tokenizer,
    scheduler=scheduler,
    feature_extractor=feature_extractor,
)
pipeline = pipeline.to("cuda")  # or "mps", "xpu", "cpu"
```

4. Poussez le pipeline vers le Hub pour le partager avec la communauté.

```python
pipeline.push_to_hub("custom-t2v-pipeline")
```

Une fois le pipeline poussé avec succès, apportez les modifications suivantes.

- Modifiez l'attribut `_class_name` dans [model_index.json](https://huggingface.co/sayakpaul/show-1-base-with-code/blob/main/model_index.json#L2) en `["pipeline_t2v_base_pixel", "TextToVideoIFPipeline"]`.
- Téléchargez `showone_unet_3d_condition.py` dans le sous-dossier [unet](https://huggingface.co/sayakpaul/show-1-base-with-code/blob/main/unet/showone_unet_3d_condition.py).
- Téléchargez `pipeline_t2v_base_pixel.py` dans le [dépôt](https://huggingface.co/sayakpaul/show-1-base-with-code/tree/main) du pipeline.

Pour exécuter l'inférence, ajoutez l'argument `trust_remote_code` lors de l'initialisation du pipeline afin de gérer toute la « magie » en arrière-plan.

```python
import torch
from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained(
    "<change-username>/<change-id>", trust_remote_code=True, dtype=torch.float16
)
```

> [!WARNING]
> En guise de précaution supplémentaire avec `trust_remote_code=True`, passez un hachage de commit à l'argument `revision` dans [from_pretrained()](/docs/diffusers/main/fr/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained) pour vous assurer que le code n'a pas été mis à jour avec du nouveau code malveillant (à moins que vous ne fiez entièrement confiance aux propriétaires du modèle).

## Étapes suivantes

- Consultez la question [#841](https://github.com/huggingface/diffusers/issues/841) pour plus de contexte sur la raison pour laquelle nous ajoutons des pipelines communautaires afin de permettre à chacun de partager facilement son travail sans être ralenti.
- Consultez le dépôt [stabilityai/japanese-stable-diffusion-xl](https://huggingface.co/stabilityai/japanese-stable-diffusion-xl/) pour un exemple supplémentaire de pipeline communautaire qui utilise également la fonctionnalité `trust_remote_code`.