diffusers/v0.43.0/es/api/cache.md

Métodos de caché

Los métodos de caché aceleran los transformadores de difusión almacenando y reutilizando las salidas intermedias de capas específicas, como las capas de atención y las capas de avance, en lugar de recalcularlas en cada paso de inferencia.

CacheMixin[[diffusers.CacheMixin]]

diffusers.CacheMixin[[diffusers.CacheMixin]]

diffusers.CacheMixin()

Fuente

Una clase para habilitar/deshabilitar técnicas de caché en modelos de difusión.

Técnicas de caché admitidas:

• Difusión de atención piramidal
• FasterCache
• FirstBlockCache
• SeaCache

cache_context[[diffusers.CacheMixin.cache_context]]

cache_context(name: str, **kwargs)

Fuente

Gestor de contexto que proporciona información para la gestión de la caché.

name es el nombre de la llamada de denoising, normalmente "cond" o "uncond". Los argumentos de palabra clave describen en qué punto se encuentra el bucle de denoising; consulte CacheContext para los campos aceptados, por ejemplo cache_context("cond", step_index=i, sigma=sigma).

enable_cache[[diffusers.CacheMixin.enable_cache]]

enable_cache(config)

Fuente

Parámetros:

config (PyramidAttentionBroadcastConfig | FasterCacheConfig | FirstBlockCacheConfig | SeaCacheConfig | TextKVCacheConfig) : La configuración para aplicar la técnica de caché. Las técnicas de caché actualmente admitidas son: - PyramidAttentionBroadcastConfig - FasterCacheConfig - FirstBlockCacheConfig - SeaCacheConfig - TextKVCacheConfig

Habilite técnicas de caché en el modelo.

Ejemplo:

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

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)

Fuente

Parámetros:

spatial_attention_block_skip_range (int, opcional, valor predeterminado None) : El número de veces que se omite una difusión específica de atención espacial antes de calcular los estados de atención para reutilizar. Si se establece en el valor N, el cálculo de la atención se omitirá N - 1 veces (es decir, se reutilizarán los estados de atención anteriores) antes de calcular nuevamente los nuevos estados de atención.

temporal_attention_block_skip_range (int, opcional, valor predeterminado None) : El número de veces que se omite una difusión específica de atención temporal antes de calcular los estados de atención para reutilizar. Si se establece en el valor N, el cálculo de la atención se omitirá N - 1 veces (es decir, se reutilizarán los estados de atención antiguos) antes de calcular nuevamente los nuevos estados de atención.

cross_attention_block_skip_range (int, opcional, valor predeterminado None) : El número de veces que se omite una difusión específica de atención cruzada antes de calcular los estados de atención para reutilizar. Si se establece en el valor N, el cálculo de atención se omitirá N - 1 veces (es decir, se reutilizarán los estados de atención antiguos) antes de calcular nuevamente los nuevos estados de atención.

spatial_attention_timestep_skip_range (tuple[int, int], por defecto (100, 800)) : El rango de timesteps que se omitirán en la capa de atención espacial. Los cálculos de atención se omitirán de forma condicional si el timestep actual se encuentra dentro del rango especificado.

temporal_attention_timestep_skip_range (tuple[int, int], por defecto (100, 800)) : El rango de timesteps que se omitirán en la capa de atención temporal. Los cálculos de atención se omitirán de forma condicional si el timestep actual se encuentra dentro del rango especificado.

cross_attention_timestep_skip_range (tuple[int, int], por defecto (100, 800)) : El rango de pasos temporales que se omitirán en la capa de atención cruzada. Los cálculos de atención se omitirán de forma condicional si el paso temporal actual se encuentra dentro del rango especificado.

spatial_attention_block_identifiers (tuple[str, ...]) : Los identificadores con los que se comparan los nombres de las capas para determinar si la capa es una capa de atención espacial.

temporal_attention_block_identifiers (tuple[str, ...]) : Los identificadores con los que se comparan los nombres de las capas para determinar si la capa es una capa de atención temporal.

