Buckets:
| ## Utilisation de blocs personnalisés avec Mellon | |
| [Mellon](https://github.com/cubiq/Mellon) est une interface de flux de travail visuel qui s'intègre à Modular Diffusers et qui est conçue pour les flux de travail basés sur des nœuds. | |
| > [!WARNING] | |
| > Mellon est en phase de développement précoce et n'est pas encore prêt pour une utilisation en production. Considérez ceci comme un aperçu de la façon dont l'intégration fonctionne ! | |
| Les blocs personnalisés fonctionnent dans Mellon sans configuration supplémentaire - il suffit d'ajouter un `mellon_pipeline_config.json` à votre dépôt. Ce fichier de configuration indique à Mellon comment afficher les paramètres de votre bloc sous forme de composants d'interface utilisateur. | |
| Voici à quoi cela ressemble en action avec le bloc [Gemini Prompt Expander](https://huggingface.co/diffusers/gemini-prompt-expander-mellon) : | |
|  | |
| Pour utiliser un bloc personnalisé modulaire de diffusers dans Mellon : | |
| 1. Faites glisser un **Dynamic Block Node** depuis la section ModularDiffusers | |
| 2. Saisissez le `repo_id` (par exemple, `diffusers/gemini-prompt-expander-mellon`) | |
| 3. Cliquez sur **Charger un bloc personnalisé** | |
| 4. Le nœud se transforme pour afficher les entrées et les sorties de votre bloc | |
| Passons maintenant en revue la création de cette configuration pour votre propre bloc personnalisé. | |
| ## Étapes pour créer une configuration Mellon | |
| 1. **Spécifiez les types Mellon pour vos paramètres** - Chaque `InputParam`/`OutputParam` a besoin d'un type qui indique à Mellon quel composant d'interface à afficher (par exemple, `"textbox"`, `"dropdown"`, `"image"`). | |
| 2. **Générer `mellon_pipeline_config.json`** - Utilisez notre utilitaire pour générer un modèle de configuration et le pousser vers votre dépôt Hub. | |
| 3. **(Facultatif) Ajuster manuellement la configuration** - Affinez la configuration générée pour répondre à vos besoins spécifiques. | |
| ## Spécifier les types Mellon pour les paramètres | |
| Les types Mellon déterminent la façon dont chaque paramètre est rendu dans l’interface utilisateur. Si vous ne spécifiez pas de type pour un paramètre, il passe par défaut à `"custom"`, qui s’affiche sous forme de simple point de connexion. Vous pouvez toujours ajuster cela plus tard dans la configuration générée. | |
| | Type | Entrées/Sorties | Description | | |
| |------|--------------|-------------| | |
| | `image` | Les deux | Image (Image PIL) | | |
| | `video` | Les deux | Vidéo | | |
| | `text` | Les deux | Affichage du texte | | |
| | `textbox` | Entrée | Saisie de texte | | |
| | `dropdown` | Entrée | Menu de sélection déroulant | | |
| | `slider` | Entrée | Curseur pour les valeurs numériques | | |
| | `number` | Entrée | Entrée numérique | | |
| | `checkbox` | Entrée | Bascule booléenne | | |
| Pour les paramètres nécessitant une configuration plus poussée (comme des menus déroulants avec des options, ou des curseurs avec des valeurs min/max), passez directement une instance de `MellonParam` au lieu d'une chaîne de caractères. Vous pouvez utiliser l'une des méthodes de classe ci-dessous, ou en créer une entièrement personnalisée avec `MellonParam(name, label, type, ...)`. | |
| | Méthode | Description | | |
| |--------|-------------| | |
| | `MellonParam.Input.image(name)` | Entrée d'image | | |
| | `MellonParam.Input.textbox(name, default)` | Saisie de texte en tant que zone de texte | | |
| | `MellonParam.Input.dropdown(name, options, default)` | Sélection par menu déroulant | | |
| | `MellonParam.Input.slider(name, default, min, max, step)` | Curseur pour les valeurs numériques | | |
| | `MellonParam.Input.number(name, default, min, max, step)` | Entrée numérique (sans curseur) | | |
| | `MellonParam.Input.seed(name, default)` | Entrée de graine avec bouton d'aléatisation | | |
| | `MellonParam.Input.checkbox(name, default)` | Case à cocher booléenne | | |
| | `MellonParam.Input.model(name)` | Entrée du modèle pour les composants de diffusers | | |
| | `MellonParam.Output.image(name)` | Sortie d'image | | |
| | `MellonParam.Output.video(name)` | Sortie vidéo | | |
| | `MellonParam.Output.text(name)` | Sortie de texte | | |
| | `MellonParam.Output.model(name)` | Sortie du modèle pour les composants de diffusers | | |
| Choisissez l'une des méthodes ci-dessous pour spécifier un type Mellon. | |
| ### Utilisation de `metadata` dans les définitions de blocs | |
| Si vous définissez un bloc personnalisé à partir de zéro, ajoutez `metadata={"mellon": "<type>"}` directement à vos définitions de `InputParam` et `OutputParam`. Si vous modifiez un bloc personnalisé existant du Hub, consultez [Modifier les blocs personnalisés](./custom_blocks#editing-custom-blocks) pour savoir comment le télécharger localement. | |
| ```python | |
| class GeminiPromptExpander(ModularPipelineBlocks): | |
| @property | |
| def inputs(self) -> List[InputParam]: | |
| return [ | |
| InputParam( | |
| "prompt", | |
| type_hint=str, | |
| required=True, | |
| description="Prompt to use", | |
| metadata={"mellon": "textbox"}, # Text input | |
| ) | |
| ] | |
| @property | |
| def intermediate_outputs(self) -> List[OutputParam]: | |
| return [ | |
| OutputParam( | |
| "prompt", | |
| type_hint=str, | |
| description="Expanded prompt by the LLM", | |
| metadata={"mellon": "text"}, # Text output | |
| ), | |
| OutputParam( | |
| "old_prompt", | |
| type_hint=str, | |
| description="Old prompt provided by the user", | |
| <CopyLLMTxtMenu containerStyle="float: inline-end; margin-inline-start: 10px; display: inline-flex; position: relative; z-index: 10;"></CopyLLMTxtMenu> | |
| # No metadata - we don't want to render this in UI | |
| ) | |
| ] | |
| ``` | |
| Pour un contrôle total de la configuration de l’interface utilisateur, passez directement une instance de `MellonParam` : | |
| ```python | |
| from diffusers.modular_pipelines.mellon_node_utils import MellonParam | |
| InputParam( | |
| "mode", | |
| type_hint=str, | |
| default="balanced", | |
| metadata={"mellon": MellonParam.Input.dropdown("mode", options=["fast", "balanced", "quality"])}, | |
| ) | |
| ``` | |
| ### Utilisation de `input_types` et `output_types` lors de la génération de la configuration | |
| Si vous travaillez avec un pipeline existant ou préférez garder vos définitions de blocs propres, spécifiez les types lors de la génération de la configuration à l'aide de l'argument `input_types/output_types` : | |
| ```python | |
| from diffusers.modular_pipelines.mellon_node_utils import MellonPipelineConfig | |
| mellon_config = MellonPipelineConfig.from_custom_block( | |
| blocks, | |
| input_types={"prompt": "textbox"}, | |
| output_types={"prompt": "text"} | |
| ) | |
| ``` | |
| > [!NOTE] | |
| > Lorsque `metadata` et `input_types`/`output_types` sont tous les deux spécifiés, les arguments remplacent `metadata`. | |
| ## Générer et pousser la configuration Mellon | |
| Après avoir ajouté des métadonnées à votre bloc, générez le modèle de configuration Mellon par défaut et poussez-le vers le Hub : | |
| ```python | |
| from diffusers import ModularPipelineBlocks | |
| from diffusers.modular_pipelines.mellon_node_utils import MellonPipelineConfig | |
| # load your custom blocks from your local dir | |
| blocks = ModularPipelineBlocks.from_pretrained("/path/local/folder", trust_remote_code=True) | |
| # Generate the default config template | |
| mellon_config = MellonPipelineConfig.from_custom_block(blocks) | |
| # push the default template to `repo_id`, you will need to pass the same local folder path so that it will save the config locally first | |
| mellon_config.save( | |
| local_dir="/path/local/folder", | |
| repo_id= repo_id, | |
| push_to_hub=True | |
| ) | |
| ``` | |
| Cela crée un fichier `mellon_pipeline_config.json` dans votre dépôt. | |
| ## Examiner et ajuster la configuration | |
| Le modèle généré est un point de départ - vous souhaiterez peut-être l'ajuster selon vos besoins. Examinons la configuration générée pour le Gemini Prompt Expander : | |
| ```json | |
| { | |
| "label": "Gemini Prompt Expander", | |
| "default_repo": "", | |
| "default_dtype": "", | |
| "node_params": { | |
| "custom": { | |
| "params": { | |
| "prompt": { | |
| "label": "Prompt", | |
| "type": "string", | |
| "display": "textarea", | |
| "default": "" | |
| }, | |
| "out_prompt": { | |
| "label": "Prompt", | |
| "type": "string", | |
| "display": "output" | |
| }, | |
| "old_prompt": { | |
| "label": "Old Prompt", | |
| "type": "custom", | |
| "display": "output" | |
| }, | |
| "doc": { | |
| "label": "Doc", | |
| "type": "string", | |
| "display": "output" | |
| } | |
| }, | |
| "input_names": ["prompt"], | |
| "model_input_names": [], | |
| "output_names": ["out_prompt", "old_prompt", "doc"], | |
| "block_name": "custom", | |
| "node_type": "custom" | |
| } | |
| } | |
| } | |
| ``` | |
| ### Comprendre la structure | |
| Le dictionnaire `params` définit la manière dont chaque élément d'interface utilisateur est rendu. Les listes `input_names`, `model_input_names` et `output_names` associent ces éléments d'interface à l'interface d'entrée/sortie des [ModularPipelineBlocks](/docs/diffusers/main/fr/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks) sous-jacents : | |
| | Configuration de Mellon | ModularPipelineBlocks | | |
| |---------------|----------------------| | |
| | `input_names` | propriété `inputs` | | |
| | `model_input_names` | propriété `expected_components` | | |
| | `output_names` | propriété `intermediate_outputs` | | |
| Dans cet exemple : `prompt` est la seule entrée. Il n'y a aucun composant de modèle, et les sorties incluent `out_prompt`, `old_prompt` et `doc`. | |
| Examinons maintenant le dictionnaire `params` : | |
| - **`prompt`** : un paramètre d’entrée avec `display: "textarea"` (affiché comme une zone de texte), `label: "Prompt"` (affiché dans l’interface utilisateur) et `default: ""` (commence vide). Le champ `type: "string"` est important dans Mellon car il détermine quels nœuds peuvent être connectés entre eux – seuls les types correspondants peuvent être reliés par des « noodles ». | |
| - **`out_prompt`** : La sortie du prompt développé. Le préfixe `out_` a été ajouté automatiquement car l’entrée et la sortie partagent le même nom (`prompt`), ce qui évite les conflits de noms dans la configuration. Il possède `display: "output"`, ce qui le rend sous forme de prise de sortie. | |
| - **`old_prompt`** : possède `type: "custom"` car nous n'avons pas spécifié de métadonnées. Cela s'affiche sous forme d'un simple point dans l'interface. Comme nous ne souhaitons pas réellement l'exposer dans l'interface, nous pouvons le supprimer. | |
| - **`doc`** : la sortie de la documentation, ajoutée automatiquement à tous les blocs personnalisés. | |
| ### Apporter des ajustements | |
| Supprimez `old_prompt` des deux listes `params` et `output_names`, car vous n'aurez pas besoin de l'utiliser. | |
| ```json | |
| { | |
| "label": "Gemini Prompt Expander", | |
| "default_repo": "", | |
| "default_dtype": "", | |
| "node_params": { | |
| "custom": { | |
| "params": { | |
| "prompt": { | |
| "label": "Prompt", | |
| "type": "string", | |
| "display": "textarea", | |
| "default": "" | |
| }, | |
| "out_prompt": { | |
| "label": "Prompt", | |
| "type": "string", | |
| "display": "output" | |
| }, | |
| "doc": { | |
| "label": "Doc", | |
| "type": "string", | |
| "display": "output" | |
| } | |
| }, | |
| "input_names": ["prompt"], | |
| "model_input_names": [], | |
| "output_names": ["out_prompt", "doc"], | |
| "block_name": "custom", | |
| "node_type": "custom" | |
| } | |
| } | |
| } | |
| ``` | |
| Voir la configuration finale dans [diffusers/gemini-prompt-expander-mellon](https://huggingface.co/diffusers/gemini-prompt-expander-mellon). | |
Xet Storage Details
- Size:
- 11.8 kB
- Xet hash:
- 24d09ac0372a493a8313284de685c2902fe620bdd09d246330e1459058c2e3bd
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.