Hugging Face's logo

Diffusers documentation

Méthodes de mise en 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éthodes de mise en cache

Les méthodes de cache accélèrent les transformeurs de diffusion en stockant et en réutilisant les sorties intermédiaires de couches spécifiques, telles que les couches d’attention et de réseau de neurones à propagation avant, plutôt qu’en les recalculant à chaque étape d’inférence.

CacheMixin

classe diffusers.CacheMixin

< >

( )

Une classe pour activer/désactiver les techniques de mise en cache sur les modèles de diffusion.

Techniques de mise en cache prises en charge :

cache_context

< >

( name: str**kwargs )

Gestionnaire de contexte qui fournit des informations pour la gestion du cache.

name est le nom de l’appel de débruitage, généralement "cond" ou "uncond". Les arguments par mot-clé décrivent où se situe la boucle de débruitage — voir CacheContext pour les champs acceptés, par exemple cache_context("cond", step_index=i, sigma=sigma).

enable_cache

< >

( config )

Paramètres

Activer les techniques de mise en cache sur le modèle.

Exemple :

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

Paramètres

  • spatial_attention_block_skip_range (int, facultatif, valeur par défaut None) — Le nombre de fois qu'une diffusion d'attention spatiale spécifique est ignorée avant de calculer les états d'attention à réutiliser. Si cette valeur est définie sur N, le calcul de l'attention sera ignoré N - 1 fois (c'est-à-dire que les anciens états d'attention seront réutilisés) avant de recalculer les nouveaux états d'attention.
  • temporal_attention_block_skip_range (int, facultatif, valeur par défaut None) — Le nombre de fois qu'une diffusion d'attention temporelle spécifique est ignorée avant de calculer les états d'attention à réutiliser. Si cette valeur est définie sur N, le calcul de l'attention sera ignoré N - 1 fois (c'est-à-dire que les anciens états d'attention seront réutilisés) avant de recalculer les nouveaux états d'attention.
  • cross_attention_block_skip_range (int, facultatif, valeur par défaut None) — Le nombre de fois qu'une diffusion spécifique d'attention croisée est ignorée avant de calculer les états d'attention à réutiliser. Si cette valeur est définie sur N, le calcul de l'attention sera ignoré N - 1 fois (c'est-à-dire que les anciens états d'attention seront réutilisés) avant de recalculer les nouveaux états d'attention.
  • spatial_attention_timestep_skip_range (tuple[int, int], par défaut (100, 800)) — La plage de timesteps à ignorer dans la couche d'attention spatiale. Les calculs d'attention seront conditionnellement ignorés si le timestep actuel se situe dans la plage spécifiée.
  • temporal_attention_timestep_skip_range (tuple[int, int], par défaut (100, 800)) — La plage de pas de temps à ignorer dans la couche d'attention temporelle. Les calculs d'attention seront conditionnellement ignorés si le pas de temps actuel se situe dans la plage spécifiée.
  • cross_attention_timestep_skip_range (tuple[int, int], par défaut (100, 800)) — La plage de timesteps à ignorer dans la couche d'attention croisée. Les calculs d'attention seront conditionnellement ignorés si le timestep actuel se situe dans la plage spécifiée.
  • spatial_attention_block_identifiers (tuple[str, ...]) — Les identifiants à comparer avec les noms de couches pour déterminer si la couche est une couche d'attention spatiale.
  • temporal_attention_block_identifiers (tuple[str, ...]) — Les identifiants à comparer avec les noms de couches pour déterminer si la couche est une couche d'attention temporelle.
  • cross_attention_block_identifiers (tuple[str, ...]) — Les identifiants à comparer avec les noms de couches pour déterminer si la couche est une couche d'attention croisée.

Configuration pour la diffusion de l'attention pyramidale.

diffusers.apply_pyramid_attention_broadcast

< >

( module: Moduleconfig: PyramidAttentionBroadcastConfig )