cross_attention_block_identifiers (tuple[str, ...]) : Los identificadores con los que se comparan los nombres de las capas para determinar si la capa es una capa de atención cruzada.

Configuración para la difusión de atención piramidal.

diffusers.apply_pyramid_attention_broadcast[[diffusers.apply_pyramid_attention_broadcast]]

diffusers.apply_pyramid_attention_broadcast(module: Module, config: PyramidAttentionBroadcastConfig)

Fuente

Parámetros:

module (torch.nn.Module) : El módulo al que se aplicará Pyramid Attention Broadcast.

config (PyramidAttentionBroadcastConfig | None, optional, por defecto None) : La configuración a utilizar para Pyramid Attention Broadcast.

Aplicar Pyramid Attention Broadcast a un pipeline dado.

PAB es un método de aproximación de atención que aprovecha la similitud en los estados de atención entre pasos de tiempo para reducir el costo computacional del cálculo de atención. La conclusión clave del artículo es que la similitud de atención en las capas de atención cruzada entre pasos de tiempo es alta, seguida de una menor similitud en las capas temporales y espaciales. Esto permite omitir el cálculo de atención en las capas de atención cruzada con mayor frecuencia que en las capas temporales y espaciales. Por lo tanto, aplicar PAB acelerará el proceso de inferencia.

Ejemplo:

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

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

Fuente

Parámetros:

spatial_attention_block_skip_range (int, por defecto 2) : Calcula los estados de atención cada N iteraciones. Si se establece en N, el cálculo de atención se omitirá N - 1 veces (es decir, se reutilizarán los estados de atención en caché) antes de calcular nuevamente los nuevos estados de atención.

temporal_attention_block_skip_range (int, opcional, valor predeterminado None) : Calcula los estados de atención cada N iteraciones. Si se establece en N, el cálculo de atención se omitirá N - 1 veces (es decir, se reutilizarán los estados de atención en caché) antes de calcular nuevamente los nuevos estados de atención.

spatial_attention_timestep_skip_range (tuple[float, float], por defecto (-1, 681)) : El rango de pasos de tiempo dentro del cual se puede omitir el cálculo de la atención espacial sin una pérdida significativa de calidad. Esto debe determinarse por el usuario en función del modelo subyacente. El primer valor de la tupla es el límite inferior y el segundo valor es el límite superior. Típicamente, los pasos de tiempo de difusión para el desruido están en el rango inverso de 0 a 1000 (es decir, el desruido comienza en el paso de tiempo 1000 y termina en el paso de tiempo 0). Para los valores por defecto, esto significaría que la omisión del cálculo de la atención espacial solo sería aplicable después de alcanzar el paso de tiempo de desruido 681, y continuaría hasta el final del proceso de desruido.

temporal_attention_timestep_skip_range (tuple[float, float], opcional, valor predeterminado None) : El rango de pasos de tiempo dentro del cual se puede omitir el cálculo de la atención temporal sin una pérdida significativa de calidad. Esto debe determinarse por el usuario en función del modelo subyacente. El primer valor de la tupla es el límite inferior y el segundo valor es el límite superior. Típicamente, los pasos de tiempo de difusión para el desruido están en el rango inverso de 0 a 1000 (es decir, el desruido comienza en el paso de tiempo 1000 y termina en el paso de tiempo 0).

low_frequency_weight_update_timestep_range (tuple[int, int], por defecto (99, 901)) : El rango de pasos de tiempo en el que se aplica la actualización de la escalado de pesos de baja frecuencia. El primer valor de la tupla es el límite inferior y el segundo valor es el límite superior del rango de pasos de tiempo. La función de callback para la actualización se llama solo dentro de este rango.

high_frequency_weight_update_timestep_range (tuple[int, int], por defecto (-1, 301)) : El rango de pasos de tiempo en el que se aplica la actualización de la escalado de pesos de alta frecuencia. El primer valor de la tupla es el límite inferior y el segundo valor es el límite superior del rango de pasos de tiempo. La función de callback para la actualización se llama solo dentro de este rango.

