Buckets:
| # 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.