Buckets:
| # Blocos de pipeline | |
| ## ModularPipelineBlocks[[diffusers.ModularPipelineBlocks]] | |
| #### diffusers.ModularPipelineBlocks[[diffusers.ModularPipelineBlocks]] | |
| ```python | |
| diffusers.ModularPipelineBlocks() | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline.py#L392) | |
| Classe base para todos os Blocos de Pipeline: ConditionalPipelineBlocks, AutoPipelineBlocks, SequentialPipelineBlocks, LoopSequentialPipelineBlocks | |
| [ModularPipelineBlocks](/docs/diffusers/main/pt/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks) fornece método para carregar e salvar a definição de blocos de pipeline. | |
| #### get_block_state[[diffusers.ModularPipelineBlocks.get_block_state]] | |
| ```python | |
| get_block_state(state: PipelineState) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline.py#L590) | |
| Obtenha todas as entradas e intermediários em um único dicionário | |
| #### get_execution_blocks[[diffusers.ModularPipelineBlocks.get_execution_blocks]] | |
| ```python | |
| get_execution_blocks(**kwargs) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline.py#L461) | |
| **Parâmetros:** | |
| - ****kwargs** : Nomes e valores de entrada. Somente as entradas de gatilho afetam a seleção de blocos. | |
| Obtém o(s) bloco(s) que seriam executados com base nas entradas. Deve ser implementado por subclasses que suportam seleção condicional de blocos. | |
| #### get_workflow[[diffusers.ModularPipelineBlocks.get_workflow]] | |
| ```python | |
| get_workflow(workflow_name: str) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline.py#L479) | |
| **Parâmetros:** | |
| workflow_name : Nome do workflow a ser recuperado. | |
| Obtenha os blocos de execução para um workflow específico. Deve ser implementado por subclasses que definem `_workflow_map`. | |
| #### init_pipeline[[diffusers.ModularPipelineBlocks.init_pipeline]] | |
| ```python | |
| init_pipeline(pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline.py#L568) | |
| crie um ModularPipeline, aceitando opcionalmente pretrained_model_name_or_path para carregar do hub. | |
| ## SequentialPipelineBlocks[[diffusers.SequentialPipelineBlocks]] | |
| #### diffusers.SequentialPipelineBlocks[[diffusers.SequentialPipelineBlocks]] | |
| ```python | |
| diffusers.SequentialPipelineBlocks() | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline.py#L1044) | |
| **Parâmetros:** | |
| block_classes : lista de classes de bloco a serem usadas | |
| block_names : lista de prefixos para cada bloco | |
| Um Pipeline Blocks que combina várias classes de bloco de pipeline em uma única. Quando chamado, ele chamará cada bloco em sequência. | |
| Esta classe herda de [ModularPipelineBlocks](/docs/diffusers/main/pt/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os blocos de pipeline (como carregamento ou salvamento, etc.) | |
| #### from_blocks_dict[[diffusers.SequentialPipelineBlocks.from_blocks_dict]] | |
| ```python | |
| from_blocks_dict(blocks_dict: dict[str, typing.Any], description: str | None = None) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline.py#L1116) | |
| **Parâmetros:** | |
| blocks_dict : Dicionário que mapeia nomes de blocos para classes ou instâncias de blocos | |
| **Retorna:** | |
| Uma nova instância de SequentialPipelineBlocks | |
| Cria uma instância de SequentialPipelineBlocks a partir de um dicionário de blocos. | |
| #### get_execution_blocks[[diffusers.SequentialPipelineBlocks.get_execution_blocks]] | |
| ```python | |
| get_execution_blocks(**kwargs) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline.py#L1259) | |
| **Parâmetros:** | |
| - ****kwargs** : Nomes e valores de entrada. Somente as entradas de gatilho afetam a seleção de blocos. | |
| **Retorna:** | |
| SequentialPipelineBlocks contendo apenas os blocos que seriam executados | |
| Obtenha os blocos que seriam executados com as entradas especificadas. | |
| À medida que a varredura percorre os blocos sequenciais, as saídas intermediárias dos blocos resolvidos são adicionadas às entradas ativas. Isso significa que blocos condicionais que dependem de intermediários (por exemplo, "executar img2img se image_latents estiver presente") serão resolvidos corretamente, desde que a condição seja baseada na presença/ausência (None ou não None), e não no valor real. | |
| ## LoopSequentialPipelineBlocks[[diffusers.LoopSequentialPipelineBlocks]] | |
| #### diffusers.LoopSequentialPipelineBlocks[[diffusers.LoopSequentialPipelineBlocks]] | |
| ```python | |
| diffusers.LoopSequentialPipelineBlocks() | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline.py#L1404) | |
| **Parâmetros:** | |
| block_classes : lista de classes de bloco a serem usadas | |
| block_names : lista de prefixos para cada bloco | |
| Um bloco Pipeline que combina várias classes de bloco de pipeline em um For Loop. Quando chamado, ele chamará cada bloco em sequência. | |
| Esta classe herda de [ModularPipelineBlocks](/docs/diffusers/main/pt/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os blocos de pipeline (como carregamento ou salvamento, etc.) | |
| #### from_blocks_dict[[diffusers.LoopSequentialPipelineBlocks.from_blocks_dict]] | |
| ```python | |
| from_blocks_dict(blocks_dict: dict[str, typing.Any]) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline.py#L1565) | |
| **Parâmetros:** | |
| blocks_dict : Dicionário que mapeia nomes de blocos para instâncias de blocos | |
| **Retorna:** | |
| Uma nova instância de LoopSequentialPipelineBlocks | |
| Cria uma instância de LoopSequentialPipelineBlocks a partir de um dicionário de blocos. | |
| ## AutoPipelineBlocks[[diffusers.AutoPipelineBlocks]] | |
| #### diffusers.AutoPipelineBlocks[[diffusers.AutoPipelineBlocks]] | |
| ```python | |
| diffusers.AutoPipelineBlocks() | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline.py#L983) | |
| **Parâmetros:** | |
| block_classes : Lista de classes de bloco a serem usadas. Deve ter o mesmo comprimento que `block_names` e `block_trigger_inputs`. | |
| block_names : Lista de nomes para cada bloco. Deve ter o mesmo comprimento que `block_classes` e `block_trigger_inputs`. | |
| block_trigger_inputs : Lista de nomes de entrada em que cada elemento especifica a entrada de gatilho para o bloco correspondente. Use `None` para marcar o bloco padrão. | |
| Blocos de Pipeline que selecionam automaticamente um bloco para executar com base na presença de entradas de gatilho. | |
| Esta é uma versão especializada de `ConditionalPipelineBlocks` em que: | |
| - Cada bloco possui uma entrada de gatilho correspondente (mapeamento 1:1) | |
| - A seleção de bloco é automática: o primeiro bloco cuja entrada de gatilho está presente é selecionado | |
| - `block_trigger_inputs` deve ter o mesmo comprimento que `block_names` e `block_classes` | |
| - Use `None` em `block_trigger_inputs` para especificar o bloco padrão, ou seja, o bloco que será executado se não houver entradas de gatilho | |
| Exemplo: | |
| ```python | |
| class MyAutoBlock(AutoPipelineBlocks): | |
| block_classes = [InpaintEncoderBlock, ImageEncoderBlock, TextEncoderBlock] | |
| block_names = ["inpaint", "img2img", "text2img"] | |
| block_trigger_inputs = ["mask_image", "image", None] # text2img is the default | |
| ``` | |
| Com essa definição: | |
| - Desde que `mask_image` seja fornecido, o bloco "inpaint" é executado (independentemente de `image` ser fornecido ou não) | |
| - Se `mask_image` não for fornecido, mas `image` for fornecido, o bloco "img2img" será executado | |
| - Caso contrário, o bloco "text2img" é executado (padrão, o gatilho é `None`) | |
| #### select_block[[diffusers.AutoPipelineBlocks.select_block]] | |
| ```python | |
| select_block(**kwargs) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline.py#L1036) | |
| Selecione o bloco com base em qual entrada de gatilho está presente (não é None). | |
| ## ConditionalPipelineBlocks[[diffusers.ConditionalPipelineBlocks]] | |
| #### diffusers.ConditionalPipelineBlocks[[diffusers.ConditionalPipelineBlocks]] | |
| ```python | |
| diffusers.ConditionalPipelineBlocks() | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline.py#L684) | |
| **Parâmetros:** | |
| block_classes : Lista de classes de bloco a serem usadas. Deve ter o mesmo comprimento que `block_names`. | |
| block_names : Lista de nomes para cada bloco. Deve ter o mesmo comprimento que `block_classes`. | |
| block_trigger_inputs : Lista de nomes de entrada que `select_block()` usa para determinar qual bloco executar. Para `ConditionalPipelineBlocks`, isso não precisa corresponder a `block_names` e `block_classes`. Para `AutoPipelineBlocks`, isso deve ter o mesmo comprimento que `block_names` e `block_classes`, onde cada elemento especifica a entrada de gatilho para o bloco correspondente. | |
| default_block_name : Nome do bloco padrão a ser executado quando nenhuma entrada de gatilho corresponde. Se for None, este bloco pode ser totalmente ignorado quando nenhuma entrada de gatilho for fornecida. | |
| Um Pipeline Blocks que seleciona condicionalmente um bloco para execução com base nas entradas. As subclasses devem implementar o método `select_block` para definir a lógica de seleção do bloco. Atualmente, suportamos apenas lógica de seleção baseada na presença ou ausência de entradas (ou seja, se são `None` ou não). | |
| Esta classe herda de [ModularPipelineBlocks](/docs/diffusers/main/pt/api/modular_diffusers/pipeline_blocks#diffusers.ModularPipelineBlocks). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os blocos de pipeline (como carregamento ou salvamento, etc.) | |
| #### get_execution_blocks[[diffusers.ConditionalPipelineBlocks.get_execution_blocks]] | |
| ```python | |
| get_execution_blocks(**kwargs) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline.py#L874) | |
| **Parâmetros:** | |
| - ****kwargs** : Nomes e valores de entrada. Somente as entradas de gatilho afetam a seleção de blocos. | |
| **Retorna:** - `ModularPipelineBlocks` | |
| Um bloco folha ou `SequentialPipelineBlocks` resolvido | |
| - `None`: Se esse bloco fosse ignorado (nenhum gatilho correspondente e nenhum padrão) | |
| Obtenha o(s) bloco(s) que seriam executados com as entradas fornecidas. | |
| Resolve recursivamente blocos aninhados de ConditionalPipelineBlocks até atingir: | |
| - Um bloco folha (sem sub_blocks ou LoopSequentialPipelineBlocks) → retorna um único `ModularPipelineBlocks` | |
| - A `SequentialPipelineBlocks` → delega para o seu `get_execution_blocks()`, que retorna | |
| a `SequentialPipelineBlocks` contendo os blocos de execução resolvidos | |
| #### select_block[[diffusers.ConditionalPipelineBlocks.select_block]] | |
| ```python | |
| select_block(**kwargs) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline.py#L830) | |
| **Parâmetros:** | |
| - ****kwargs** : Nomes e valores de entrada do gatilho a partir do estado. | |
| **Retorna:** `str | None` | |
| O nome do bloco a ser executado, ou None para usar o padrão/pular. | |
| Selecione o bloco a ser executado com base nas entradas do gatilho. As subclasses devem implementar este método para definir a lógica de seleção do bloco. | |
| Nota: Quando as entradas de gatilho incluem saídas intermediárias de blocos anteriores, a lógica de seleção deve depender apenas da presença ou ausência da entrada (ou seja, se ela é None ou não), e não do seu valor real. Isso ocorre porque `get_execution_blocks()` resolve as condições estaticamente, propagando os nomes das saídas intermediárias sem seus valores em tempo de execução. | |
Xet Storage Details
- Size:
- 12.3 kB
- Xet hash:
- a4458877b5a29ea4b923460b0ab48caa5253a8a52e7ce224b9cf4bd0809dab8b
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.