alpha_low_frequency (float, por defecto 1.1) : El peso para escalar las actualizaciones de baja frecuencia. Se utiliza para aproximar la rama incondicional a partir de las salidas de la rama condicional.

alpha_high_frequency (float, por defecto 1.1) : El peso para escalar las actualizaciones de alta frecuencia. Se utiliza para aproximar la rama incondicional a partir de las salidas de la rama condicional.

unconditional_batch_skip_range (int, por defecto 5) : Procesa la rama incondicional cada N iteraciones. Si se establece en N, el cálculo de la rama incondicional se omitirá N - 1 veces (es decir, se reutilizarán los estados de rama incondicional en caché) antes de calcular nuevamente los nuevos estados de rama incondicional.

unconditional_batch_timestep_skip_range (tuple[float, float], por defecto (-1, 641)) : El rango de pasos de tiempo dentro del cual se puede omitir el cálculo de la rama incondicional sin una pérdida significativa de calidad. Esto debe determinarse por el usuario en función del modelo subyacente. El primer valor de la tupla es el límite inferior y el segundo valor es el límite superior.

spatial_attention_block_identifiers (tuple[str, ...], por defecto ("blocks.*attn1", "transformer_blocks.*attn1", "single_transformer_blocks.*attn1")) : Los identificadores para hacer coincidir los bloques de atención espacial en el modelo. Si el nombre del bloque contiene alguno de estos identificadores, se aplicará FasterCache a ese bloque. Esto puede ser el nombre completo de la capa, un nombre parcial de la capa o patrones de expresión regular. La coincidencia siempre se realizará mediante una coincidencia de expresión regular.

temporal_attention_block_identifiers (tuple[str, ...], por defecto ("temporal_transformer_blocks.*attn1",)) : Los identificadores para hacer coincidir los bloques de atención temporal en el modelo. Si el nombre del bloque contiene alguno de estos identificadores, se aplicará FasterCache a ese bloque. Esto puede ser el nombre completo de la capa, un nombre parcial de la capa o patrones de expresión regular. La coincidencia siempre se realizará mediante una coincidencia de expresión regular.

attention_weight_callback (Callable[[torch.nn.Module], float], por defecto None) : La función de callback para determinar el peso con el que se escalan las salidas de atención. Esta función debe recibir el módulo de atención como entrada y devolver un valor float. Se utiliza para aproximar la rama incondicional a partir de las salidas de la rama condicional. Si no se proporciona, el peso por defecto es 0.5 para todos los pasos de tiempo. Típicamente, tal como se describe en el artículo, este peso debe aumentar gradualmente de 0 a 1 a medida que avanza la inferencia. Se anima a los usuarios a experimentar y proporcionar programaciones de pesos personalizadas que tengan en cuenta el número de pasos de inferencia y el comportamiento del modelo subyacente a medida que avanza el desruido.

low_frequency_weight_callback (Callable[[torch.nn.Module], float], por defecto None) : La función de callback para determinar el peso con el que se escalan las actualizaciones de baja frecuencia. Si no se proporciona, el peso por defecto es 1.1 para los pasos de tiempo dentro del rango especificado (tal como se describe en el artículo).

high_frequency_weight_callback (Callable[[torch.nn.Module], float], por defecto None) : La función de callback para determinar el peso con el que se escalan las actualizaciones de alta frecuencia. Si no se proporciona, el peso por defecto es 1.1 para los pasos de tiempo dentro del rango especificado (tal como se describe en el artículo).

tensor_format (str, por defecto "BCFHW") : El formato de los tensores de entrada. Debe ser uno de "BCFHW", "BFCHW" o "BCHW". El formato se utiliza para dividir los fotogramas latentes individuales a fin de calcular las componentes de baja y alta frecuencia.

