Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /ru /api /cache.md
mishig
1 day ago
preview code
download
raw
48.7 kB
# Методы кэширования

Методы кэширования ускоряют диффузионные трансформеры, сохраняя и повторно используя промежуточные результаты определённых слоёв, таких как слои внимания и полносвязные слои, вместо их пересчёта на каждом шаге инференса.

## CacheMixin[[diffusers.CacheMixin]]

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cache_utils.py#L23)

Класс для включения/отключения методов кэширования в диффузионных моделях.

Поддерживаемые методы кэширования:
- [Pyramid Attention Broadcast](https://huggingface.co/papers/2408.12588)
- [FasterCache](https://huggingface.co/papers/2410.19355)
- [FirstBlockCache](https://github.com/chengzeyi/ParaAttention/blob/7a266123671b55e7e5a2fe9af3121f07a36afc78/README.md#first-block-cache-our-dynamic-caching)
- [SeaCache](https://huggingface.co/papers/2602.18993)

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

```python
cache_context(name: str, **kwargs)
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cache_utils.py#L181)

Контекстный менеджер, предоставляющий информацию для управления кэшем.

`name` — это имя вызова денузинга, обычно `"cond"` или `"uncond"`. Именованные аргументы описывают, на каком этапе находится цикл денузинга — см. `CacheContext` для списка поддерживаемых полей, например `cache_context("cond", step_index=i, sigma=sigma)`.

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

```python
enable_cache(config)
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cache_utils.py#L40)

**Параметры:**

config (`PyramidAttentionBroadcastConfig | FasterCacheConfig | FirstBlockCacheConfig | SeaCacheConfig | TextKVCacheConfig`) : конфигурация для применения техники кэширования. В настоящее время поддерживаются следующие техники кэширования: - [PyramidAttentionBroadcastConfig](/docs/diffusers/main/ru/api/cache#diffusers.PyramidAttentionBroadcastConfig) - [FasterCacheConfig](/docs/diffusers/main/ru/api/cache#diffusers.FasterCacheConfig) - [FirstBlockCacheConfig](/docs/diffusers/main/ru/api/cache#diffusers.FirstBlockCacheConfig) - [SeaCacheConfig](/docs/diffusers/main/ru/api/cache#diffusers.SeaCacheConfig) - [TextKVCacheConfig](/docs/diffusers/main/ru/api/cache#diffusers.TextKVCacheConfig)

Включите методы кэширования для модели.

Пример:

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/pyramid_attention_broadcast.py#L40)

**Параметры:**

spatial_attention_block_skip_range (`int`, *optional*, по умолчанию `None`) : Количество раз, когда конкретный пространственный broadcast внимания пропускается перед вычислением состояний внимания для повторного использования. Если это значение установлено в `N`, вычисление внимания будет пропущено `N - 1` раз (то есть будут повторно использованы старые состояния внимания) перед тем, как снова вычислить новые состояния внимания.

temporal_attention_block_skip_range (`int`, *optional*, по умолчанию `None`) : Количество раз, когда конкретное временное внимание (temporal attention) пропускается перед вычислением состояний внимания для повторного использования. Если это значение установлено в `N`, вычисление внимания будет пропущено `N - 1` раз (то есть будут повторно использованы старые состояния внимания) перед тем, как снова вычислить новые состояния внимания.

cross_attention_block_skip_range (`int`, *optional*, по умолчанию `None`) : Количество раз, когда конкретный broadcast кросс-внимания пропускается перед вычислением состояний внимания для повторного использования. Если это значение установлено в `N`, вычисление внимания будет пропущено `N - 1` раз (то есть будут повторно использованы старые состояния внимания) перед тем, как снова вычислить новые состояния внимания.

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, ...]`) : Идентификаторы, по которым сверяются имена слоёв, чтобы определить, является ли слой слоем пространственного внимания.
temporal_attention_block_identifiers (`tuple[str, ...]`) : Идентификаторы, по которым сверяются имена слоёв, чтобы определить, является ли слой слоем временного внимания.

cross_attention_block_identifiers (`tuple[str, ...]`) : Идентификаторы, по которым сверяются имена слоёв, чтобы определить, является ли слой слоем кросс-внимания.
Конфигурация для Pyramid Attention Broadcast.
#### diffusers.apply_pyramid_attention_broadcast[[diffusers.apply_pyramid_attention_broadcast]]
```python
diffusers.apply_pyramid_attention_broadcast(module: Module, config: PyramidAttentionBroadcastConfig)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/pyramid_attention_broadcast.py#L181)
**Параметры:**
module (`torch.nn.Module`) : модуль, к которому применяется Pyramid Attention Broadcast.
config (`PyramidAttentionBroadcastConfig | None`, `optional`, по умолчанию `None`) : Конфигурация, используемая для Pyramid Attention Broadcast.
Примените [Pyramid Attention Broadcast](https://huggingface.co/papers/2408.12588) к указанному конвейеру.
PAB — это метод аппроксимации внимания, который использует сходство состояний внимания между временными шагами для снижения вычислительных затрат на вычисление внимания. Ключевой вывод из статьи состоит в том, что сходство внимания в слоях кросс-внимания между временными шагами высокое, тогда как в временных и пространственных слоях оно ниже. Это позволяет пропускать вычисление внимания в слоях кросс-внимания чаще, чем во временных и пространственных слоях. Таким образом, применение PAB ускоряет процесс инференса.
Пример:
```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'))
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/faster_cache.py#L50)
**Параметры:**
spatial_attention_block_skip_range (`int`, по умолчанию `2`) : Вычислять состояния внимания каждые `N` итераций. Если это значение установлено в `N`, вычисление внимания будет пропускаться `N - 1` раз (то есть будут повторно использоваться кэшированные состояния внимания), прежде чем снова вычислить новые состояния внимания.
temporal_attention_block_skip_range (`int`, *optional*, по умолчанию `None`) : Вычислять состояния внимания каждые `N` итераций. Если это значение установлено в `N`, вычисление внимания будет пропускаться `N - 1` раз (т. е. будут повторно использоваться кэшированные состояния внимания), прежде чем снова вычислить новые состояния внимания.
spatial_attention_timestep_skip_range (`tuple[float, float]`, по умолчанию `(-1, 681)`) : Диапазон временных шагов, в пределах которого вычисление пространственного внимания можно пропустить без значительной потери качества. Это значение определяется пользователем на основе используемой модели. Первое значение в кортеже — нижняя граница, второе — верхняя. Как правило, временные шаги диффузии для удаления шума находятся в обратном диапазоне от 0 до 1000 (то есть удаление шума начинается с шага 1000 и заканчивается на шаге 0). Для значений по умолчанию это означает, что пропуск вычисления пространственного внимания будет применяться только после достижения временного шага удаления шума 681 и продолжится до конца процесса удаления шума.
temporal_attention_timestep_skip_range (`tuple[float, float]`, *optional*, по умолчанию `None`) : Диапазон временных шагов, в пределах которого вычисление временного внимания можно пропустить без значительной потери качества. Это значение определяется пользователем на основе используемой модели. Первое значение в кортеже — нижняя граница, второе — верхняя. Как правило, временные шаги диффузии для удаления шума находятся в обратном диапазоне от 0 до 1000 (то есть удаление шума начинается с шага 1000 и заканчивается на шаге 0).
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`) : обрабатывать безусловный переход каждые `N` итераций. Если установлено значение `N`, вычисление безусловного перехода будет пропускаться `N - 1` раз (то есть переиспользуются кэшированные состояния безусловного перехода), прежде чем снова вычислить новые состояния безусловного перехода.

unconditional_batch_timestep_skip_range (`tuple[float, float]`, по умолчанию `(-1, 641)`) : Диапазон временных шагов, в пределах которого вычисление безусловной ветви можно пропустить без значительной потери качества. Это значение определяется пользователем на основе базовой модели. Первое значение в кортеже — нижняя граница, второе — верхняя граница.

spatial_attention_block_identifiers (`tuple[str, ...]`, по умолчанию `("blocks.*attn1", "transformer_blocks.*attn1", "single_transformer_blocks.*attn1")`) : Идентификаторы для сопоставления с блоками пространственного внимания в модели. Если имя блока содержит один из этих идентификаторов, к этому блоку будет применён FasterCache. Это могут быть полные имена слоёв, частичные имена слоёв или регулярные выражения. Сопоставление всегда выполняется с помощью регулярного выражения.

temporal_attention_block_identifiers (`tuple[str, ...]`, по умолчанию `("temporal_transformer_blocks.*attn1",)`) : Идентификаторы для сопоставления с блоками временного внимания в модели. Если имя блока содержит один из этих идентификаторов, к этому блоку будет применён FasterCache. Это могут быть полные имена слоёв, частичные имена слоёв или регулярные выражения. Сопоставление всегда выполняется с помощью регулярного выражения.
attention_weight_callback (`Callable[[torch.nn.Module], float]`, по умолчанию `None`) : Функция обратного вызова для определения веса, на который масштабируются выходные значения внимания. Эта функция должна принимать модуль внимания в качестве входного параметра и возвращать значение типа float. Используется для приближения безусловной ветви по выходным значениям условной ветви. Если не задана, вес по умолчанию составляет 0,5 для всех временных шагов. Как правило, согласно описанию в статье, этот вес должен постепенно увеличиваться с 0 до 1 по мере продвижения инференса. Пользователям рекомендуется экспериментировать и задавать собственные расписания весов, учитывающие количество шагов инференса и поведение базовой модели по мере продвижения процесса денойзинга.
low_frequency_weight_callback (`Callable[[torch.nn.Module], float]`, по умолчанию `None`) : Функция обратного вызова для определения веса, на который масштабируются обновления с низкой частотой. Если не задана, по умолчанию используется вес 1.1 для шагов времени в указанном диапазоне (как описано в статье).

high_frequency_weight_callback (`Callable[[torch.nn.Module], float]`, по умолчанию `None`) : Функция обратного вызова для определения веса, на который масштабируются обновления с высокой частотой. Если не задана, по умолчанию используется вес 1.1 для шагов времени в указанном диапазоне (как описано в статье).
tensor_format (`str`, по умолчанию `"BCFHW"`) : Формат входных тензоров. Должен быть одним из `"BCFHW"`, `"BFCHW"` или `"BCHW"`. Формат используется для разделения отдельных латентных кадров, чтобы вычислить компоненты низкой и высокой частоты.

is_guidance_distilled (`bool`, по умолчанию `False`) : Указывает, является ли модель дистиллированной с помощью guidance. Если модель дистиллирована с помощью guidance, FasterCache не применяется на уровне denoiser для пропуска вычисления безусловной ветви (поскольку она отсутствует).

_unconditional_conditional_input_kwargs_identifiers (`list[str]`, по умолчанию `("hidden_states", "encoder_hidden_states", "timestep", "attention_mask", "encoder_attention_mask")`) : Идентификаторы для сопоставления входных kwargs, содержащих батч-конкатенированные безусловные и условные входы. Если имя входного kwargs содержит один из этих идентификаторов, FasterCache разделит входы на безусловную и условную ветви. Это должно быть список точных имён входных kwargs, содержащих батч-конкатенированные безусловные и условные входы.
Конфигурация для [FasterCache](https://huggingface.co/papers/2410.19355).
#### diffusers.apply_faster_cache[[diffusers.apply_faster_cache]]
```python
diffusers.apply_faster_cache(module: Module, config: FasterCacheConfig)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/faster_cache.py#L486)
**Параметры:**
module (`torch.nn.Module`) : модуль PyTorch, к которому применяется FasterCache. Как правило, это должна быть поддерживаемая в Diffusers архитектура трансформера, например `CogVideoXTransformer3DModel`, но могут работать и внешние реализации.
config (`FasterCacheConfig`) : конфигурация, используемая для FasterCache.
Применяет [FasterCache](https://huggingface.co/papers/2410.19355) к указанному конвейеру.
Пример:
```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)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/first_block_cache.py#L33)
**Параметры:**
threshold (`float`, по умолчанию `0.05`) : Порог, определяющий необходимость прямого прохода через все слои модели. Более высокий порог обычно приводит к прямому проходу через меньшее количество слоёв и более быстрому выводу, но может ухудшить качество генерации. Более низкий порог может не дать значительного ускорения генерации. Порог сравнивается с абсолютным средним значением разницы остатков между текущим и кэшированным выходом первого блока трансформера. Если разница ниже порога, прямой проход пропускается.
Конфигурация для [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)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/first_block_cache.py#L193)
**Параметры:**
module (`torch.nn.Module`) : модуль PyTorch, к которому применяется FBCache. Как правило, это должна быть поддерживаемая в Diffusers трансформерная архитектура, например `CogVideoXTransformer3DModel`, но могут работать и внешние реализации.
config (`FirstBlockCacheConfig`) : конфигурация для применения метода FBCache.
Применяет [First Block Cache](https://github.com/chengzeyi/ParaAttention/blob/4de137c5b96416489f06e43e19f2c14a772e28fd/README.md#first-block-cache-our-dynamic-caching) к заданному модулю.
First Block Cache основан на идеях [TeaCache](https://huggingface.co/papers/2411.19108). Он значительно проще в реализации для широкого круга моделей и был интегрирован в первую очередь в экспериментальных целях.
Пример:
```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)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/taylorseer_cache.py#L26)
**Параметры:**
cache_interval (`int`, по умолчанию `5`) : Интервал между полными шагами вычислений. После полного вычисления кэшированные (предсказанные) результаты переиспользуются для этого количества последующих шагов денойзинга, прежде чем обновляются новым полным проходом вперёд.
disable_cache_before_step (`int`, по умолчанию `3`) : Индекс шага денойзинга, до которого кэширование отключено, то есть для начальных шагов (от 0 до disable_cache_before_step - 1) выполняется полный вычислительный процесс для сбора данных для приближений рядомми Тейлора. На этих шагах обновляются коэффициенты Тейлора, но кэширование/предсказания не применяются. Кэширование начинается с этого шага.
disable_cache_after_step (`int`, *optional*, по умолчанию `None`) : Индекс шага денойзинга, после которого кэширование отключается. Если значение задано, то для шагов >= этого значения все модули выполняют полные вычисления без предсказаний или обновлений состояния, что обеспечивает точность на поздних этапах при необходимости.
max_order (`int`, по умолчанию `1`) : Наивысший порядок разложения в ряд Тейлора для аппроксимации выходов модуля. Более высокие порядки обеспечивают более точную аппроксимацию, но увеличивают вычислительные затраты и потребление памяти.
taylor_factors_dtype (`torch.dtype`, по умолчанию `torch.bfloat16`) : Тип данных, используемый для хранения и вычисления факторов ряда Тейлора. Более низкая точность уменьшает потребление памяти, но может повлиять на устойчивость; более высокая точность повышает точность вычислений за счёт увеличения потребления памяти.
skip_predict_identifiers (`list[str]`, *необязательный*, по умолчанию `None`) : Регулярные выражения (с использованием `re.fullmatch`) для имён модулей, которые следует помечать как «skip» в режиме «cache». В этом режиме модуль полностью вычисляется на начальных шагах или при обновлении, но на шагах предсказания возвращает нулевой тензор (с совпадающей записанной формой), чтобы дёшево пропустить вычисления.
cache_identifiers (`list[str]`, *необязательный*, по умолчанию `None`) : Регулярные выражения (с использованием `re.fullmatch`) для имён модулей, которые нужно поместить в режим кэширования по ряду Тейлора, где выходные значения аппроксимируются и кэшируются для повторного использования.
use_lite_mode (`bool`, *необязательный*, по умолчанию `False`) : Включает облегчённый вариант TaylorSeer, который минимизирует использование памяти, применяя предопределённые паттерны для пропуска и кэширования (например, пропуск блоков и кэширование проекций). Это переопределяет любые пользовательские `inactive_identifiers` или `active_identifiers`.
Конфигурация для кэша TaylorSeer. См.: https://huggingface.co/papers/2503.06923
Примечания:
- Сопоставление шаблонов выполняется с помощью `re.fullmatch` по имени модуля.
- Если указаны `skip_predict_identifiers` или `cache_identifiers`, хуки устанавливаются только для соответствующих модулей.
- Если ни один из них не указан, по умолчанию перехватываются все модули, подобные attention.
Пример неактивного и активного использования:
```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)
```

Мок-значение для пути с точками (например, `torch.float32`): цепочки доступа к атрибутам и вызовы работают как пропускные декораторы, `repr` — это путь с точками, а использование в качестве базового класса подменяет его обычным базовым классом `type` (PEP 560 `__mro_entries__`), благодаря чему реальные дочерние классы сохраняют обычный метакласс, а `inspect.signature` читает их реальный `__init__`, а не мок.

#### diffusers.apply_taylorseer_cache[[diffusers.apply_taylorseer_cache]]

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/taylorseer_cache.py#L261)

**Параметры:**

module (torch.nn.Module) : Поддерево модели, к которому следует применить хуки.

config (TaylorSeerCacheConfig) : Настройки для кэша.

Применяет кэш TaylorSeer к указанному конвейеру (как правило, трансформеру / UNet).

Эта функция подключает выбранные модули в модели для включения кэширования или пропуска на основе предоставленной конфигурации, что снижает избыточные вычисления в циклах денуазинга диффузии.

Пример:
```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)
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/mag_cache.py#L84)

**Параметры:**

threshold (`float`, по умолчанию `0.06`) : Порог для накопленной ошибки. Если накопленная ошибка ниже этого порога, вычисление блока пропускается. Более высокий порог позволяет более агрессивно пропускать вычисления (быстрее), но может ухудшить качество.

max_skip_steps (`int`, по умолчанию `3`) : максимальное количество последовательных шагов, которые можно пропустить (K в статье).

retention_ratio (`float`, по умолчанию `0.2`) : Доля начальных шагов, на протяжении которых пропуск отключён для обеспечения стабильности. Например, если `num_inference_steps` равно 28, а `retention_ratio` равно 0.2, первые 6 шагов никогда не пропускаются.

num_inference_steps (`int`, по умолчанию `28`) : Количество шагов инференса, используемых в конвейере. Это необходимо для корректной интерполяции `mag_ratios`.

mag_ratios (`torch.Tensor`, *необязательный*) : Предварительно вычисленные коэффициенты амплитуды для модели. Они зависят от контрольной точки. Если не указаны, необходимо установить `calibrate=True`, чтобы вычислить их для вашей конкретной модели. Для моделей Flux можно использовать `diffusers.hooks.mag_cache.FLUX_MAG_RATIOS`.

calibrate (`bool`, по умолчанию `False`) : Если True, включается режим калибровки. В этом режиме блоки не пропускаются. Вместо этого хук вычисляет отношения амплитуд для текущего запуска и записывает их в журнал в конце. Используйте этот режим, чтобы получить `mag_ratios` для новых моделей или планировщиков.

Конфигурация для [MagCache](https://github.com/Zehong-Ma/MagCache).

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/mag_cache.py#L398)

**Параметры:**

module (`torch.nn.Module`) : модуль, к которому нужно применить MagCache.

config (`MagCacheConfig`) : конфигурация MagCache.

Применяет MagCache к заданному модулю (как правило, 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)
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/sea_cache.py#L38)

**Параметры:**

threshold (`float`, по умолчанию `0.25`) : Накопленный относительный L1-бюджет. Большие значения приводят к более частому повторному использованию кэша.

residual_order (`int`, по умолчанию `1`) : Порядок, используемый для предсказания остаточного сигнала трансформера. `0` напрямую переиспользует самый последний остаточный сигнал, а `1` линейно экстраполирует его по двум последним полным выполнениям.
retention_steps (`int`, по умолчанию `1`) : Количество начальных шагов планировщика, которые всегда выполняются полностью.

cache_end_steps (`int`, по умолчанию `1`) : Количество последних шагов планировщика, которые всегда выполняются полностью.

max_consecutive_cached (`int`, по умолчанию `2`) : Максимальное количество последовательных повторных использований остаточных значений в контексте кэша перед принудительным полным выполнением. `0` отключает ограничение.

power_exp (`float`, по умолчанию `3.0`) : Показатель степени априорного распределения мощности чистого сигнала SEA. SeaCache использует `3.0` для видеособразов.
raw_vision_callback (`Callable`, *необязательный*) : Продвинутый адаптер модели, возвращающий визуальные латенты, формирующие сгенерированный вывод, каждый из которых имеет форму `(C, T, H, W)`. Включите чистые кадры условий в траекторию вывода, но исключите отдельные визуальные подсказки, не являющиеся частью вывода. Если параметр не указан, используется встроенный адаптер, если он доступен.
Конфигурация для [SeaCache](https://huggingface.co/papers/2602.18993).
SeaCache отключён по умолчанию и активируется только после передачи этой конфигурации в `transformer.enable_cache(config)`.

SeaCache сравнивает индикаторы Spectral-Evolution-Aware (SEA) между шагами планировщика. Если их накопленное относительное изменение остается ниже `threshold`, повторяющаяся стопка блоков трансформера заменяется кэшированным остатком. Адаптеры, специфичные для модели, могут расширять границу остатка за пределы этих блоков. Другие видео-трансформеры могут использовать универсальный путь, зарегистрировав метаданные своих блоков и предоставив `raw_vision_callback`; их конвейер должен входить в `cache_context` для каждой траектории трансформера.

Пример:
```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)
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/sea_cache.py#L980)

**Параметры:**

module (`torch.nn.Module`) : модуль Transformer для кэширования.

config (`SeaCacheConfig`) : конфигурация SeaCache.

Примените SeaCache к поддерживаемому трансформеру.

SeaCache повторно использует кэшированный остаток для повторяющейся стековой структуры блоков трансформера. Адаптеры модели могут настраивать извлечение индикаторов и границу остатка; общий путь использует зарегистрированные метаданные блоков и `raw_vision_callback`. Параметры совместимости и кэширования необходимо проверять для каждой модели.

## TextKVCacheConfig[[diffusers.TextKVCacheConfig]]

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/text_kv_cache.py#L27)

Включите точное (без потерь) кэширование текста K/V для трансформерных моделей.

Предварительно вычисляет проекции ключей и значений текста для каждого блока один раз перед циклом денойзинга и повторно использует их на всех шагах. Положительные и отрицательные промпты различаются с помощью стабильного ключа кэша, который захватывается хуком на уровне трансформера до выделения промежуточных тензоров.

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/text_kv_cache.py#L157)
Xet Storage Details

Size:: 48.7 kB
Xet hash:: 2d77ea4ccb1e85dfee6bdb7c51e7b6233edb703e267ba4641c0ba8d1588d4e16
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.