Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /fr /api /cache.md
mishig
1 day ago
preview code
download
raw
36.2 kB
# 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[[diffusers.CacheMixin]]

#### diffusers.CacheMixin[[diffusers.CacheMixin]]

```python
diffusers.CacheMixin()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cache_utils.py#L23)

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 :
- [Diffusion de l'attention pyramidale](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)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cache_utils.py#L181)

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 trouve la boucle de débruitage — voir `CacheContext` pour les champs acceptés, par exemple `cache_context("cond", step_index=i, sigma=sigma)`.

#### enable_cache[[diffusers.CacheMixin.enable_cache]]

```python
enable_cache(config)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cache_utils.py#L40)

**Paramètres :**

config (`PyramidAttentionBroadcastConfig | FasterCacheConfig | FirstBlockCacheConfig | SeaCacheConfig | TextKVCacheConfig`) : La configuration pour appliquer la technique de mise en cache. Les techniques de mise en cache actuellement prises en charge sont : - [PyramidAttentionBroadcastConfig](/docs/diffusers/main/fr/api/cache#diffusers.PyramidAttentionBroadcastConfig) - [FasterCacheConfig](/docs/diffusers/main/fr/api/cache#diffusers.FasterCacheConfig) - [FirstBlockCacheConfig](/docs/diffusers/main/fr/api/cache#diffusers.FirstBlockCacheConfig) - [SeaCacheConfig](/docs/diffusers/main/fr/api/cache#diffusers.SeaCacheConfig) - [TextKVCacheConfig](/docs/diffusers/main/fr/api/cache#diffusers.TextKVCacheConfig)

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

Exemple :

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/pyramid_attention_broadcast.py#L40)

**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 spécifique d'attention temporelle 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'un diffusion spécifique de l'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 pas temporels à ignorer dans la couche d'attention spatiale. Les calculs d'attention seront conditionnellement ignorés si le pas temporel 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 timesteps à ignorer dans la couche d'attention temporelle. Les calculs d'attention seront conditionnellement ignorés si le timestep 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 pas de temps à ignorer dans la couche d'attention croisée. Les calculs d'attention seront conditionnellement ignorés si le pas de temps 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[[diffusers.apply_pyramid_attention_broadcast]]
```python
diffusers.apply_pyramid_attention_broadcast(module: Module, config: PyramidAttentionBroadcastConfig)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/pyramid_attention_broadcast.py#L181)
**Paramètres :**
module (`torch.nn.Module`) : le module auquel appliquer Pyramid Attention Broadcast.
config (`PyramidAttentionBroadcastConfig | None`, `optional`, defaults to `None`) : La configuration à utiliser pour Pyramid Attention Broadcast.
Appliquer [Pyramid Attention Broadcast](https://huggingface.co/papers/2408.12588) à un pipeline donné.
PAB est une méthode d’approximation de l’attention qui exploite la similarité des états d’attention entre les timesteps 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 de cross-attention entre les timesteps 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 de cross-attention plus fréquemment que dans les couches temporelles et spatiales. L’application de PAB accélère donc le processus d’inférence.
Exemple :
```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'))
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/faster_cache.py#L50)
**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 pas de temps dans laquelle le calcul de l'attention temporelle peut être ignoré sans perte significative de qualité. Cette plage doit être déterminée par l'utilisateur en fonction du modèle sous-jacent. La première valeur du tuple est la borne inférieure et la seconde valeur est la borne supérieure. Typiquement, les pas de temps de diffusion pour le débruitage sont dans la plage inversée de 0 à 1000 (c'est-à-dire que le débruitage commence au pas de temps 1000 et se termine au pas de temps 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 seconde 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 de l'échelle des poids haute fréquence est appliquée. La première valeur du tuple est la borne inférieure et la seconde 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 poids utilisé pour mettre à l'échelle les mises à jour de basse fréquence. Il sert à 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`) : Traiter 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 branche inconditionnelle mis en cache seront réutilisés) avant de recalculer les nouveaux états de branche inconditionnelle.

unconditional_batch_timestep_skip_range (`tuple[float, float]`, par défaut `(-1, 641)`) : La plage de pas temporels dans laquelle le calcul de la branche inconditionnelle peut être ignoré sans perte significative de qualité. Cette plage doit être déterminée 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 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 pour déterminer le poids utilisé pour mettre à l'échelle les sorties d'attention. 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 pour 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 pas de temps 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 pour 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 pas de temps 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 s'agir de `"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é par guidage ou non. Si le modèle est distillé par guidage, FasterCache ne sera pas appliqué au niveau du débruiteur pour sauter le calcul de la branche non conditionnelle (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](https://huggingface.co/papers/2410.19355).
#### diffusers.apply_faster_cache[[diffusers.apply_faster_cache]]
```python
diffusers.apply_faster_cache(module: Module, config: FasterCacheConfig)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/faster_cache.py#L486)
**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](https://huggingface.co/papers/2410.19355) à un pipeline donné.
Exemple :
```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)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/first_block_cache.py#L33)
**Paramètres :**
threshold (`float`, par défaut `0.05`) : Le seuil pour 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 réduit 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 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](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)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/first_block_cache.py#L193)
**Paramètres :**
module (`torch.nn.Module`) : le module pytorch auquel appliquer FBCache. 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 (`FirstBlockCacheConfig`) : La configuration à utiliser pour appliquer la méthode FBCache.
Applique [First Block Cache](https://github.com/chengzeyi/ParaAttention/blob/4de137c5b96416489f06e43e19f2c14a772e28fd/README.md#first-block-cache-our-dynamic-caching) à un module donné.
First Block Cache s’appuie sur les idées de [TeaCache](https://huggingface.co/papers/2411.19108). 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 :
```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)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/taylorseer_cache.py#L26)
**Paramètres :**
cache_interval (`int`, par défaut `5`) : L'intervalle entre les étapes de calcul complètes. Après un calcul complet, les sorties mises en cache (prédites) sont réutilisées pour ce nombre d'étapes de débruitage suivantes avant d'être rafraîchies par un nouveau passage avant complet.
disable_cache_before_step (`int`, par défaut `3`) : L'indice de l'étape de débruitage avant laquelle la mise en cache est désactivée, ce qui signifie qu'un calcul complet est effectué pour les étapes initiales (0 à disable_cache_before_step - 1) afin de collecter les données pour les 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 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 supérieurs 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 l'exactitude au prix d'une consommation mémoire accrue.
skip_predict_identifiers (`list[str]`, *facultatif*, valeur par défaut `None`) : motifs d'expressions régulières (utilisant `re.fullmatch`) pour les noms de modules à placer en mode « skip » dans le mode « cache ». 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*, valeur par défaut `None`) : Motifs 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 du 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 :
```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)
```

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[[diffusers.apply_taylorseer_cache]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/taylorseer_cache.py#L261)

**Paramètres :**

module (torch.nn.Module) : Sous-arbre du modèle auquel appliquer les hooks.

config (TaylorSeerCacheConfig) : Configuration du cache.

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

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

Exemple :
```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)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/mag_cache.py#L84)