is_guidance_distilled (bool, por defecto False) : Indica si el modelo es de destilación de guía o no. Si el modelo es de destilación de guía, FasterCache no se aplicará a nivel de desruidador para omitir el cálculo de la rama incondicional (ya que no existe).

_unconditional_conditional_input_kwargs_identifiers (list[str], por defecto ("hidden_states", "encoder_hidden_states", "timestep", "attention_mask", "encoder_attention_mask")) : Los identificadores para hacer coincidir los kwargs de entrada que contienen las entradas incondicionales y condicionales concatenadas por lote. Si el nombre de los kwargs de entrada contiene alguno de estos identificadores, FasterCache dividirá las entradas en ramas incondicional y condicional. Esto debe ser una lista de nombres exactos de kwargs de entrada que contienen las entradas incondicionales y condicionales concatenadas por lote.

Configuración para FasterCache.

diffusers.apply_faster_cache[[diffusers.apply_faster_cache]]

diffusers.apply_faster_cache(module: Module, config: FasterCacheConfig)

Fuente

Parámetros:

module (torch.nn.Module) : El módulo de PyTorch al que se le aplicará FasterCache. Por lo general, debe ser una arquitectura de transformador compatible con Diffusers, como CogVideoXTransformer3DModel, aunque también pueden funcionar implementaciones externas.

config (FasterCacheConfig) : La configuración a utilizar para FasterCache.

Aplica FasterCache a un pipeline dado.

Ejemplo:

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

diffusers.FirstBlockCacheConfig(threshold: float = 0.05)

Fuente

Parámetros:

threshold (float, por defecto 0.05) : El umbral para determinar si se requiere o no una pasada hacia adelante a través de todas las capas del modelo. Un umbral más alto suele dar como resultado una pasada hacia adelante a través de un menor número de capas y una inferencia más rápida, pero podría llevar a una menor calidad de generación. Un umbral más bajo puede no resultar en una aceleración significativa de la generación. El umbral se compara con la diferencia absmean de los residuos entre las salidas actuales y las salidas en caché del primer bloque transformer. Si la diferencia es inferior al umbral, se omite la pasada hacia adelante.

Configuración para First Block Cache.

diffusers.apply_first_block_cache[[diffusers.apply_first_block_cache]]

diffusers.apply_first_block_cache(module: Module, config: FirstBlockCacheConfig)

Fuente

Parámetros:

module (torch.nn.Module) : El módulo de PyTorch al que se le aplicará FBCache. Por lo general, debe ser una arquitectura de transformer compatible con Diffusers, como CogVideoXTransformer3DModel, aunque también pueden funcionar implementaciones externas.

config (FirstBlockCacheConfig) : La configuración que se utilizará para aplicar el método FBCache.

Aplica First Block Cache a un módulo dado.

First Block Cache se basa en las ideas de TeaCache. Es mucho más sencillo de implementar de forma genérica para una amplia gama de modelos y se ha integrado primero con fines experimentales.

Ejemplo:

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

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)

Fuente

Parámetros:

cache_interval (int, por defecto 5) : El intervalo entre pasos de cálculo completos. Después de un cálculo completo, las salidas en caché (predichas) se reutilizan durante este número de pasos de desruido posteriores antes de actualizarse con una nueva pasada completa hacia adelante.

disable_cache_before_step (int, por defecto 3) : El índice del paso de desruido antes del cual se desactiva la caché, lo que significa que se realiza un cálculo completo para los pasos iniciales (0 para desactivar_cache_before_step - 1) con el fin de recopilar datos para las aproximaciones de la serie de Taylor. Durante estos pasos, se actualizan los factores de Taylor, pero no se aplican la caché ni las predicciones. La caché comienza en este paso.

disable_cache_after_step (int, opcional, valor predeterminado None) : El índice del paso de desruido a partir del cual se desactiva la caché. Si se establece, para los pasos >= a este valor, todos los módulos ejecutan cálculos completos sin predicciones ni actualizaciones de estado, garantizando la precisión en las etapas posteriores si es necesario.