Paramètres

  • module (torch.nn.Module) — Le module auquel appliquer Pyramid Attention Broadcast.
  • config (PyramidAttentionBroadcastConfig | None, optional, par défaut None) — La configuration à utiliser pour Pyramid Attention Broadcast.

Appliquer Pyramid Attention Broadcast à un pipeline donné.

PAB est une méthode d’approximation de l’attention qui exploite la similarité des états d’attention entre les pas de temps pour réduire le coût de calcul de l’attention. Le point clé de l’article est que la similarité de l’attention dans les couches d’attention croisée entre les pas de temps est élevée, suivie d’une similarité moindre dans les couches temporelles et spatiales. Cela permet de sauter le calcul de l’attention dans les couches d’attention croisée plus fréquemment que dans les couches temporelles et spatiales. L’application de PAB accélère donc le processus d’inférence.

Exemple :

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

Paramètres

  • spatial_attention_block_skip_range (int, par défaut 2) — Calcule les états d'attention toutes les N itérations. Si cette valeur est définie sur N, le calcul de l'attention sera ignoré N - 1 fois (c'est-à-dire que les états d'attention mis en cache seront réutilisés) avant de recalculer les nouveaux états d'attention.
  • temporal_attention_block_skip_range (int, facultatif, valeur par défaut None) — Calcule les états d’attention toutes les N itérations. Si cette valeur est définie sur N, le calcul de l’attention sera ignoré N - 1 fois (c’est-à-dire que les états d’attention mis en cache seront réutilisés) avant de recalculer les nouveaux états d’attention.
  • spatial_attention_timestep_skip_range (tuple[float, float], par défaut (-1, 681)) — La plage de timesteps dans laquelle le calcul de l'attention spatiale peut être ignoré sans perte significative de qualité. Cette plage est à déterminer par l'utilisateur en fonction du modèle sous-jacent. La première valeur du tuple est la borne inférieure et la seconde est la borne supérieure. En général, les timesteps de diffusion pour le débruitage sont dans la plage inversée de 0 à 1000 (c'est-à-dire que le débruitage commence au timestep 1000 et se termine au timestep 0). Pour les valeurs par défaut, cela signifie que l'ignorance du calcul de l'attention spatiale ne s'appliquera qu'après que le timestep de débruitage 681 a été atteint, et continuera jusqu'à la fin du processus de débruitage.
  • temporal_attention_timestep_skip_range (tuple[float, float], facultatif, valeur par défaut None) — La plage de timesteps dans laquelle le calcul de l’attention temporelle peut être ignoré sans perte significative de qualité. Cette plage est à déterminer par l’utilisateur en fonction du modèle sous-jacent. La première valeur du tuple est la borne inférieure et la seconde est la borne supérieure. En général, les timesteps de diffusion pour le débruitage sont dans la plage inversée de 0 à 1000 (c’est-à-dire que le débruitage commence au timestep 1000 et se termine au timestep 0).
  • low_frequency_weight_update_timestep_range (tuple[int, int], par défaut (99, 901)) — La plage de timesteps dans laquelle la mise à jour de l’échelle des poids basse fréquence est appliquée. La première valeur du tuple est la borne inférieure et la deuxième valeur est la borne supérieure de la plage de timesteps. La fonction de rappel pour la mise à jour n’est appelée que dans cette plage.
  • high_frequency_weight_update_timestep_range (tuple[int, int], par défaut (-1, 301)) — La plage de timesteps dans laquelle la mise à jour du facteur d’échelle des poids à haute fréquence est appliquée. La première valeur du tuple est la borne inférieure et la deuxième valeur est la borne supérieure de la plage de timesteps. La fonction de rappel pour la mise à jour n’est appelée que dans cette plage.
  • alpha_low_frequency (float, par défaut 1.1) — Le facteur d'échelle appliqué aux mises à jour de basse fréquence. Il est utilisé pour approximer la branche inconditionnelle à partir des sorties de la branche conditionnelle.
  • alpha_high_frequency (float, par défaut 1.1) — Le poids utilisé pour mettre à l'échelle les mises à jour de haute fréquence. Il sert à approximer la branche inconditionnelle à partir des sorties de la branche conditionnelle.
  • unconditional_batch_skip_range (int, par défaut 5) — Traite la branche inconditionnelle toutes les N itérations. Si cette valeur est définie sur N, le calcul de la branche inconditionnelle sera ignoré N - 1 fois (c’est-à-dire que les états de la branche inconditionnelle mis en cache seront réutilisés) avant de recalculer les nouveaux états de la branche inconditionnelle.
  • unconditional_batch_timestep_skip_range (tuple[float, float], par défaut (-1, 641)) — La plage de timesteps dans laquelle le calcul de la branche inconditionnelle peut être ignoré sans perte significative de qualité. Cette plage est à déterminer par l'utilisateur en fonction du modèle sous-jacent. La première valeur du tuple est la borne inférieure et la deuxième valeur est la borne supérieure.
  • spatial_attention_block_identifiers (tuple[str, ...], par défaut ("blocks.*attn1", "transformer_blocks.*attn1", "single_transformer_blocks.*attn1")) — Les identifiants à utiliser pour correspondre aux blocs d'attention spatiale du modèle. Si le nom d'un bloc contient l'un de ces identifiants, FasterCache sera appliqué à ce bloc. Il peut s'agir de noms de couches complets, de noms de couches partiels ou de motifs regex. La correspondance sera toujours effectuée à l'aide d'une correspondance regex.
  • temporal_attention_block_identifiers (tuple[str, ...], par défaut ("temporal_transformer_blocks.*attn1",)) — Les identifiants à utiliser pour correspondre aux blocs d'attention temporelle du modèle. Si le nom d'un bloc contient l'un de ces identifiants, FasterCache sera appliqué à ce bloc. Il peut s'agir de noms de couches complets, de noms de couches partiels ou de motifs regex. La correspondance est toujours effectuée à l'aide d'une recherche regex.
  • attention_weight_callback (Callable[[torch.nn.Module], float], par défaut None) — La fonction de rappel permettant de déterminer le poids par lequel les sorties d'attention doivent être mises à l'échelle. Cette fonction doit prendre le module d'attention en entrée et renvoyer une valeur flottante. Elle est utilisée pour approximer la branche inconditionnelle à partir des sorties de la branche conditionnelle. Si elle n'est pas fournie, le poids par défaut est de 0,5 pour toutes les étapes temporelles. Généralement, comme décrit dans l'article, ce poids doit augmenter progressivement de 0 à 1 au fur et à mesure que l'inférence progresse. Les utilisateurs sont encouragés à expérimenter et à fournir des plans de poids personnalisés qui tiennent compte du nombre d'étapes d'inférence et du comportement du modèle sous-jacent au fur et à mesure que le débruitage progresse.
  • low_frequency_weight_callback (Callable[[torch.nn.Module], float], par défaut None) — La fonction de rappel permettant de déterminer le poids utilisé pour mettre à l'échelle les mises à jour de basse fréquence. Si elle n'est pas fournie, le poids par défaut est 1,1 pour les timesteps compris dans la plage spécifiée (comme décrit dans l'article).
  • high_frequency_weight_callback (Callable[[torch.nn.Module], float], par défaut None) — La fonction de rappel permettant de déterminer le poids utilisé pour mettre à l'échelle les mises à jour de haute fréquence. Si elle n'est pas fournie, le poids par défaut est 1.1 pour les timesteps dans la plage spécifiée (comme décrit dans l'article).
  • tensor_format (str, par défaut "BCFHW") — Le format des tenseurs d’entrée. Il doit être l’un des formats suivants : "BCFHW", "BFCHW" ou "BCHW". Ce format est utilisé pour séparer les trames latentes individuelles afin de calculer les composantes basse et haute fréquence.
  • is_guidance_distilled (bool, par défaut False) — Indique si le modèle est distillé en guidance ou non. Si le modèle est distillé en guidance, FasterCache ne sera pas appliqué au niveau du débruiteur pour sauter le calcul de la branche inconditionnelle (car il n’y en a pas).
  • _unconditional_conditional_input_kwargs_identifiers (list[str], par défaut ("hidden_states", "encoder_hidden_states", "timestep", "attention_mask", "encoder_attention_mask")) — Les identifiants à utiliser pour correspondre aux kwargs d’entrée contenant les entrées non conditionnelles et conditionnelles concaténées par lot. Si le nom d’un kwarg d’entrée contient l’un de ces identifiants, FasterCache séparera les entrées en branches non conditionnelle et conditionnelle. Il doit s’agir d’une liste de noms exacts de kwargs d’entrée contenant les entrées non conditionnelles et conditionnelles concaténées par lot.

Configuration pour FasterCache.

diffusers.apply_faster_cache

< >

( module: Moduleconfig: FasterCacheConfig )

Paramètres

  • module (torch.nn.Module) — Le module pytorch auquel appliquer FasterCache. Il s'agit généralement d'une architecture de transformer prise en charge par Diffusers, telle que CogVideoXTransformer3DModel, mais des implémentations externes peuvent également fonctionner.
  • config (FasterCacheConfig) — La configuration à utiliser pour FasterCache.

Applique FasterCache à un pipeline donné.

Exemple :

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

Paramètres

  • threshold (float, par défaut 0.05) — Le seuil permettant de déterminer si un passage avant à travers toutes les couches du modèle est nécessaire. Un seuil plus élevé entraîne généralement un passage avant à travers un nombre plus faible de couches et une inférence plus rapide, mais peut entraîner une qualité de génération inférieure. Un seuil plus bas peut ne pas entraîner d'accélération significative de la génération. Le seuil est comparé à la différence absmean des résidus entre les sorties actuelles et les sorties mises en cache du premier bloc transformer. Si la différence est inférieure au seuil, le passage avant est ignoré.

Configuration pour First Block Cache.

diffusers.apply_first_block_cache

< >

( module: Moduleconfig: FirstBlockCacheConfig )

Paramètres

  • module (torch.nn.Module) — Le module pytorch auquel appliquer FBCache. Il s'agit généralement d'une architecture transformer prise en charge par Diffusers, telle que CogVideoXTransformer3DModel, mais des implémentations externes peuvent également fonctionner.
  • config (FirstBlockCacheConfig) — La configuration à utiliser pour appliquer la méthode FBCache.

Applique First Block Cache à un module donné.

First Block Cache s’appuie sur les idées de TeaCache. Il est beaucoup plus simple à implémenter de manière générique pour une large gamme de modèles et a été intégré en premier à des fins expérimentales.

Exemple :

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

Paramètres

  • cache_interval (int, par défaut 5) — L'intervalle entre les étapes de calcul complet. Après un calcul complet, les sorties mises en cache (prédites) sont réutilisées pendant ce nombre d'étapes de débruitage suivantes avant d'être actualisées par un nouveau passage avant complet.
  • disable_cache_before_step (int, par défaut 3) — L’indice de l’étape de débruitage avant lequel la mise en cache est désactivée, ce qui signifie qu’un calcul complet est effectué pour les étapes initiales (de 0 à disable_cache_before_step - 1) afin de collecter les données nécessaires aux approximations par séries de Taylor. Au cours de ces étapes, les facteurs de Taylor sont mis à jour, mais la mise en cache/prédictions ne sont pas appliquées. La mise en cache commence à cette étape.
  • disable_cache_after_step (int, facultatif, valeur par défaut None) — L’indice de l’étape de débruitage après laquelle la mise en cache est désactivée. Si défini, pour les étapes >= à cette valeur, tous les modules exécutent des calculs complets sans prédictions ni mises à jour d’état, garantissant ainsi la précision aux étapes ultérieures si nécessaire.
  • max_order (int, par défaut 1) — L'ordre maximal de la série de Taylor utilisée pour approximer les sorties du module. Des ordres plus élevés offrent de meilleures approximations, mais augmentent les calculs et l'utilisation de la mémoire.
  • taylor_factors_dtype (torch.dtype, par défaut torch.bfloat16) — Type de données utilisé pour le stockage et le calcul des facteurs de la série de Taylor. Une précision inférieure réduit la mémoire mais peut affecter la stabilité ; une précision supérieure améliore la précision au prix d'une consommation mémoire accrue.
  • skip_predict_identifiers (list[str], facultatif, valeur par défaut None) — Modèles regex (utilisant re.fullmatch) pour les noms de modules à placer en mode « skip ». Dans ce mode, le module est entièrement calculé lors des étapes initiales ou de rafraîchissement, mais renvoie un tenseur nul (correspondant à la forme enregistrée) lors des étapes de prédiction afin d'éviter le calcul à moindre coût.
  • cache_identifiers (list[str], facultatif, par défaut None) — Modèles d'expressions régulières (utilisant re.fullmatch) pour les noms de modules à placer en mode de mise en cache par séries de Taylor, où les sorties sont approximées et mises en cache pour réutilisation.
  • use_lite_mode (bool, facultatif, valeur par défaut False) — Active une variante allégée de TaylorSeer qui minimise l’utilisation de la mémoire en appliquant des motifs prédéfinis pour l’omission et la mise en cache (par exemple, omettre des blocs et mettre en cache les projections). Cela remplace tout inactive_identifiers ou active_identifiers personnalisé.

Configuration pour le cache TaylorSeer. Voir : https://huggingface.co/papers/2503.06923

Remarques :

  • Les motifs sont appariés à l'aide de re.fullmatch sur le nom du module.
  • Si skip_predict_identifiers ou cache_identifiers sont fournis, seuls les modules correspondants sont interceptés.
  • Si aucun des deux n'est fourni, tous les modules de type attention sont accrochés par défaut.

Exemple d'utilisation inactive et active :

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 )

Valeur factice pour un chemin pointé (par exemple torch.float32) : les chaînes d’accès aux attributs et les appels se comportent comme des décorateurs de pass-through, repr est le chemin pointé, et son utilisation comme classe de base substitue une base de type ordinaire (PEP 560 __mro_entries__), de sorte que les vraies sous-classes conservent un métaclasse normal et que inspect.signature lit leur __init__ réel plutôt que celui d’une valeur factice.

diffusers.apply_taylorseer_cache

< >

( module: Moduleconfig: TaylorSeerCacheConfig )

Paramètres

  • module (torch.nn.Module) — La sous-arborescence du modèle à laquelle appliquer les hooks.
  • config (TaylorSeerCacheConfig) — Configuration du cache.

Applique le cache TaylorSeer à un pipeline donné (généralement le transformer / UNet).

Cette fonction accroche les modules sélectionnés du modèle afin d’activer la mise en cache ou le saut en fonction de la configuration fournie, réduisant ainsi les calculs redondants dans les boucles de débruitage de diffusion.

Exemple :

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

Paramètres

  • threshold (float, par défaut 0.06) — Le seuil pour l'erreur accumulée. Si l'erreur accumulée est inférieure à ce seuil, le calcul du bloc est ignoré. Un seuil plus élevé permet un saut plus agressif (plus rapide) mais peut dégrader la qualité.
  • max_skip_steps (int, par défaut 3) — Le nombre maximal d'étapes consécutives pouvant être ignorées (K dans l'article).
  • retention_ratio (float, par défaut 0.2) — La fraction des étapes initiales pendant laquelle le saut est désactivé afin d’assurer la stabilité. Par exemple, si num_inference_steps vaut 28 et retention_ratio vaut 0,2, les 6 premières étapes ne seront jamais sautées.
  • num_inference_steps (int, par défaut 28) — Le nombre d'étapes d'inférence utilisées dans le pipeline. Cette valeur est requise pour interpoler correctement mag_ratios.
  • mag_ratios (torch.Tensor, facultatif) — Les rapports d'amplitude précalculés pour le modèle. Ils dépendent du point de contrôle. S'ils ne sont pas fournis, vous devez définir calibrate=True pour les calculer pour votre modèle spécifique. Pour les modèles Flux, vous pouvez utiliser diffusers.hooks.mag_cache.FLUX_MAG_RATIOS.
  • calibrate (bool, par défaut False) — Si True, active le mode de calibration. Dans ce mode, aucun bloc n’est ignoré. À la place, le hook calcule les rapports d’amplitude pour l’exécution en cours et les journalise à la fin. Utilisez cette option pour obtenir les mag_ratios de nouveaux modèles ou planificateurs.

Configuration pour MagCache.

diffusers.apply_mag_cache

< >

( module: Moduleconfig: MagCacheConfig )

Paramètres

  • module (torch.nn.Module) — Le module auquel appliquer MagCache.
  • config (MagCacheConfig) — La configuration de MagCache.

Applique MagCache à un module donné (généralement un 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 )

Paramètres

  • threshold (float, par défaut 0.25) — Budget relatif L1 cumulé. Des valeurs plus élevées réutilisent le cache plus souvent.
  • residual_order (int, par défaut 1) — Ordre utilisé pour prédire le résidu du transformer. 0 réutilise directement le résidu le plus récent et 1 effectue une extrapolation linéaire à partir des deux dernières exécutions complètes.
  • retention_steps (int, par défaut 1) — Nombre d'étapes initiales du planificateur qui s'exécutent toujours en totalité.
  • cache_end_steps (int, par défaut 1) — Nombre d'étapes finales du planificateur qui s'exécutent toujours en totalité.
  • max_consecutive_cached (int, par défaut 2) — Nombre maximal de réutilisations consécutives de résidus par contexte de cache avant de forcer une exécution complète. 0 désactive cette limite.
  • power_exp (float, par défaut 3.0) — Exposant de la loi a priori de puissance du signal propre SEA. SeaCache utilise 3.0 pour les caractéristiques vidéo.
  • raw_vision_callback (Callable, facultatif) — Adaptateur de modèle avancé qui renvoie les latents visuels constituant la sortie générée, chacun ayant la forme (C, T, H, W). Incluez les images de conditionnement propres dans la trajectoire de sortie, mais excluez les indices visuels distincts qui ne font pas partie de la sortie. S’il est omis, un adaptateur intégré est utilisé si disponible.

Configuration pour SeaCache.

SeaCache est désactivé par défaut et ne s'active qu'après que cette configuration a été transmise à transformer.enable_cache(config).

SeaCache compare les indicateurs Spectral-Evolution-Aware (SEA) entre les étapes du planificateur. Si leur variation relative accumulée reste inférieure à threshold, la pile de blocs transformer répétés est remplacée par un résidu mis en cache. Des adaptateurs spécifiques au modèle peuvent étendre la frontière du résidu au-delà de ces blocs. D'autres transformers vidéo peuvent utiliser le chemin générique en enregistrant leurs métadonnées de bloc et en fournissant raw_vision_callback ; leur pipeline doit entrer dans un cache_context pour chaque trajectoire de transformer.

Exemple :

>>> from diffusers import Cosmos3OmniPipeline, SeaCacheConfig

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

diffusers.apply_sea_cache

< >

( module: Moduleconfig: SeaCacheConfig )

Paramètres

  • module (torch.nn.Module) — Module Transformer à mettre en cache.
  • config (SeaCacheConfig) — Configuration de SeaCache.

Appliquer SeaCache à un transformateur pris en charge.

SeaCache réutilise un résidu mis en cache pour la pile de blocs répétés d’un transformeur. Les adaptateurs de modèle peuvent personnaliser l’extraction des indicateurs et la frontière du résidu ; le chemin générique utilise les métadonnées de bloc enregistrées et raw_vision_callback. Les paramètres de compatibilité et de cache doivent être validés pour chaque modèle.

Update on GitHub

←Fonctions d'activation personnalisées Couches de normalisation personnalisées→