Hugging Face's logo

Buckets:
hf-doc-build
/
doc

Files
xet
hf-doc-build/doc / diffusers /v0.43.0 /pt /api /cache.md
mishig's picture
mishig
preview code
|
download
raw
33.5 kB
# Métodos de cache
Os métodos de cache aceleram os difusão transformers armazenando e reutilizando saídas intermediárias de camadas específicas, como as camadas de atenção e feedforward, em vez de recalculá-las a cada etapa de inferência.
## CacheMixin[[diffusers.CacheMixin]]
#### diffusers.CacheMixin[[diffusers.CacheMixin]]
```python
diffusers.CacheMixin()
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/cache_utils.py#L23)
Uma classe para habilitar/desabilitar técnicas de cache em modelos de difusão.
Técnicas de cache suportadas:
- [Pyramid Attention Broadcast](https://huggingface.co/papers/2408.12588)
- [FasterCache](https://huggingface.co/papers/2410.19355)
- [FirstBlockCache](https://github.com/chengzeyi/ParaAttention/blob/7a266123671b55e7e5a2fe9af3121f07a36afc78/README.md#first-block-cache-our-dynamic-caching)
- [SeaCache](https://huggingface.co/papers/2602.18993)
#### cache_context[[diffusers.CacheMixin.cache_context]]
```python
cache_context(name: str, **kwargs)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/cache_utils.py#L181)
Gerenciador de contexto que fornece informações para o gerenciamento de cache.
`name` é o nome da chamada de desruidamento, geralmente `"cond"` ou `"uncond"`. Os argumentos de palavra-chave descrevem onde o loop de desruidamento está — veja `CacheContext` para os campos aceitos, por exemplo, `cache_context("cond", step_index=i, sigma=sigma)`.
#### enable_cache[[diffusers.CacheMixin.enable_cache]]
```python
enable_cache(config)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/cache_utils.py#L40)
**Parâmetros:**
config (`PyramidAttentionBroadcastConfig | FasterCacheConfig | FirstBlockCacheConfig | SeaCacheConfig | TextKVCacheConfig`) : A configuração para aplicar a técnica de cache. As técnicas de cache atualmente suportadas são: - [PyramidAttentionBroadcastConfig](/docs/diffusers/v0.43.0/pt/api/cache#diffusers.PyramidAttentionBroadcastConfig) - [FasterCacheConfig](/docs/diffusers/v0.43.0/pt/api/cache#diffusers.FasterCacheConfig) - [FirstBlockCacheConfig](/docs/diffusers/v0.43.0/pt/api/cache#diffusers.FirstBlockCacheConfig) - [SeaCacheConfig](/docs/diffusers/v0.43.0/pt/api/cache#diffusers.SeaCacheConfig) - `TextKVCacheConfig`
Ative técnicas de cache no modelo.
Exemplo:
```python
>>> import torch
>>> from diffusers import CogVideoXPipeline, PyramidAttentionBroadcastConfig
>>> pipe = CogVideoXPipeline.from_pretrained("THUDM/CogVideoX-5b", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> config = PyramidAttentionBroadcastConfig(
... spatial_attention_block_skip_range=2,
... spatial_attention_timestep_skip_range=(100, 800),
... current_timestep_callback=lambda: pipe.current_timestep,
... )
>>> pipe.transformer.enable_cache(config)
```
## PyramidAttentionBroadcastConfig[[diffusers.PyramidAttentionBroadcastConfig]]
#### diffusers.PyramidAttentionBroadcastConfig[[diffusers.PyramidAttentionBroadcastConfig]]
```python
diffusers.PyramidAttentionBroadcastConfig(spatial_attention_block_skip_range: int | None = None, temporal_attention_block_skip_range: int | None = None, cross_attention_block_skip_range: int | None = None, spatial_attention_timestep_skip_range: tuple[int, int] = (100, 800), temporal_attention_timestep_skip_range: tuple[int, int] = (100, 800), cross_attention_timestep_skip_range: tuple[int, int] = (100, 800), spatial_attention_block_identifiers: tuple[str, ...] = ('blocks', 'transformer_blocks', 'single_transformer_blocks', 'layers', 'visual_transformer_blocks'), temporal_attention_block_identifiers: tuple[str, ...] = ('temporal_transformer_blocks',), cross_attention_block_identifiers: tuple[str, ...] = ('blocks', 'transformer_blocks', 'layers'), current_timestep_callback: typing.Callable[[], int] = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/pyramid_attention_broadcast.py#L40)
**Parâmetros:**
spatial_attention_block_skip_range (`int`, *opcional*, padrão `None`) : O número de vezes que um broadcast específico de atenção espacial é ignorado antes de calcular os estados de atenção para reutilização. Se este valor for definido como `N`, o cálculo da atenção será ignorado `N - 1` vezes (ou seja, os estados de atenção antigos serão reutilizados) antes de calcular novamente os novos estados de atenção.
temporal_attention_block_skip_range (`int`, *opcional*, padrão `None`) : O número de vezes que um broadcast específico de atenção temporal é ignorado antes de calcular os estados de atenção para reutilização. Se este valor for definido como `N`, o cálculo da atenção será ignorado `N - 1` vezes (ou seja, os estados de atenção antigos serão reutilizados) antes de calcular novamente os novos estados de atenção.
cross_attention_block_skip_range (`int`, *opcional*, padrão `None`) : O número de vezes que um broadcast específico de cross-attention é ignorado antes de calcular os estados de atenção para reutilização. Se este valor for definido como `N`, o cálculo da atenção será ignorado `N - 1` vezes (ou seja, os estados de atenção antigos serão reutilizados) antes de calcular novamente os novos estados de atenção.
spatial_attention_timestep_skip_range (`tuple[int, int]`, padrão `(100, 800)`) : O intervalo de timesteps a serem ignorados na camada de atenção espacial. Os cálculos de atenção serão condicionalmente ignorados se o timestep atual estiver dentro do intervalo especificado.
temporal_attention_timestep_skip_range (`tuple[int, int]`, padrão `(100, 800)`) : O intervalo de timesteps a serem ignorados na camada de atenção temporal. Os cálculos de atenção serão condicionalmente ignorados se o timestep atual estiver dentro do intervalo especificado.
cross_attention_timestep_skip_range (`tuple[int, int]`, padrão `(100, 800)`) : O intervalo de timesteps a serem ignorados na camada de cross-attention. Os cálculos de atenção serão condicionalmente ignorados se o timestep atual estiver dentro do intervalo especificado.
spatial_attention_block_identifiers (`tuple[str, ...]`) : Os identificadores para corresponder aos nomes das camadas e determinar se a camada é uma camada de atenção espacial.
temporal_attention_block_identifiers (`tuple[str, ...]`) : Os identificadores para corresponder aos nomes das camadas e determinar se a camada é uma camada de atenção temporal.
cross_attention_block_identifiers (`tuple[str, ...]`) : Os identificadores para comparar com os nomes das camadas e determinar se a camada é uma camada de atenção cruzada.
Configuração para o Pyramid Attention Broadcast.
#### diffusers.apply_pyramid_attention_broadcast[[diffusers.apply_pyramid_attention_broadcast]]
```python
diffusers.apply_pyramid_attention_broadcast(module: Module, config: PyramidAttentionBroadcastConfig)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/pyramid_attention_broadcast.py#L181)
**Parâmetros:**
module (`torch.nn.Module`) : O módulo ao qual aplicar o Pyramid Attention Broadcast.
config (`PyramidAttentionBroadcastConfig | None`, `optional`, padrão `None`) : A configuração a ser usada para o Pyramid Attention Broadcast.
Aplique [Pyramid Attention Broadcast](https://huggingface.co/papers/2408.12588) a um pipeline específico.
PAB é um método de aproximação de atenção que aproveita a similaridade nos estados de atenção entre timesteps para reduzir o custo computacional do cálculo de atenção. O ponto principal do artigo é que a similaridade de atenção nas camadas de cross-attention entre timesteps é alta, seguida por uma similaridade menor nas camadas temporais e espaciais. Isso permite pular o cálculo de atenção nas camadas de cross-attention com mais frequência do que nas camadas temporais e espaciais. A aplicação do PAB, portanto, acelera o processo de inferência.
Exemplo:
```python
>>> import torch
>>> from diffusers import CogVideoXPipeline, PyramidAttentionBroadcastConfig, apply_pyramid_attention_broadcast
>>> from diffusers.utils import export_to_video
>>> pipe = CogVideoXPipeline.from_pretrained("THUDM/CogVideoX-5b", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> config = PyramidAttentionBroadcastConfig(
... spatial_attention_block_skip_range=2,
... spatial_attention_timestep_skip_range=(100, 800),
... current_timestep_callback=lambda: pipe.current_timestep,
... )
>>> apply_pyramid_attention_broadcast(pipe.transformer, config)
```
## FasterCacheConfig[[diffusers.FasterCacheConfig]]
#### diffusers.FasterCacheConfig[[diffusers.FasterCacheConfig]]
```python
diffusers.FasterCacheConfig(spatial_attention_block_skip_range: int = 2, temporal_attention_block_skip_range: int | None = None, spatial_attention_timestep_skip_range: tuple[int, int] = (-1, 681), temporal_attention_timestep_skip_range: tuple[int, int] = (-1, 681), low_frequency_weight_update_timestep_range: tuple[int, int] = (99, 901), high_frequency_weight_update_timestep_range: tuple[int, int] = (-1, 301), alpha_low_frequency: float = 1.1, alpha_high_frequency: float = 1.1, unconditional_batch_skip_range: int = 5, unconditional_batch_timestep_skip_range: tuple[int, int] = (-1, 641), spatial_attention_block_identifiers: tuple[str, ...] = ('^blocks.*attn', '^transformer_blocks.*attn', '^single_transformer_blocks.*attn'), temporal_attention_block_identifiers: tuple[str, ...] = ('^temporal_transformer_blocks.*attn',), attention_weight_callback: typing.Callable[[torch.nn.Module], float] = None, low_frequency_weight_callback: typing.Callable[[torch.nn.Module], float] = None, high_frequency_weight_callback: typing.Callable[[torch.nn.Module], float] = None, tensor_format: str = 'BCFHW', is_guidance_distilled: bool = False, current_timestep_callback: typing.Callable[[], int] = None, _unconditional_conditional_input_kwargs_identifiers: list[str] = ('hidden_states', 'encoder_hidden_states', 'timestep', 'attention_mask', 'encoder_attention_mask'))
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/faster_cache.py#L50)
**Parâmetros:**
spatial_attention_block_skip_range (`int`, padrão `2`) : Calcula os estados de atenção a cada `N` iterações. Se definido como `N`, o cálculo de atenção será ignorado `N - 1` vezes (ou seja, os estados de atenção em cache serão reutilizados) antes de calcular novamente os novos estados de atenção.
temporal_attention_block_skip_range (`int`, *opcional*, padrão `None`) : Calcula os estados de atenção a cada `N` iterações. Se isso for definido como `N`, o cálculo da atenção será ignorado `N - 1` vezes (ou seja, os estados de atenção em cache serão reutilizados) antes de calcular novamente os novos estados de atenção.
spatial_attention_timestep_skip_range (`tuple[float, float]`, padrão `(-1, 681)`) : O intervalo de timesteps no qual o cálculo de atenção espacial pode ser ignorado sem perda significativa de qualidade. Isso deve ser determinado pelo usuário com base no modelo subjacente. O primeiro valor da tupla é o limite inferior e o segundo valor é o limite superior. Tipicamente, os timesteps de difusão para desruido estão no intervalo invertido de 0 a 1000 (ou seja, o desruido começa no timestep 1000 e termina no timestep 0). Para os valores padrão, isso significa que a omissão do cálculo de atenção espacial será aplicável apenas após o timestep de desruido 681 ser atingido, e continuará até o fim do processo de desruido.
temporal_attention_timestep_skip_range (`tuple[float, float]`, *opcional*, padrão `None`) : O intervalo de timesteps dentro do qual o cálculo da atenção temporal pode ser ignorado sem uma perda significativa de qualidade. Isso deve ser determinado pelo usuário com base no modelo subjacente. O primeiro valor da tupla é o limite inferior e o segundo valor é o limite superior. Tipicamente, os timesteps de difusão para desruido estão no intervalo invertido de 0 a 1000 (ou seja, o desruido começa no timestep 1000 e termina no timestep 0).
low_frequency_weight_update_timestep_range (`tuple[int, int]`, padrão `(99, 901)`) : O intervalo de timesteps no qual a atualização de escala de pesos de baixa frequência é aplicada. O primeiro valor da tupla é o limite inferior e o segundo valor é o limite superior do intervalo de timesteps. A função de callback para a atualização é chamada apenas dentro deste intervalo.
high_frequency_weight_update_timestep_range (`tuple[int, int]`, padrão `(-1, 301)`) : O intervalo de timesteps no qual a atualização de escala de pesos de alta frequência é aplicada. O primeiro valor da tupla é o limite inferior e o segundo valor é o limite superior do intervalo de timesteps. A função de callback para a atualização é chamada apenas dentro deste intervalo.
alpha_low_frequency (`float`, padrão `1.1`) : O peso para escalar as atualizações de baixa frequência. Isso é usado para aproximar o ramo incondicional a partir das saídas do ramo condicional.
alpha_high_frequency (`float`, padrão `1.1`) : O peso para escalar as atualizações de alta frequência. Isso é usado para aproximar o ramo incondicional a partir das saídas do ramo condicional.
unconditional_batch_skip_range (`int`, padrão `5`) : Processa o ramo incondicional a cada `N` iterações. Se definido como `N`, o cálculo do ramo incondicional será ignorado `N - 1` vezes (ou seja, os estados do ramo incondicional em cache serão reutilizados) antes de calcular novamente os novos estados do ramo incondicional.
unconditional_batch_timestep_skip_range (`tuple[float, float]`, padrão `(-1, 641)`) : O intervalo de timestep dentro do qual o cálculo do ramo incondicional pode ser ignorado sem perda significativa de qualidade. Isso deve ser determinado pelo usuário com base no modelo subjacente. O primeiro valor da tupla é o limite inferior e o segundo valor é o limite superior.
spatial_attention_block_identifiers (`tuple[str, ...]`, padrão `("blocks.*attn1", "transformer_blocks.*attn1", "single_transformer_blocks.*attn1")`) : Os identificadores para corresponder aos blocos de atenção espacial no modelo. Se o nome do bloco contiver qualquer um desses identificadores, o FasterCache será aplicado a esse bloco. Isso pode ser o nome completo da camada, nomes parciais de camadas ou padrões de regex. A correspondência será sempre feita usando uma correspondência de regex.
temporal_attention_block_identifiers (`tuple[str, ...]`, padrão `("temporal_transformer_blocks.*attn1",)`) : Os identificadores para corresponder aos blocos de atenção temporal no modelo. Se o nome do bloco contiver qualquer um desses identificadores, o FasterCache será aplicado a esse bloco. Isso pode ser o nome completo da camada, nomes parciais de camadas ou padrões de regex. A correspondência será sempre feita usando uma correspondência de regex.
attention_weight_callback (`Callable[[torch.nn.Module], float]`, padrão `None`) : A função de callback para determinar o peso usado para escalar as saídas de atenção. Esta função deve receber o módulo de atenção como entrada e retornar um valor float. Isso é usado para aproximar o ramo incondicional a partir das saídas do ramo condicional. Se não for fornecida, o peso padrão é 0,5 para todos os timesteps. Tipicamente, conforme descrito no paper, esse peso deve aumentar gradualmente de 0 para 1 à medida que a inferência avança. Recomenda-se que os usuários experimentem e forneçam agendamentos de pesos personalizados que levem em conta o número de passos de inferência e o comportamento subjacente do modelo à medida que o desruido avança.
low_frequency_weight_callback (`Callable[[torch.nn.Module], float]`, padrão `None`) : A função de callback para determinar o peso usado para escalar as atualizações de baixa frequência. Se não for fornecida, o peso padrão é 1.1 para os timesteps dentro do intervalo especificado (conforme descrito no artigo).
high_frequency_weight_callback (`Callable[[torch.nn.Module], float]`, padrão `None`) : A função de callback para determinar o peso usado para escalar as atualizações de alta frequência. Se não for fornecida, o peso padrão é 1.1 para os timesteps dentro do intervalo especificado (conforme descrito no artigo).
tensor_format (`str`, padrão `"BCFHW"`) : O formato dos tensores de entrada. Deve ser um dos formatos `"BCFHW"`, `"BFCHW"` ou `"BCHW"`. O formato é utilizado para dividir os quadros latentes individuais, permitindo o cálculo das componentes de baixa e alta frequência.
is_guidance_distilled (`bool`, padrão `False`) : Indica se o modelo é destilado por orientação ou não. Se o modelo for destilado por orientação, o FasterCache não será aplicado no nível do desruidor para pular o cálculo do ramo incondicional (pois não há nenhum).
_unconditional_conditional_input_kwargs_identifiers (`list[str]`, padrão `("hidden_states", "encoder_hidden_states", "timestep", "attention_mask", "encoder_attention_mask")`) : Os identificadores para corresponder aos kwargs de entrada que contêm as entradas incondicionais e condicionais concatenadas por lote. Se o nome dos kwargs de entrada contiver qualquer um desses identificadores, o FasterCache dividirá as entradas em ramos incondicional e condicional. Isso deve ser uma lista de nomes exatos de kwargs de entrada que contêm as entradas incondicionais e condicionais concatenadas por lote.
Configuração para [FasterCache](https://huggingface.co/papers/2410.19355).
#### diffusers.apply_faster_cache[[diffusers.apply_faster_cache]]
```python
diffusers.apply_faster_cache(module: Module, config: FasterCacheConfig)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/faster_cache.py#L486)
**Parâmetros:**
module (`torch.nn.Module`) : O módulo do PyTorch ao qual o FasterCache será aplicado. Tipicamente, isso deve ser uma arquitetura de transformer suportada no Diffusers, como `CogVideoXTransformer3DModel`, mas implementações externas também podem funcionar.
config (`FasterCacheConfig`) : A configuração a ser usada para o FasterCache.
Aplica [FasterCache](https://huggingface.co/papers/2410.19355) a um pipeline específico.
Exemplo:
```python
>>> import torch
>>> from diffusers import CogVideoXPipeline, FasterCacheConfig, apply_faster_cache
>>> pipe = CogVideoXPipeline.from_pretrained("THUDM/CogVideoX-5b", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> config = FasterCacheConfig(
... spatial_attention_block_skip_range=2,
... spatial_attention_timestep_skip_range=(-1, 681),
... low_frequency_weight_update_timestep_range=(99, 641),
... high_frequency_weight_update_timestep_range=(-1, 301),
... spatial_attention_block_identifiers=["transformer_blocks"],
... attention_weight_callback=lambda _: 0.3,
... tensor_format="BFCHW",
... )
>>> apply_faster_cache(pipe.transformer, config)
```
## FirstBlockCacheConfig[[diffusers.FirstBlockCacheConfig]]
#### diffusers.FirstBlockCacheConfig[[diffusers.FirstBlockCacheConfig]]
```python
diffusers.FirstBlockCacheConfig(threshold: float = 0.05)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/first_block_cache.py#L33)
**Parâmetros:**
threshold (`float`, padrão `0.05`) : O limiar para determinar se é necessário ou não um forward pass por todas as camadas do modelo. Um limiar mais alto geralmente resulta em um forward pass por um menor número de camadas e inferência mais rápida, mas pode levar a uma qualidade de geração inferior. Um limiar mais baixo pode não resultar em uma aceleração significativa da geração. O limiar é comparado com a diferença absmean dos resíduos entre as saídas atuais e as saídas em cache do primeiro bloco transformer. Se a diferença estiver abaixo do limiar, o forward pass é ignorado.
Configuração para [First Block Cache](https://github.com/chengzeyi/ParaAttention/blob/7a266123671b55e7e5a2fe9af3121f07a36afc78/README.md#first-block-cache-our-dynamic-caching).
#### diffusers.apply_first_block_cache[[diffusers.apply_first_block_cache]]
```python
diffusers.apply_first_block_cache(module: Module, config: FirstBlockCacheConfig)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/first_block_cache.py#L193)
**Parâmetros:**
module (`torch.nn.Module`) : O módulo do PyTorch ao qual o FBCache será aplicado. Tipicamente, isso deve ser uma arquitetura de transformer suportada no Diffusers, como `CogVideoXTransformer3DModel`, mas implementações externas também podem funcionar.
config (`FirstBlockCacheConfig`) : A configuração a ser usada para aplicar o método FBCache.
Aplica [First Block Cache](https://github.com/chengzeyi/ParaAttention/blob/4de137c5b96416489f06e43e19f2c14a772e28fd/README.md#first-block-cache-our-dynamic-caching) a um módulo específico.
O First Block Cache se baseia nas ideias do [TeaCache](https://huggingface.co/papers/2411.19108). É muito mais simples de implementar de forma genérica para uma ampla variedade de modelos e foi integrado inicialmente para fins experimentais.
Exemplo:
```python
>>> import torch
>>> from diffusers import CogView4Pipeline
>>> from diffusers.hooks import apply_first_block_cache, FirstBlockCacheConfig
>>> pipe = CogView4Pipeline.from_pretrained("THUDM/CogView4-6B", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> apply_first_block_cache(pipe.transformer, FirstBlockCacheConfig(threshold=0.2))
>>> prompt = "A photo of an astronaut riding a horse on mars"
>>> image = pipe(prompt, generator=torch.Generator().manual_seed(42)).images[0]
>>> image.save("output.png")
```
## TaylorSeerCacheConfig[[diffusers.TaylorSeerCacheConfig]]
#### diffusers.TaylorSeerCacheConfig[[diffusers.TaylorSeerCacheConfig]]
```python
diffusers.TaylorSeerCacheConfig(cache_interval: int = 5, disable_cache_before_step: int = 3, disable_cache_after_step: int | None = None, max_order: int = 1, taylor_factors_dtype: typing.Optional[torch.dtype] = torch.bfloat16, skip_predict_identifiers: list[str] | None = None, cache_identifiers: list[str] | None = None, use_lite_mode: bool = False)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/taylorseer_cache.py#L26)
**Parâmetros:**
cache_interval (`int`, padrão `5`) : O intervalo entre etapas de computação completa. Após uma computação completa, as saídas em cache (previstas) são reutilizadas para esse número de etapas subsequentes de desruido antes de serem atualizadas com uma nova passagem de frente completa.
disable_cache_before_step (`int`, padrão `3`) : O índice do passo de desruidamento antes do qual o cache é desativado, o que significa que a computação completa é executada para os passos iniciais (0 para desativar_cache_before_step - 1) a fim de coletar dados para as aproximações da série de Taylor. Durante esses passos, os fatores de Taylor são atualizados, mas o cache/previsões não são aplicados. O cache começa neste passo.
disable_cache_after_step (`int`, *opcional*, padrão `None`) : O índice do passo de desruidamento após o qual o cache é desativado. Se definido, para passos >= a este valor, todos os módulos executam cálculos completos sem previsões ou atualizações de estado, garantindo precisão nas etapas finais, se necessário.
max_order (`int`, padrão `1`) : A ordem mais alta na expansão da série de Taylor para aproximar as saídas do módulo. Ordens mais altas fornecem aproximações melhores, mas aumentam o uso de computação e memória.
taylor_factors_dtype (`torch.dtype`, padrão `torch.bfloat16`) : Tipo de dados usado para armazenar e calcular os fatores da série de Taylor. Menor precisão reduz a memória, mas pode afetar a estabilidade; maior precisão melhora a exatidão ao custo de mais memória.
skip_predict_identifiers (`list[str]`, *opcional*, padrão `None`) : Padrões de expressão regular (usando `re.fullmatch`) para nomes de módulos a serem colocados como "skip" no modo "cache". Neste modo, o módulo é calculado totalmente durante as etapas iniciais ou de atualização, mas retorna um tensor zero (correspondendo à forma registrada) durante as etapas de previsão para pular o cálculo de forma barata.
cache_identifiers (`list[str]`, *opcional*, padrão `None`) : Padrões de regex (usando `re.fullmatch`) para nomes de módulos a serem colocados no modo de cache de série de Taylor, onde as saídas são aproximadas e armazenadas em cache para reutilização.
use_lite_mode (`bool`, *opcional*, padrão `False`) : Ativa uma variante leve do TaylorSeer que minimiza o uso de memória aplicando padrões predefinidos para ignorar e fazer cache (por exemplo, ignorar blocos e fazer cache de projeções). Isso substitui quaisquer `inactive_identifiers` ou `active_identifiers` personalizados.
Configuração para o cache TaylorSeer. Veja: https://huggingface.co/papers/2503.06923
Observações:
- Os padrões são correspondidos usando `re.fullmatch` no nome do módulo.
- Se `skip_predict_identifiers` ou `cache_identifiers` forem fornecidos, apenas os módulos correspondentes serão interceptados.
- Se nenhum dos dois for fornecido, todos os módulos semelhantes a atenção são conectados por padrão.
Exemplo de uso inativo e ativo:
```py
def forward(x):
x = self.module1(x) # inactive module: returns zeros tensor based on shape recorded during full compute
x = self.module2(x) # active module: caches output here, avoiding recomputation of prior steps
return x
```
#### bfloat16[[diffusers.TaylorSeerCacheConfig.taylor_factors_dtype]]
```python
bfloat16(*args, **kwargs)
```
Um valor simulado para um caminho pontilhado (por exemplo, `torch.float32`): as cadeias de acesso a atributos e as chamadas se comportam como decoradores de passagem, o `repr` é o caminho pontilhado, e o uso como classe base substitui uma base de `type` simples (PEP 560 `__mro_entries__`), de modo que as subclasses reais mantêm um metaclass normal e o `inspect.signature` lê o `__init__` real delas, em vez do de um mock.
#### diffusers.apply_taylorseer_cache[[diffusers.apply_taylorseer_cache]]
```python
diffusers.apply_taylorseer_cache(module: Module, config: TaylorSeerCacheConfig)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/taylorseer_cache.py#L261)
**Parâmetros:**
module (torch.nn.Module) : A subárvore do modelo à qual os hooks devem ser aplicados.
config (TaylorSeerCacheConfig) : Configuração do cache.
Aplica o cache TaylorSeer a um pipeline específico (geralmente o transformer / UNet).
Esta função conecta os módulos selecionados no modelo para permitir o cache ou a omissão com base na configuração fornecida, reduzindo cálculos redundantes nos loops de desruidificação de difusão.
Exemplo:
```python
>>> import torch
>>> from diffusers import FluxPipeline, TaylorSeerCacheConfig
>>> pipe = FluxPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-dev",
... torch_dtype=torch.bfloat16,
... )
>>> pipe.to("cuda")
>>> config = TaylorSeerCacheConfig(
... cache_interval=5,
... max_order=1,
... disable_cache_before_step=3,
... taylor_factors_dtype=torch.float32,
... )
>>> pipe.transformer.enable_cache(config)
```
## MagCacheConfig[[diffusers.MagCacheConfig]]
#### diffusers.MagCacheConfig[[diffusers.MagCacheConfig]]
```python
diffusers.MagCacheConfig(threshold: float = 0.06, max_skip_steps: int = 3, retention_ratio: float = 0.2, num_inference_steps: int = 28, mag_ratios: typing.Union[torch.Tensor, typing.List[float], NoneType] = None, calibrate: bool = False)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/mag_cache.py#L84)
**Parâmetros:**
threshold (`float`, padrão `0.06`) : O limite para o erro acumulado. Se o erro acumulado estiver abaixo desse limite, o cálculo do bloco é ignorado. Um limite mais alto permite um salto mais agressivo (mais rápido), mas pode degradar a qualidade.
max_skip_steps (`int`, padrão `3`) : O número máximo de passos consecutivos que podem ser pulados (K no artigo).
retention_ratio (`float`, padrão `0.2`) : A fração dos passos iniciais durante a qual a omissão é desativada para garantir estabilidade. Por exemplo, se `num_inference_steps` for 28 e `retention_ratio` for 0.2, os primeiros 6 passos nunca serão omitidos.
num_inference_steps (`int`, padrão `28`) : O número de etapas de inferência usadas no pipeline. Isso é necessário para interpolar `mag_ratios` corretamente.
mag_ratios (`torch.Tensor`, *opcional*) : As razões de magnitude pré-computadas para o modelo. Estas dependem do checkpoint. Se não forem fornecidas, você deve definir `calibrate=True` para calculá-las para o seu modelo específico. Para modelos Flux, você pode usar `diffusers.hooks.mag_cache.FLUX_MAG_RATIOS`.
calibrate (`bool`, padrão `False`) : Se True, habilita o modo de calibração. Neste modo, nenhum bloco é ignorado. Em vez disso, o hook calcula as razões de magnitude para a execução atual e as registra ao final. Use isso para obter `mag_ratios` para novos modelos ou agendadores.
Configuração para [MagCache](https://github.com/Zehong-Ma/MagCache).
#### diffusers.apply_mag_cache[[diffusers.apply_mag_cache]]
```python
diffusers.apply_mag_cache(module: Module, config: MagCacheConfig)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/mag_cache.py#L398)
**Parâmetros:**
module (`torch.nn.Module`) : O módulo ao qual aplicar o MagCache.
config (`MagCacheConfig`) : A configuração do MagCache.
Aplica o MagCache a um módulo específico (geralmente um Transformer).
## SeaCacheConfig[[diffusers.SeaCacheConfig]]
#### diffusers.SeaCacheConfig[[diffusers.SeaCacheConfig]]
```python
diffusers.SeaCacheConfig(threshold: float = 0.25, residual_order: int = 1, retention_steps: int = 1, cache_end_steps: int = 1, max_consecutive_cached: int = 2, power_exp: float = 3.0, raw_vision_callback: typing.Callable[[torch.nn.Module, tuple[typing.Any, ...], dict[str, typing.Any]], list[torch.Tensor] | None] = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/sea_cache.py#L38)
**Parâmetros:**
threshold (`float`, padrão `0.25`) : Orçamento relativo-L1 acumulado. Valores maiores reutilizam o cache com mais frequência.
residual_order (`int`, padrão `1`) : Ordem usada para prever o residual do transformer. `0` reutiliza diretamente o residual mais recente e `1` extrapola linearmente a partir das duas execuções completas mais recentes.
retention_steps (`int`, padrão `1`) : Número de etapas iniciais do agendador que sempre são executadas por completo.
cache_end_steps (`int`, padrão `1`) : Número de etapas finais do agendador que sempre são executadas por completo.
max_consecutive_cached (`int`, padrão `2`) : Máximo de reutilizações consecutivas de resíduos por contexto de cache antes de forçar uma execução completa. `0` desabilita o limite.
power_exp (`float`, padrão `3.0`) : Exponente do prior de potência do sinal limpo do SEA. O SeaCache usa `3.0` para recursos de vídeo.
raw_vision_callback (`Callable`, *opcional*) : Adaptador de modelo avançado que retorna os latentes visuais que formam a saída gerada, cada um com a forma `(C, T, H, W)`. Inclua os quadros de condicionamento limpos dentro da trajetória de saída, mas exclua as dicas visuais separadas que não fazem parte da saída. Quando omitido, um adaptador embutido é usado, se disponível.
Configuração para [SeaCache](https://huggingface.co/papers/2602.18993).
SeaCache é desativado por padrão e só é ativado após essa configuração ser passada para `transformer.enable_cache(config)`.
SeaCache compara os indicadores Spectral-Evolution-Aware (SEA) entre as etapas do scheduler. Se a mudança relativa acumulada permanecer abaixo de `threshold`, a pilha repetida de blocos transformer é substituída por um residual em cache. Adaptadores específicos do modelo podem estender o limite do residual além desses blocos. Outros video transformers podem usar o caminho genérico registrando seus metadados de bloco e fornecendo `raw_vision_callback`; seu pipeline deve entrar em um `cache_context` para cada trajetória do transformer.
Exemplo:
```python
>>> from diffusers import Cosmos3OmniPipeline, SeaCacheConfig
>>> pipe = Cosmos3OmniPipeline.from_pretrained("nvidia/Cosmos3-Nano")
>>> pipe.transformer.enable_cache(SeaCacheConfig())
```
#### diffusers.apply_sea_cache[[diffusers.apply_sea_cache]]
```python
diffusers.apply_sea_cache(module: Module, config: SeaCacheConfig)
```
[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/hooks/sea_cache.py#L980)
**Parâmetros:**
module (`torch.nn.Module`) : módulo Transformer para cache.
config (`SeaCacheConfig`) : Configuração do SeaCache.
Aplique o SeaCache a um transformador compatível.
SeaCache reutiliza um residual em cache para a pilha de blocos repetidos de um transformer. Adaptadores de modelo podem personalizar a extração de indicadores e o limite do residual; o caminho genérico usa metadados de bloco registrados e `raw_vision_callback`. Os parâmetros de compatibilidade e de cache devem ser validados para cada modelo.

Xet Storage Details

Size:
33.5 kB
·
Xet hash:
7cb22bed6814f62580aecb98d17d6c828dcedbd5e5ffc4b51700be2a4ae50e03

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