max_order (int, por defecto 1) : El orden más alto en la expansión de la serie de Taylor para aproximar las salidas del módulo. Los órdenes más altos proporcionan mejores aproximaciones, pero aumentan el uso de cómputo y memoria.

taylor_factors_dtype (torch.dtype, por defecto torch.bfloat16) : Tipo de datos utilizado para almacenar y calcular los factores de la serie de Taylor. Una precisión más baja reduce la memoria, pero puede afectar la estabilidad; una precisión más alta mejora la exactitud a costa de más memoria.

skip_predict_identifiers (list[str], opcional, valor predeterminado None) : Patrones de expresiones regulares (usando re.fullmatch) para nombres de módulos que se colocarán como "skip" en el modo "cache". En este modo, el módulo se calcula por completo durante los pasos iniciales o de actualización, pero devuelve un tensor de ceros (que coincide con la forma registrada) durante los pasos de predicción para omitir el cálculo de forma económica.

cache_identifiers (list[str], opcional, valor predeterminado None) : Patrones de expresiones regulares (usando re.fullmatch) para nombres de módulos que se colocarán en el modo de caché de series de Taylor, donde las salidas se aproximan y se almacenan en caché para su reutilización.

use_lite_mode (bool, opcional, valor predeterminado False) : Habilita una variante ligera de TaylorSeer que minimiza el uso de memoria aplicando patrones predefinidos para omitir y almacenar en caché (p. ej., omitir bloques y almacenar proyecciones en caché). Esto anula cualquier inactive_identifiers o active_identifiers personalizado.

Configuración para la caché TaylorSeer. Ver: https://huggingface.co/papers/2503.06923

Notas:

• Los patrones se coinciden mediante re.fullmatch en el nombre del módulo.
• Si se proporcionan skip_predict_identifiers o cache_identifiers, solo se enganchan los módulos que coincidan.
• Si no se proporciona ninguno, todos los módulos de tipo atención se enganchan de forma predeterminada.

Ejemplo de uso inactivo y activo:

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

bfloat16(*args, **kwargs)

Un valor simulado para una ruta con puntos (p. ej. torch.float32): las cadenas de acceso a atributos y las llamadas se comportan como decoradores de paso, repr es la ruta con puntos, y su uso como clase base sustituye una base de type simple (PEP 560 __mro_entries__), de modo que las subclases reales conservan un metaclass normal y inspect.signature lee su __init__ real en lugar del de un simulado.

diffusers.apply_taylorseer_cache[[diffusers.apply_taylorseer_cache]]

diffusers.apply_taylorseer_cache(module: Module, config: TaylorSeerCacheConfig)

Fuente

Parámetros:

module (torch.nn.Module) : El subárbol del modelo al que se aplicarán los hooks.

config (TaylorSeerCacheConfig) : Configuración de la caché.

Aplica la caché de TaylorSeer a un pipeline dado (típicamente el transformer / UNet).

Esta función conecta los módulos seleccionados del modelo para habilitar el almacenamiento en caché o el omitido de pasos según la configuración proporcionada, reduciendo los cálculos redundantes en los bucles de desruido de difusión.

Ejemplo:

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

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)

Fuente

Parámetros:

threshold (float, por defecto 0.06) : El umbral para el error acumulado. Si el error acumulado está por debajo de este umbral, se omite el cálculo del bloque. Un umbral más alto permite un salto más agresivo (más rápido), pero puede degradar la calidad.

max_skip_steps (int, por defecto 3) : El número máximo de pasos consecutivos que se pueden omitir (K en el artículo).

retention_ratio (float, por defecto 0.2) : La fracción de pasos iniciales durante los cuales se desactiva el salto para garantizar la estabilidad. Por ejemplo, si num_inference_steps es 28 y retention_ratio es 0.2, los primeros 6 pasos nunca se omitirán.

