Buckets:

mishig's picture
|
download
raw
14.1 kB
# Pipeline
## ModularPipeline[[diffusers.ModularPipeline]]
#### diffusers.ModularPipeline[[diffusers.ModularPipeline]]
```python
diffusers.ModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L1700)
**Parâmetros:**
blocks : ModularPipelineBlocks, os blocos a serem usados no pipeline
Classe base para todos os pipelines Modulares.
#### from_pretrained[[diffusers.ModularPipeline.from_pretrained]]
```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike | None, trust_remote_code: bool | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L1925)
**Parâmetros:**
pretrained_model_name_or_path (`str` ou `os.PathLike`, opcional) : Caminho para uma configuração de pipeline pré-treinada. Primeiro, tentará carregar a configuração de `modular_model_index.json` e, em seguida, usará `model_index.json` como alternativa para compatibilidade com repositórios padrão não modulares. Se pretrained_model_name_or_path não contiver nenhuma configuração de pipeline, será definido como None durante a inicialização.
trust_remote_code (`bool`, opcional) : Se deve confiar em código remoto ao carregar o pipeline. Precisa ser definido como True se você quiser criar blocos de pipeline com base no código personalizado em `pretrained_model_name_or_path`
components_manager (`ComponentsManager`, opcional) : Instância de ComponentsManager para gerenciar múltiplos componentes em diferentes pipelines e aplicar estratégias de offloading.
collection (`str`, opcional) --` Nome da coleção para organizar os componentes no ComponentsManager.
workflow (`str`, opcional) : Nome de um workflow declarado pelos blocos do pipeline. Se fornecido, os blocos são podados para os blocos de execução daquele workflow, de modo que o pipeline espera apenas — e `load_components()` carrega apenas — os componentes que o workflow utiliza.
Carregue um ModularPipeline de um repositório do huggingface hub.
#### get_component_spec[[diffusers.ModularPipeline.get_component_spec]]
```python
get_component_spec(name: str)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L2401)
**Retorna:**
- uma cópia do objeto ComponentSpec para o nome de componente fornecido
#### load_components[[diffusers.ModularPipeline.load_components]]
```python
load_components(names: list[str] | str | None = None, workflow: str | None = None, **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L2489)
**Parâmetros:**
names : lista de nomes de componentes a serem carregados. Se for None, todos os componentes com default_creation_method == "from_pretrained" serão carregados. Se fornecido como uma lista ou string, apenas os componentes especificados serão carregados.
workflow : nome de um workflow declarado pelos blocos de pipeline. Se fornecido, apenas os componentes usados pelos blocos de execução desse workflow são carregados. Não pode ser combinado com `names`.
- ****kwargs** : kwargs adicionais a serem passados para `from_pretrained()`. Pode ser: - um único valor a ser aplicado a todos os componentes a serem carregados, por exemplo, dtype=torch.bfloat16 - um dict, por exemplo, dtype={"unet": torch.bfloat16, "default": torch.float32} - se potencialmente sobrescrever ComponentSpec se um campo de carregamento diferente for passado em kwargs, por exemplo, `pretrained_model_name_or_path`, `variant`, `revision`, etc. - se potencialmente sobrescrever ComponentSpec se um campo de carregamento diferente for passado em kwargs, por exemplo, `pretrained_model_name_or_path`, `variant`, `revision`, etc.
Carregue os componentes selecionados a partir das especificações.
#### register_components[[diffusers.ModularPipeline.register_components]]
```python
register_components(**kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L2186)
**Parâmetros:**
- ****kwargs** : Argumentos de palavra-chave em que as chaves são os nomes dos componentes e os valores são os objetos dos componentes. Por exemplo, register_components(unet=unet_model, text_encoder=encoder_model)
Registre os componentes com suas especificações correspondentes.
Este método é responsável por:
1. Define os objetos de componentes como atributos no loader (por exemplo, self.unet = unet)
2. Atualiza o dicionário de configuração, que será salvo como `modular_model_index.json` durante `save_pretrained` (apenas para componentes de from_pretrained)
3. Adiciona componentes ao gerenciador de componentes, se um estiver anexado (apenas para componentes de from_pretrained)
Este método é chamado quando:
- Os componentes são inicializados pela primeira vez em __init__:
- componentes de from_pretrained não carregados durante __init__, portanto registrados como None;
- componentes não de from_pretrained são criados durante __init__ e registrados como o próprio objeto
- Os componentes são atualizados com o método `update_components()`: por exemplo, loader.update_components(unet=unet) ou loader.update_components(guider=guider_spec)
- (from_pretrained) Os componentes são carregados com o método `load_components()`: por exemplo, loader.load_components(names=["unet"]) ou loader.load_components() para carregar todos os componentes padrão
Observações:
- Ao registrar None para um componente, o atributo é definido como None, mas as especificações ainda são sincronizadas com o dicionário de configuração, que será salvo como `modular_model_index.json` durante `save_pretrained`
- component_specs são atualizados para corresponder ao novo componente fora deste método, por exemplo, no método `update_components()`
#### save_pretrained[[diffusers.ModularPipeline.save_pretrained]]
```python
save_pretrained(save_directory: str | os.PathLike, safe_serialization: bool = True, variant: str | None = None, max_shard_size: int | str | None = None, push_to_hub: bool = False, **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L2026)
**Parâmetros:**
save_directory (`str` ou `os.PathLike`) : Diretório para salvar o pipeline. Será criado se não existir.
safe_serialization (`bool`, *opcional*, padrão `True`) : Se o modelo deve ser salvo usando `safetensors` ou da maneira tradicional do PyTorch com `pickle`.
variant (`str`, *opcional*) : Se especificado, os pesos são salvos no formato `pytorch_model.<variant>.bin`.
max_shard_size (`int` ou `str`, padrão `None`) : O tamanho máximo de um checkpoint antes de ser fragmentado. Os fragmentos do checkpoint terão, então, cada um um tamanho menor que esse valor. Se expresso como uma string, deve ser composto por dígitos seguidos por uma unidade (como `"5GB"`). Se expresso como um inteiro, a unidade é bytes.
push_to_hub (`bool`, *opcional*, padrão `False`) : Se deve enviar o pipeline para o hub de modelos do Hugging Face após salvá-lo.
- ****kwargs** : Argumentos de palavra-chave adicionais: - `overwrite_modular_index` (`bool`, *opcional*, padrão `True`): Se deve atualizar `modular_model_index.json` para que a especificação de carregamento de cada componente salvo aponte para o destino: `repo_id` ao enviar para o Hub, caso contrário `save_directory`. Componentes que não são carregados não são salvos e sempre mantêm suas especificações de carregamento registradas. Passe `False` para também preservar as especificações registradas dos componentes que estão sendo salvos (por exemplo, para um índice que referencia intencionalmente outros repositórios); componentes sem um ID de carregamento (como modelos personalizados adicionados com `update_components`) ainda são reescritos, pois não possuem uma fonte registrada. - `repo_id` (`str`, *opcional*): O ID do repositório para o qual a pipeline será enviada. Padrão é o último componente de `save_directory`. - `commit_message` (`str`, *opcional*): Mensagem de commit para a operação de envio ao Hub. - `private` (`bool`, *opcional*): Se o repositório deve ser privado. - `create_pr` (`bool`, *opcional*, padrão `False`): Se deve criar um pull request em vez de enviar diretamente. - `token` (`str`, *opcional*): O token do Hugging Face a ser usado para autenticação.
Salve o pipeline e todos os seus componentes em um diretório, para que ele possa ser recarregado usando o método de classe [from_pretrained()](/docs/diffusers/v0.43.0/pt/api/modular_diffusers/pipeline#diffusers.ModularPipeline.from_pretrained).
#### para[[diffusers.ModularPipeline.to]]
```python
to(*args, **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L2651)
**Parâmetros:**
dtype (`torch.dtype`, *opcional*) : Retorna um pipeline com o [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) especificado
device (`torch.Device`, *opcional*) : Retorna um pipeline com o [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) especificado
silence_dtype_warnings (`str`, *opcional*, padrão `False`) : Se deve omitir avisos quando o `dtype` de destino não é compatível com o `device` de destino.
**Retorna:** [DiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline)
O pipeline foi convertido para o `dtype` e/ou `dtype` especificado.
Executa a conversão de dtype e/ou device do Pipeline. Um torch.dtype e um torch.device são inferidos a partir dos argumentos de `self.to(*args, **kwargs).`
> [!TIP] > Se o pipeline já possui o torch.dtype e o torch.device corretos, ele é retornado como está.
Caso contrário, > o pipeline retornado é uma cópia de self com o torch.dtype e o torch.device desejados.
Aqui estão as formas de chamar `to`:
- `to(dtype, silence_dtype_warnings=False) → DiffusionPipeline` para retornar um pipeline com o [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) especificado
- `to(device, silence_dtype_warnings=False) → DiffusionPipeline` para retornar um pipeline com o [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) especificado
- `to(device=None, dtype=None, silence_dtype_warnings=False) → DiffusionPipeline` para retornar um pipeline com o [`device`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device) e o [`dtype`](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) especificados
#### unload_components[[diffusers.ModularPipeline.unload_components]]
```python
unload_components(names: list[str] | str)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L2595)
**Parâmetros:**
names : nome do componente ou lista de nomes de componentes para descarregar.
Descarregue os componentes selecionados, liberando sua memória.
O atributo component é definido novamente como `None` e, se um ComponentsManager estiver anexado, o componente é removido dele. A especificação do componente permanece intacta, portanto, o componente pode ser carregado novamente mais tarde com `load_components()`.
#### update_components[[diffusers.ModularPipeline.update_components]]
```python
update_components(**kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/modular_pipeline.py#L2408)
**Parâmetros:**
- ****kwargs** : Objetos de componentes ou valores de configuração para atualizar: - Objetos de componentes: Modelos carregados com `AutoModel.from_pretrained()` ou `ComponentSpec.load()` são automaticamente marcados com informações de carregamento. Objetos ConfigMixin sem pesos (por exemplo, agendadores, guias) podem ser passados diretamente. - Valores de configuração: Valores simples para atualizar configurações (por exemplo, `requires_safety_checker=False`)
Atualize os componentes e os valores e especificações de configuração após a instância do pipeline ter sido criada.
Este método permite que você:
1. Substitua os componentes existentes por novos (por exemplo, atualizando `self.unet` ou `self.text_encoder`)
2. Atualize os valores de configuração (por exemplo, alterando a flag `self.requires_safety_checker`)
Além de atualizar os componentes e os valores de configuração como atributos do pipeline, o método também atualiza:
- as especificações correspondentes em `_component_specs` e `_config_specs`
- o dicionário `config`, que será salvo como `modular_model_index.json` durante o `save_pretrained`
Exemplos:
```python
# Update pre-trained model
pipeline.update_components(unet=new_unet_model, text_encoder=new_text_encoder)
# Update configuration values
pipeline.update_components(requires_safety_checker=False)
```
Observações:
- Os componentes carregados com `AutoModel.from_pretrained()` ou `ComponentSpec.load()` terão
especificações carregadas preservadas para serialização. Componentes personalizados ou carregados localmente sem referências do Hub terão suas entradas em `modular_model_index.json` atualizadas automaticamente durante `save_pretrained()`.
- Objetos ConfigMixin sem pesos (por exemplo, agendadores, guias) podem ser passados diretamente.

Xet Storage Details

Size:
14.1 kB
·
Xet hash:
6f166f59e07045d4cafeb94bafbc79da260417f1e5f2efcfcc8151ed5bdc90d1

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.