Hugging Face's logo

Diffusers documentation

Métodos de cache

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.42.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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

classe diffusers.CacheMixin

< >

( )

Uma classe para habilitar/desabilitar técnicas de cache em modelos de difusão.

Técnicas de cache suportadas:

cache_context

< >

( name: str**kwargs )

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

< >

( config )

Parâmetros

Ative técnicas de cache no modelo.

Exemplo:

>>> 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

classe diffusers.PyramidAttentionBroadcastConfig

< >

( spatial_attention_block_skip_range: int | None = Nonetemporal_attention_block_skip_range: int | None = Nonecross_attention_block_skip_range: int | None = Nonespatial_attention_timestep_skip_range: tuple = (100, 800)temporal_attention_timestep_skip_range: tuple = (100, 800)cross_attention_timestep_skip_range: tuple = (100, 800)spatial_attention_block_identifiers: tuple = ('blocks', 'transformer_blocks', 'single_transformer_blocks', 'layers', 'visual_transformer_blocks')temporal_attention_block_identifiers: tuple = ('temporal_transformer_blocks',)cross_attention_block_identifiers: tuple = ('blocks', 'transformer_blocks', 'layers')current_timestep_callback: typing.Callable[[], int] = None )

Parâmetros

  • spatial_attention_block_skip_range (int, opcional, padrão None) — O número de vezes que uma transmissão específica de atenção espacial é ignorada 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 uma transmissão específica de cross-attention é ignorada 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 comparar com os nomes das camadas e determinar se a camada é uma camada de atenção espacial.
  • temporal_attention_block_identifiers (tuple[str, ...]) — Os identificadores para comparar com os 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

< >

( module: Moduleconfig: PyramidAttentionBroadcastConfig )

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 Pyramid Attention Broadcast.

Aplique Pyramid Attention Broadcast 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:

>>> 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

classe diffusers.FasterCacheConfig

< >