**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` est 28 et que `retention_ratio` est 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. Cela est nécessaire 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` pour de nouveaux modèles ou planificateurs.

Configuration pour [MagCache](https://github.com/Zehong-Ma/MagCache).

#### diffusers.apply_mag_cache[[diffusers.apply_mag_cache]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/mag_cache.py#L398)

**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[[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)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/sea_cache.py#L38)

**Paramètres :**

threshold (`float`, par défaut `0.25`) : Budget relatif-L1 accumulé. 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 entier.

cache_end_steps (`int`, par défaut `1`) : Nombre d'étapes finales du planificateur qui s'exécutent toujours en entier.

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 l'a priori de puissance du signal propre SEA. SeaCache utilise `3.0` pour les fonctionnalités vidéo.
raw_vision_callback (`Callable`, *facultatif*) : Adaptateur de modèle avancé renvoyant les latents visuels formant la sortie générée, chacun ayant la forme `(C, T, H, W)`. Inclure les images de conditionnement propres dans la trajectoire de sortie, mais exclure 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](https://huggingface.co/papers/2602.18993).
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 transformeurs 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 transformeurs vidéo peuvent utiliser le chemin générique en enregistrant leurs métadonnées de blocs et en fournissant `raw_vision_callback` ; leur pipeline doit entrer dans un `cache_context` pour chaque trajectoire de transformeur.

Exemple :
```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)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/sea_cache.py#L980)

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

## TextKVCacheConfig[[diffusers.TextKVCacheConfig]]

#### diffusers.TextKVCacheConfig[[diffusers.TextKVCacheConfig]]

```python
diffusers.TextKVCacheConfig()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/text_kv_cache.py#L27)

Activer la mise en cache exacte (sans perte) du texte K/V pour les modèles transformers.

Pré-calcule les projections de clés et de valeurs par bloc de texte une seule fois avant la boucle de débruitage et les réutilise à toutes les étapes. Les prompts positifs et négatifs sont distingués par une clé de cache stable capturée par un hook au niveau du transformeur avant toute allocation de tenseurs intermédiaires.

#### diffusers.apply_text_kv_cache[[diffusers.apply_text_kv_cache]]

```python
diffusers.apply_text_kv_cache(module: Module, config: TextKVCacheConfig)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/text_kv_cache.py#L157)
Xet Storage Details

Size:: 36.2 kB
Xet hash:: 0d9d4b43119d299c344a673706690ae7d6511f76c32c897b5c9705d63fcff867
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.