num_inference_steps (int, por defecto 28) : El número de pasos de inferencia utilizados en el pipeline. Esto es necesario para interpolar mag_ratios correctamente.

mag_ratios (torch.Tensor, opcional) : Las proporciones de magnitud precalculadas para el modelo. Estas dependen del checkpoint. Si no se proporcionan, debe establecer calibrate=True para calcularlas para su modelo específico. Para los modelos Flux, puede usar diffusers.hooks.mag_cache.FLUX_MAG_RATIOS.

calibrate (bool, por defecto False) : Si es True, habilita el modo de calibración. En este modo, no se omiten bloques. En su lugar, el hook calcula las proporciones de magnitud para la ejecución actual y las registra al final. Utilice esto para obtener mag_ratios para nuevos modelos o programadores.

Configuración para MagCache.

diffusers.apply_mag_cache[[diffusers.apply_mag_cache]]

diffusers.apply_mag_cache(module: Module, config: MagCacheConfig)

Fuente

Parámetros:

module (torch.nn.Module) : El módulo al que se le aplicará MagCache.

config (MagCacheConfig) : La configuración de MagCache.

Aplica MagCache a un módulo dado (típicamente un Transformer).

SeaCacheConfig[[diffusers.SeaCacheConfig]]

diffusers.SeaCacheConfig[[diffusers.SeaCacheConfig]]

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)

Fuente

Parámetros:

threshold (float, por defecto 0.25) : Presupuesto acumulado de L1 relativo. Valores más grandes reutilizan la caché con más frecuencia.

residual_order (int, por defecto 1) : Orden utilizado para predecir el residual del transformer. 0 reutiliza directamente el residual más reciente y 1 extrapola linealmente a partir de las dos ejecuciones completas más recientes.

retention_steps (int, por defecto 1) : Número de pasos iniciales del programador que siempre se ejecutan por completo.

cache_end_steps (int, por defecto 1) : Número de pasos finales del programador que siempre se ejecutan por completo.

max_consecutive_cached (int, por defecto 2) : Número máximo de reutilizaciones consecutivas de residuales por contexto de caché antes de forzar una ejecución completa. 0 deshabilita el límite.

power_exp (float, por defecto 3.0) : Exponente del prior de potencia de señal limpia de SEA. SeaCache utiliza 3.0 para las características de video.

raw_vision_callback (Callable, opcional) : Adaptador de modelo avanzado que devuelve los latentes visuales que forman la salida generada, cada uno con forma (C, T, H, W). Incluye los fotogramas de condicionamiento limpios dentro de la trayectoria de salida, pero excluye las pistas visuales separadas que no forman parte de la salida. Si se omite, se utiliza un adaptador integrado si está disponible.

Configuración para SeaCache.

SeaCache está deshabilitado de forma predeterminada y solo se activa después de pasar esta configuración a transformer.enable_cache(config).

SeaCache compara los indicadores Spectral-Evolution-Aware (SEA) entre pasos del programador. Si su cambio relativo acumulado se mantiene por debajo de threshold, la pila de bloques de transformador repetida se reemplaza con un residual en caché. Los adaptadores específicos del modelo pueden extender el límite del residual más allá de esos bloques. Otros transformadores de video pueden usar la ruta genérica registrando sus metadatos de bloque y proporcionando raw_vision_callback; su pipeline debe entrar en un cache_context para cada trayectoria del transformador.

Ejemplo:

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

diffusers.apply_sea_cache(module: Module, config: SeaCacheConfig)

Fuente

Parámetros:

module (torch.nn.Module) : Módulo Transformer para cachear.

config (SeaCacheConfig) : Configuración de SeaCache.

Aplica SeaCache a un transformador compatible.

SeaCache reutiliza un residual en caché para la pila de bloques repetidos de un transformer. Los adaptadores de modelo pueden personalizar la extracción de indicadores y el límite del residual; la ruta genérica utiliza los metadatos de bloques registrados y raw_vision_callback. Los parámetros de compatibilidad y de caché deben validarse para cada modelo.