Diffusers documentation
SequentialPipelineBlocks
SequentialPipelineBlocks
SequentialPipelineBlocks est un type multi-blocs qui compose d'autres ModularPipelineBlocks en séquence. Les données circulent linéairement d'un bloc à l'autre à l'aide de inputs et intermediate_outputs. Chaque bloc de SequentialPipelineBlocks représente généralement une étape du pipeline, et en les combinant, vous construisez progressivement un pipeline.
Ce guide vous montre comment connecter deux blocs dans un SequentialPipelineBlocks.
Créez deux ModularPipelineBlocks. Le premier bloc, InputBlock, renvoie une valeur batch_size et le second bloc, ImageEncoderBlock, utilise batch_size comme inputs.
from diffusers.modular_pipelines import ModularPipelineBlocks, InputParam, OutputParam
class InputBlock(ModularPipelineBlocks):
@property
def inputs(self):
return [
InputParam(name="prompt", type_hint=list, description="list of text prompts"),
InputParam(name="num_images_per_prompt", type_hint=int, description="number of images per prompt"),
]
@property
def intermediate_outputs(self):
return [
OutputParam(name="batch_size", description="calculated batch size"),
]
@property
def description(self):
return "A block that determines batch_size based on the number of prompts and num_images_per_prompt argument."
def __call__(self, components, state):
block_state = self.get_block_state(state)
batch_size = len(block_state.prompt)
block_state.batch_size = batch_size * block_state.num_images_per_prompt
self.set_block_state(state, block_state)
return components, stateimport torch
from diffusers.modular_pipelines import ModularPipelineBlocks, InputParam, OutputParam
class ImageEncoderBlock(ModularPipelineBlocks):
@property
def inputs(self):
return [
InputParam(name="image", type_hint="PIL.Image", description="raw input image to process"),
InputParam(name="batch_size", type_hint=int),
]
@property
def intermediate_outputs(self):
return [
OutputParam(name="image_latents", description="latents representing the image"),
]
@property
def description(self):
return "Encode raw image into its latent presentation"
def __call__(self, components, state):
block_state = self.get_block_state(state)
# Simulate processing the image
# This will change the state of the image from a PIL image to a tensor for all blocks
block_state.image = torch.randn(1, 3, 512, 512)
block_state.batch_size = block_state.batch_size * 2
block_state.image_latents = torch.randn(1, 4, 64, 64)
self.set_block_state(state, block_state)
return components, stateConnectez les deux blocs en définissant un SequentialPipelineBlocks. Listez les instances de blocs dans block_classes et leurs noms correspondants dans block_names. Les blocs sont exécutés dans l'ordre où ils apparaissent dans block_classes, et les données circulent d'un bloc à l'autre via PipelineState.
class ImageProcessingStep(SequentialPipelineBlocks):
"""
# auto_docstring
"""
model_name = "my_model"
block_classes = [InputBlock(), ImageEncoderBlock()]
block_names = ["input", "image_encoder"]
@property
def description(self):
return (
"Process text prompts and images for the pipeline. It:\n"
" - Determines the batch size from the prompts.\n"
" - Encodes the image into latent space."
)Lors de la création d'un SequentialPipelineBlocks, les propriétés telles que inputs, intermediate_outputs et expected_components sont automatiquement agrégées à partir des sous-blocs, il n'est donc pas nécessaire de les redéfinir.
Voici quelques propriétés que vous devez définir :
description: Nous recommandons d'ajouter une description pour le bloc assemblé afin d'expliquer ce que fait l'étape combinée.model_name: Ce nom est dérivé automatiquement des sous-blocs, mais il n’est pas toujours correct, il peut donc être nécessaire de le remplacer.outputs: par défaut, c'est la même chose queintermediate_outputs, mais vous pouvez le définir manuellement pour contrôler les valeurs affichées dans la documentation. C'est utile pour n'afficher que les sorties finales plutôt que toutes les valeurs intermédiaires.
Ces propriétés, ainsi que les inputs, intermediate_outputs et expected_components agrégés, sont utilisées pour générer automatiquement la propriété doc.
Affichez le bloc ImageProcessingStep pour inspecter ses sous-blocs, et utilisez doc pour un résumé complet des entrées, des sorties et des composants du bloc.
blocks = ImageProcessingStep()
print(blocks)
print(blocks.doc)