Buckets:
| # ModularPipelineBlocks | |
| [ModularPipelineBlocks](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks) est le bloc de base pour construire un [ModularPipeline](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline#diffusers.ModularPipeline). Il définit les composants, les entrées/sorties et le calcul qu'un bloc doit effectuer pour une étape spécifique d'un pipeline. Un [ModularPipelineBlocks](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks) se connecte à d'autres blocs, en utilisant l'[state](./modular_diffusers_states), pour permettre la construction modulaire de workflows. | |
| Un [ModularPipelineBlocks](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks) seul ne peut pas être exécuté. Il s'agit d'un plan de ce qu'une étape doit faire dans un pipeline. Pour exécuter réellement un pipeline, les [ModularPipelineBlocks](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks) doivent être convertis en [ModularPipeline](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline#diffusers.ModularPipeline). | |
| Ce guide vous montre comment créer un [ModularPipelineBlocks](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks). | |
| ## Entrées et sorties | |
| > [!TIP] | |
| > Consultez le guide [States](./modular_diffusers_states) si vous n'êtes pas familier avec le fonctionnement de l'état dans Modular Diffusers. | |
| Un [ModularPipelineBlocks](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks) nécessite `inputs` et `intermediate_outputs`. | |
| - `inputs` sont les valeurs qu'un bloc lit depuis l'[PipelineState](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_states#diffusers.modular_pipelines.PipelineState) pour effectuer son calcul. Il peut s'agir de valeurs fournies par un utilisateur (comme un prompt ou une image) ou de valeurs produites par un bloc précédent (comme les `image_latents` encodés). | |
| Utilisez `InputParam` pour définir les `inputs`. | |
| ```py | |
| class ImageEncodeStep(ModularPipelineBlocks): | |
| ... | |
| @property | |
| def inputs(self): | |
| return [ | |
| InputParam(name="image", type_hint="PIL.Image", required=True, description="raw input image to process"), | |
| ] | |
| ... | |
| ``` | |
| - `intermediate_outputs` sont de nouvelles valeurs créées par un bloc et ajoutées à l'[PipelineState](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_states#diffusers.modular_pipelines.PipelineState). Les `intermediate_outputs` sont disponibles en tant que `inputs` pour les blocs suivants ou en tant que sortie finale de l'exécution du pipeline. | |
| Utilisez `OutputParam` pour définir `intermediate_outputs`. | |
| ```py | |
| class ImageEncodeStep(ModularPipelineBlocks): | |
| ... | |
| @property | |
| def intermediate_outputs(self): | |
| return [ | |
| OutputParam(name="image_latents", description="latents representing the image"), | |
| ] | |
| ... | |
| ``` | |
| Les entrées et sorties intermédiaires partagent des données pour connecter les blocs. Elles sont accessibles à tout moment, ce qui vous permet de suivre l'avancement du flux de travail. | |
| ## Composants et configurations | |
| Les composants et les configurations au niveau du pipeline dont un bloc a besoin sont spécifiés dans [ComponentSpec](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_components#diffusers.ComponentSpec) et [ConfigSpec](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_components#diffusers.ConfigSpec). | |
| - [ComponentSpec](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_components#diffusers.ComponentSpec) contient les composants attendus utilisés par un bloc. Vous avez besoin du `name` du composant et, idéalement, d'un `type_hint` qui précise exactement ce qu'est le composant. | |
| - [ConfigSpec](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_components#diffusers.ConfigSpec) contient les paramètres au niveau du pipeline qui contrôlent le comportement de tous les blocs. | |
| ```py | |
| class ImageEncodeStep(ModularPipelineBlocks): | |
| ... | |
| @property | |
| def expected_components(self): | |
| return [ | |
| ComponentSpec(name="vae", type_hint=AutoencoderKL), | |
| ] | |
| @property | |
| def expected_configs(self): | |
| return [ | |
| ConfigSpec("force_zeros_for_empty_prompt", True), | |
| ] | |
| ... | |
| ``` | |
| Lorsque les blocs sont convertis en pipeline, les composants deviennent disponibles pour le bloc en tant que premier argument de `__call__`. | |
| ## Logique de calcul | |
| Le calcul effectué par un bloc est défini dans la méthode `__call__` et suit une structure spécifique. | |
| 1. Récupérez le [BlockState](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_states#diffusers.modular_pipelines.BlockState) pour obtenir une vue locale des `inputs`. | |
| 2. Implémentez la logique de calcul sur les `inputs`. | |
| 3. Mettre à jour [PipelineState](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_states#diffusers.modular_pipelines.PipelineState) pour propager les modifications de l'[BlockState](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_states#diffusers.modular_pipelines.BlockState) local vers l'[PipelineState](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_states#diffusers.modular_pipelines.PipelineState) global. | |
| 4. Retourne les composants et l'état qui deviennent disponibles pour le bloc suivant. | |
| ```py | |
| class ImageEncodeStep(ModularPipelineBlocks): | |
| def __call__(self, components, state): | |
| # Get a local view of the state variables this block needs | |
| block_state = self.get_block_state(state) | |
| # Your computation logic here | |
| # block_state contains all your inputs | |
| # Access them like: block_state.image, block_state.processed_image | |
| # Update the pipeline state with your updated block_states | |
| self.set_block_state(state, block_state) | |
| return components, state | |
| ``` | |
| ## Tout mettre ensemble | |
| Voici le bloc complet avec toutes les pièces connectées. | |
| ```py | |
| from diffusers import ComponentSpec, AutoencoderKL | |
| from diffusers.modular_pipelines import InputParam, ModularPipelineBlocks, OutputParam | |
| class ImageEncodeStep(ModularPipelineBlocks): | |
| @property | |
| def description(self): | |
| return "Encode an image into latent space." | |
| @property | |
| def expected_components(self): | |
| return [ | |
| ComponentSpec(name="vae", type_hint=AutoencoderKL), | |
| ] | |
| @property | |
| def inputs(self): | |
| return [ | |
| InputParam(name="image", type_hint="PIL.Image", required=True, description="raw input image to process"), | |
| ] | |
| @property | |
| def intermediate_outputs(self): | |
| return [ | |
| OutputParam(name="image_latents", type_hint="torch.Tensor", description="latents representing the image"), | |
| ] | |
| def __call__(self, components, state): | |
| block_state = self.get_block_state(state) | |
| block_state.image_latents = components.vae.encode(block_state.image) | |
| self.set_block_state(state, block_state) | |
| return components, state | |
| ``` | |
| Chaque bloc possède une propriété `doc` générée automatiquement à partir des propriétés définies ci-dessus. Elle fournit un résumé de la description du bloc, de ses composants, de ses entrées et de ses sorties. | |
| ```py | |
| block = ImageEncoderStep() | |
| print(block.doc) | |
| class ImageEncodeStep | |
| Encode an image into latent space. | |
| Components: | |
| vae (`AutoencoderKL`) | |
| Inputs: | |
| image (`PIL.Image`): | |
| raw input image to process | |
| Outputs: | |
| image_latents (`torch.Tensor`): | |
| latents representing the image | |
| ``` | |
Xet Storage Details
- Size:
- 7.74 kB
- Xet hash:
- 1e9fa1a01135b95bf7d299ea4093d2aacb79585f7f3da6a8f0f4cd8e9c635e24
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.