( spatial_attention_block_skip_range: int = 2temporal_attention_block_skip_range: int | None = Nonespatial_attention_timestep_skip_range: tuple = (-1, 681)temporal_attention_timestep_skip_range: tuple = (-1, 681)low_frequency_weight_update_timestep_range: tuple = (99, 901)high_frequency_weight_update_timestep_range: tuple = (-1, 301)alpha_low_frequency: float = 1.1alpha_high_frequency: float = 1.1unconditional_batch_skip_range: int = 5unconditional_batch_timestep_skip_range: tuple = (-1, 641)spatial_attention_block_identifiers: tuple = ('^blocks.*attn', '^transformer_blocks.*attn', '^single_transformer_blocks.*attn')temporal_attention_block_identifiers: tuple = ('^temporal_transformer_blocks.*attn',)attention_weight_callback: typing.Callable[[torch.nn.Module], float] = Nonelow_frequency_weight_callback: typing.Callable[[torch.nn.Module], float] = Nonehigh_frequency_weight_callback: typing.Callable[[torch.nn.Module], float] = Nonetensor_format: str = 'BCFHW'is_guidance_distilled: bool = Falsecurrent_timestep_callback: typing.Callable[[], int] = None_unconditional_conditional_input_kwargs_identifiers: list = ('hidden_states', 'encoder_hidden_states', 'timestep', 'attention_mask', 'encoder_attention_mask') )

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 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.
  • temporal_attention_block_skip_range (int, opcional, padrão None) — Calcula os estados de atenção a cada N iterações. Se 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 desruidamento estão no intervalo invertido de 0 a 1000 (ou seja, o desruidamento 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 desruidamento 681 ser atingido, e continuará até o fim do processo de desruidamento.
  • 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 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 desruidamento estão no intervalo invertido de 0 a 1000 (ou seja, o desruidamento 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 desse intervalo.
  • alpha_low_frequency (float, padrão 1.1) — O peso usado para escalar as atualizações de baixa frequência. Isso é utilizado para aproximar o ramo incondicional a partir das saídas do ramo condicional.
  • alpha_high_frequency (float, padrão 1.1) — O peso usado para escalar as atualizações de alta frequência. Isso é utilizado 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 timesteps 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 fornecido, o peso padrão é 0,5 para todos os timesteps. Tipicamente, conforme descrito no artigo, 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 etapas 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 seguintes: "BCFHW", "BFCHW" ou "BCHW". O formato é utilizado para dividir os quadros latentes individuais, a fim de que os componentes de baixa e alta frequência sejam calculados.
  • is_guidance_distilled (bool, padrão False) — Indica se o modelo é guidance distilled ou não. Se o modelo for guidance distilled, o FasterCache não será aplicado no nível do denoiser 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.

diffusers.apply_faster_cache

< >

( module: Moduleconfig: FasterCacheConfig )

Parâmetros

  • module (torch.nn.Module) — O módulo pytorch ao qual aplicar o FasterCache. 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 a um pipeline específico.

Exemplo:

>>> 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

classe diffusers.FirstBlockCacheConfig

< >

( threshold: float = 0.05 )

Parâmetros

  • threshold (float, padrão 0.05) — O limiar para determinar se uma passagem direta por todas as camadas do modelo é necessária. Um limiar mais alto geralmente resulta em uma passagem direta 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 do transformer. Se a diferença estiver abaixo do limiar, a passagem direta é ignorada.

Configuração para First Block Cache.

diffusers.apply_first_block_cache

< >

( module: Moduleconfig: FirstBlockCacheConfig )

Parâmetros

  • module (torch.nn.Module) — O módulo do pytorch ao qual aplicar o FBCache. 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 a um módulo específico.

O First Block Cache se baseia nas ideias do TeaCache. É muito mais simples de implementar de forma genérica para uma ampla variedade de modelos e foi integrado inicialmente para fins experimentais.

Exemplo:

>>> 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

classe diffusers.TaylorSeerCacheConfig

< >

( cache_interval: int = 5disable_cache_before_step: int = 3disable_cache_after_step: int | None = Nonemax_order: int = 1taylor_factors_dtype: typing.Optional[torch.dtype] = torch.bfloat16skip_predict_identifiers: list[str] | None = Nonecache_identifiers: list[str] | None = Noneuse_lite_mode: bool = False )

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 a disable_cache_before_step - 1) para 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 esse valor, todos os módulos executam computações completas 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 marcados como “skip” no modo “cache”. Neste modo, o módulo é computado totalmente nas etapas iniciais ou de atualização, mas retorna um tensor zero (com a forma registrada) nas etapas de previsão para pular o cálculo de forma barata.
  • cache_identifiers (list[str], opcional, padrão None) — Padrões de expressão regular (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 pular e fazer cache (por exemplo, pular 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:

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

( *args**kwargs )

Um valor simulado para um caminho pontilhado (por exemplo, torch.float32): cadeias de acesso a atributos, chamadas se comportam como decoradores de passagem, repr é o caminho pontilhado, e usá-lo como classe base substitui uma base de type simples (PEP 560 __mro_entries__), de modo que subclasses reais mantêm uma metaclass normal e inspect.signature lê seu __init__ real em vez do de um mock.

diffusers.apply_taylorseer_cache

< >

( module: Moduleconfig: TaylorSeerCacheConfig )

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:

>>> 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

classe diffusers.MagCacheConfig

< >

( threshold: float = 0.06max_skip_steps: int = 3retention_ratio: float = 0.2num_inference_steps: int = 28mag_ratios: typing.Union[torch.Tensor, typing.List[float], NoneType] = Nonecalibrate: bool = False )

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 etapas consecutivas que podem ser puladas (K no artigo).
  • retention_ratio (float, padrão 0.2) — A fração dos passos iniciais durante a qual o salto é desativado para garantir estabilidade. Por exemplo, se num_inference_steps for 28 e retention_ratio for 0.2, os primeiros 6 passos nunca serão pulados.
  • 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é-calculadas para o modelo. Elas 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 no final. Use isso para obter mag_ratios para novos modelos ou agendadores.

Configuração para MagCache.

diffusers.apply_mag_cache

< >

( module: Moduleconfig: MagCacheConfig )

Parâmetros

  • module (torch.nn.Module) — O módulo ao qual aplicar o MagCache.
  • config (MagCacheConfig) — A configuração para o MagCache.

Aplica o MagCache a um módulo específico (geralmente um Transformer).

SeaCacheConfig

classe diffusers.SeaCacheConfig

< >

( threshold: float = 0.25residual_order: int = 1retention_steps: int = 1cache_end_steps: int = 1max_consecutive_cached: int = 2power_exp: float = 3.0raw_vision_callback: typing.Callable[[torch.nn.Module, tuple[typing.Any, ...], dict[str, typing.Any]], list[torch.Tensor] | None] = None )

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) — Expoente 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 avançado de modelo que retorna os latentes visuais que formam a saída gerada, cada um com 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.

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 agendador. Se a mudança relativa acumulada permanecer abaixo de threshold, a pilha repetida de blocos do 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:

>>> from diffusers import Cosmos3OmniPipeline, SeaCacheConfig

>>> pipe = Cosmos3OmniPipeline.from_pretrained("nvidia/Cosmos3-Nano")
>>> pipe.transformer.enable_cache(SeaCacheConfig())

diffusers.apply_sea_cache

< >

( module: Moduleconfig: SeaCacheConfig )

Parâmetros

  • module (torch.nn.Module) — Módulo Transformer a ser armazenado em 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 do indicador 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.

Update on GitHub

←Funções de ativação personalizadas Camadas de normalização personalizadas→