# Metode peng-cache-an

Metode cache mempercepat diffusion transformers dengan menyimpan dan menggunakan kembali output antara dari lapisan tertentu, seperti lapisan attention dan feedforward, alih-alih menghitungnya ulang pada setiap langkah inferensi.

## CacheMixin[[diffusers.CacheMixin]]

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

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

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

Kelas untuk mengaktifkan/menonaktifkan teknik caching pada model difusi.

Teknik penyangga yang didukung:
- [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)
```

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

Manajer konteks yang menyediakan informasi untuk manajemen cache.

`name` adalah nama panggilan denoising, biasanya `"cond"` atau `"uncond"`. Argumen kata kunci menjelaskan posisi loop denoising — lihat `CacheContext` untuk bidang yang diterima, misalnya `cache_context("cond", step_index=i, sigma=sigma)`.

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

```python
enable_cache(config)
```

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

**Parameter:**

config (`PyramidAttentionBroadcastConfig | FasterCacheConfig | FirstBlockCacheConfig | SeaCacheConfig | TextKVCacheConfig`) : Konfigurasi untuk menerapkan teknik caching. Teknik caching yang saat ini didukung adalah: - [PyramidAttentionBroadcastConfig](/docs/diffusers/main/id/api/cache#diffusers.PyramidAttentionBroadcastConfig) - [FasterCacheConfig](/docs/diffusers/main/id/api/cache#diffusers.FasterCacheConfig) - [FirstBlockCacheConfig](/docs/diffusers/main/id/api/cache#diffusers.FirstBlockCacheConfig) - [SeaCacheConfig](/docs/diffusers/main/id/api/cache#diffusers.SeaCacheConfig) - `TextKVCacheConfig`

Aktifkan teknik caching pada model.

Contoh:

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

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

**Parameter:**

spatial_attention_block_skip_range (`int`, *opsional*, defaultnya `None`) : Jumlah kali broadcast perhatian spasial tertentu dilewati sebelum menghitung keadaan perhatian untuk digunakan kembali. Jika ini diatur ke nilai `N`, komputasi perhatian akan dilewati `N - 1` kali (yaitu, keadaan perhatian lama akan digunakan kembali) sebelum menghitung keadaan perhatian baru lagi.

temporal_attention_block_skip_range (`int`, *opsional*, defaultnya `None`) : Jumlah kali broadcast atensi temporal tertentu dilewati sebelum menghitung keadaan atensi untuk digunakan kembali. Jika ini diatur ke nilai `N`, perhitungan atensi akan dilewati `N - 1` kali (yaitu, keadaan atensi lama akan digunakan kembali) sebelum menghitung keadaan atensi baru lagi.

cross_attention_block_skip_range (`int`, *opsional*, defaultnya `None`) : Jumlah kali broadcast cross-attention tertentu dilewati sebelum menghitung state attention untuk digunakan kembali. Jika ini diatur ke nilai `N`, komputasi attention akan dilewati `N - 1` kali (yaitu, state attention lama akan digunakan kembali) sebelum state attention baru dihitung lagi.

spatial_attention_timestep_skip_range (`tuple[int, int]`, defaultnya `(100, 800)`) : Rentang timestep yang akan dilewati di lapisan spatial attention. Perhitungan attention akan dilewati secara kondisional jika timestep saat ini berada dalam rentang yang ditentukan.

temporal_attention_timestep_skip_range (`tuple[int, int]`, defaultnya `(100, 800)`) : Rentang timestep yang akan dilewati di lapisan temporal attention. Perhitungan attention akan dilewati secara kondisional jika timestep saat ini berada dalam rentang yang ditentukan.

cross_attention_timestep_skip_range (`tuple[int, int]`, defaultnya `(100, 800)`) : Rentang timestep yang akan dilewati di lapisan cross-attention. Perhitungan attention akan dilewati secara kondisional jika timestep saat ini berada dalam rentang yang ditentukan.

spatial_attention_block_identifiers (`tuple[str, ...]`) : Pengidentifikasi yang dicocokkan dengan nama layer untuk menentukan apakah layer tersebut merupakan layer atensi spasial.

temporal_attention_block_identifiers (`tuple[str, ...]`) : Pengidentifikasi yang dicocokkan dengan nama layer untuk menentukan apakah layer tersebut merupakan layer atensi temporal.

cross_attention_block_identifiers (`tuple[str, ...]`) : Pengidentifikasi yang dicocokkan dengan nama layer untuk menentukan apakah layer tersebut merupakan layer cross-attention.

Konfigurasi untuk Pyramid Attention Broadcast.

#### diffusers.apply_pyramid_attention_broadcast[[diffusers.apply_pyramid_attention_broadcast]]

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

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

**Parameter:**

module (`torch.nn.Module`) : Modul yang akan diterapkan Pyramid Attention Broadcast.

config (`PyramidAttentionBroadcastConfig | None`, `optional`, defaults to `None`) : Konfigurasi yang digunakan untuk Pyramid Attention Broadcast.

Terapkan [Pyramid Attention Broadcast](https://huggingface.co/papers/2408.12588) pada pipeline tertentu.

PAB adalah metode aproksimasi perhatian yang memanfaatkan kemiripan dalam keadaan perhatian antar langkah waktu untuk mengurangi biaya komputasi dari perhitungan perhatian. Poin utama dari makalah tersebut adalah bahwa kemiripan perhatian pada lapisan cross-attention antar langkah waktu sangat tinggi, diikuti oleh kemiripan yang lebih rendah pada lapisan temporal dan spasial. Hal ini memungkinkan pengabaian perhitungan perhatian pada lapisan cross-attention lebih sering daripada pada lapisan temporal dan spasial. Dengan demikian, penerapan PAB akan mempercepat proses inferensi.

Contoh:

```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 = (-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.1, alpha_high_frequency: float = 1.1, unconditional_batch_skip_range: int = 5, unconditional_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] = 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 = ('hidden_states', 'encoder_hidden_states', 'timestep', 'attention_mask', 'encoder_attention_mask'))
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/faster_cache.py#L50)

**Parameter:**

spatial_attention_block_skip_range (`int`, defaultnya `2`) : Hitung status perhatian setiap `N` iterasi. Jika ini diatur ke `N`, komputasi perhatian akan dilewati `N - 1` kali (yaitu, status perhatian yang di-cache akan digunakan kembali) sebelum menghitung status perhatian baru lagi.

temporal_attention_block_skip_range (`int`, *opsional*, defaultnya `None`) : Menghitung keadaan perhatian setiap `N` iterasi. Jika ini diatur ke `N`, komputasi perhatian akan dilewati `N - 1` kali (yaitu, keadaan perhatian yang di-cache akan digunakan kembali) sebelum menghitung keadaan perhatian baru lagi.

spatial_attention_timestep_skip_range (`tuple[float, float]`, defaultnya `(-1, 681)`) : Rentang timestep di mana komputasi atensi spasial dapat dilewati tanpa penurunan kualitas yang signifikan. Nilai ini harus ditentukan oleh pengguna berdasarkan model yang mendasarinya. Nilai pertama dalam tuple adalah batas bawah dan nilai kedua adalah batas atas. Biasanya, timestep difusi untuk denoising berada dalam rentang terbalik dari 0 hingga 1000 (yaitu, denoising dimulai pada timestep 1000 dan berakhir pada timestep 0). Untuk nilai default, ini berarti pengabaian komputasi atensi spasial hanya akan berlaku setelah timestep denoising 681 tercapai, dan berlanjut hingga akhir proses denoising.

temporal_attention_timestep_skip_range (`tuple[float, float]`, *opsional*, defaultnya `None`) : Rentang timestep di mana komputasi atensi temporal dapat dilewati tanpa penurunan kualitas yang signifikan. Nilai ini harus ditentukan oleh pengguna berdasarkan model yang mendasarinya. Nilai pertama dalam tuple adalah batas bawah dan nilai kedua adalah batas atas. Biasanya, timestep difusi untuk denoising berada dalam rentang terbalik dari 0 hingga 1000 (yaitu, denoising dimulai pada timestep 1000 dan berakhir pada timestep 0).

low_frequency_weight_update_timestep_range (`tuple[int, int]`, defaultnya `(99, 901)`) : Rentang timestep di mana pembaruan penskalaan bobot frekuensi rendah diterapkan. Nilai pertama dalam tuple adalah batas bawah dan nilai kedua adalah batas atas dari rentang timestep. Fungsi callback untuk pembaruan hanya dipanggil di dalam rentang ini.

high_frequency_weight_update_timestep_range (`tuple[int, int]`, defaultnya `(-1, 301)`) : Rentang timestep di mana pembaruan penskalaan bobot frekuensi tinggi diterapkan. Nilai pertama dalam tuple adalah batas bawah dan nilai kedua adalah batas atas dari rentang timestep. Fungsi callback untuk pembaruan hanya dipanggil di dalam rentang ini.

alpha_low_frequency (`float`, defaultnya `1.1`) : Bobot untuk menskalakan pembaruan frekuensi rendah. Ini digunakan untuk mengaproksimasi cabang tak bersyarat dari keluaran cabang bersyarat.

alpha_high_frequency (`float`, defaultnya `1.1`) : Bobot untuk menskalakan pembaruan frekuensi tinggi. Ini digunakan untuk mengaproksimasi cabang tak bersyarat dari keluaran cabang bersyarat.

unconditional_batch_skip_range (`int`, defaultnya `5`) : Proses cabang tanpa syarat setiap `N` iterasi. Jika ini diatur ke `N`, komputasi cabang tanpa syarat akan dilewati `N - 1` kali (yaitu, keadaan cabang tanpa syarat yang di-cache akan digunakan kembali) sebelum keadaan cabang tanpa syarat baru dihitung lagi.

unconditional_batch_timestep_skip_range (`tuple[float, float]`, defaultnya `(-1, 641)`) : Rentang timestep di mana komputasi cabang unconditional dapat dilewati tanpa penurunan kualitas yang signifikan. Nilai ini harus ditentukan oleh pengguna berdasarkan model yang mendasarinya. Nilai pertama dalam tuple adalah batas bawah dan nilai kedua adalah batas atas.

spatial_attention_block_identifiers (`tuple[str, ...]`, defaultnya `("blocks.*attn1", "transformer_blocks.*attn1", "single_transformer_blocks.*attn1")`) : Identifikator untuk mencocokkan blok atensi spasial dalam model. Jika nama blok mengandung salah satu identifikator ini, FasterCache akan diterapkan pada blok tersebut. Ini bisa berupa nama layer penuh, nama layer parsial, atau pola regex. Pencocokan selalu dilakukan menggunakan pencocokan regex.

temporal_attention_block_identifiers (`tuple[str, ...]`, defaultnya `("temporal_transformer_blocks.*attn1",)`) : Identifikator untuk mencocokkan blok atensi temporal dalam model. Jika nama blok mengandung salah satu identifikator ini, FasterCache akan diterapkan pada blok tersebut. Ini bisa berupa nama layer penuh, nama layer parsial, atau pola regex. Pencocokan selalu dilakukan menggunakan regex match.

attention_weight_callback (`Callable[[torch.nn.Module], float]`, defaultnya `None`) : Fungsi callback untuk menentukan bobot yang akan digunakan untuk menskalakan output perhatian. Fungsi ini harus menerima modul perhatian sebagai input dan mengembalikan nilai float. Ini digunakan untuk memperkirakan cabang tak bersyarat dari output cabang bersyarat. Jika tidak disediakan, bobot default adalah 0,5 untuk semua langkah waktu. Biasanya, seperti yang dijelaskan dalam makalah, bobot ini harus meningkat secara bertahap dari 0 ke 1 seiring berjalannya inferensi. Pengguna didorong untuk bereksperimen dan menyediakan jadwal bobot kustom yang mempertimbangkan jumlah langkah inferensi dan perilaku model dasar seiring berjalannya proses denoising.

low_frequency_weight_callback (`Callable[[torch.nn.Module], float]`, defaultnya `None`) : Fungsi callback untuk menentukan bobot yang akan digunakan untuk menskalakan pembaruan frekuensi rendah. Jika tidak disediakan, bobot default adalah 1.1 untuk timestep dalam rentang yang ditentukan (seperti yang dijelaskan dalam makalah).

high_frequency_weight_callback (`Callable[[torch.nn.Module], float]`, defaultnya `None`) : Fungsi callback untuk menentukan bobot yang akan digunakan untuk menskalakan pembaruan frekuensi tinggi. Jika tidak disediakan, bobot default adalah 1.1 untuk timestep dalam rentang yang ditentukan (seperti yang dijelaskan dalam makalah).

tensor_format (`str`, defaultnya `"BCFHW"`) : Format dari tensor input. Ini harus salah satu dari `"BCFHW"`, `"BFCHW"`, atau `"BCHW"`. Format ini digunakan untuk memisahkan frame laten individual agar komponen frekuensi rendah dan tinggi dapat dihitung.

is_guidance_distilled (`bool`, defaultnya `False`) : Apakah model tersebut guidance distilled atau tidak. Jika modelnya guidance distilled, FasterCache tidak akan diterapkan pada level denoiser untuk melompati komputasi cabang unconditional (karena tidak ada cabang tersebut).

_unconditional_conditional_input_kwargs_identifiers (`list[str]`, defaultnya `("hidden_states", "encoder_hidden_states", "timestep", "attention_mask", "encoder_attention_mask")`) : Identifikator untuk mencocokkan input kwargs yang berisi input kondisional dan tidak kondisional yang dikonekasi secara batchwise. Jika nama input kwargs mengandung salah satu identifikator ini, FasterCache akan memisahkan input menjadi cabang kondisional dan tidak kondisional. Ini harus berupa daftar nama input kwargs yang persis berisi input kondisional dan tidak kondisional yang dikonekasi secara batchwise.

Konfigurasi untuk [FasterCache](https://huggingface.co/papers/2410.19355).

#### diffusers.apply_faster_cache[[diffusers.apply_faster_cache]]

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/faster_cache.py#L486)

**Parameter:**

module (`torch.nn.Module`) : modul pytorch yang akan diterapkan FasterCache-nya. Biasanya, ini harus berupa arsitektur transformer yang didukung di Diffusers, seperti `CogVideoXTransformer3DModel`, tetapi implementasi eksternal juga mungkin dapat berfungsi.

config (`FasterCacheConfig`) : Konfigurasi yang digunakan untuk FasterCache.

Menerapkan [FasterCache](https://huggingface.co/papers/2410.19355) ke pipeline tertentu.

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/first_block_cache.py#L33)

**Parameter:**

threshold (`float`, defaultnya `0.05`) : Ambang batas untuk menentukan apakah forward pass melalui semua lapisan model diperlukan atau tidak. Ambang batas yang lebih tinggi biasanya menghasilkan forward pass melalui jumlah lapisan yang lebih sedikit dan inferensi yang lebih cepat, tetapi dapat menyebabkan kualitas generasi yang lebih buruk. Ambang batas yang lebih rendah mungkin tidak menghasilkan percepatan generasi yang signifikan. Ambang batas ini dibandingkan dengan selisih absmean dari residual antara output saat ini dan output yang di-cache dari blok transformer pertama. Jika selisihnya di bawah ambang batas, forward pass dilewati.

Konfigurasi untuk [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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/first_block_cache.py#L193)

**Parameter:**

module (`torch.nn.Module`) : modul pytorch yang akan diterapkan FBCache. Biasanya, ini harus berupa arsitektur transformer yang didukung di Diffusers, seperti `CogVideoXTransformer3DModel`, tetapi implementasi eksternal juga mungkin dapat berfungsi.

config (`FirstBlockCacheConfig`) : Konfigurasi yang digunakan untuk menerapkan metode FBCache.

Menerapkan [First Block Cache](https://github.com/chengzeyi/ParaAttention/blob/4de137c5b96416489f06e43e19f2c14a772e28fd/README.md#first-block-cache-our-dynamic-caching) ke modul tertentu.

First Block Cache dibangun berdasarkan ide dari [TeaCache](https://huggingface.co/papers/2411.19108). Implementasinya jauh lebih sederhana secara generik untuk berbagai model dan telah diintegrasikan terlebih dahulu untuk tujuan eksperimental.

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

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

**Parameter:**

cache_interval (`int`, defaultnya `5`) : Interval antara langkah komputasi penuh. Setelah komputasi penuh, output yang di-cache (diperkirakan) digunakan kembali untuk sejumlah langkah denoising berikutnya sebanyak ini sebelum diperbarui dengan forward pass penuh yang baru.

disable_cache_before_step (`int`, defaultnya `3`) : Indeks langkah denoising sebelum mana caching dinonaktifkan, yang berarti komputasi penuh dilakukan untuk langkah-langkah awal (0 untuk disable_cache_before_step - 1) guna mengumpulkan data untuk aproksimasi deret Taylor. Selama langkah-langkah ini, faktor Taylor diperbarui, tetapi caching/prediksi tidak diterapkan. Caching dimulai pada langkah ini.

disable_cache_after_step (`int`, *opsional*, defaultnya `None`) : Indeks langkah denoising setelah mana caching dinonaktifkan. Jika diatur, untuk langkah >= nilai ini, semua modul menjalankan komputasi penuh tanpa prediksi atau pembaruan state, memastikan akurasi di tahap-tahap akhir jika diperlukan.

max_order (`int`, defaultnya `1`) : Orde tertinggi dalam ekspansi deret Taylor untuk mengaproksimasi output modul. Orde yang lebih tinggi memberikan aproksimasi yang lebih baik tetapi meningkatkan penggunaan komputasi dan memori.

taylor_factors_dtype (`torch.dtype`, defaultnya `torch.bfloat16`) : Tipe data yang digunakan untuk menyimpan dan menghitung faktor deret Taylor. Presisi yang lebih rendah mengurangi memori tetapi dapat memengaruhi stabilitas; presisi yang lebih tinggi meningkatkan akurasi dengan biaya memori yang lebih besar.

skip_predict_identifiers (`list[str]`, *opsional*, defaultnya `None`) : Pola regex (menggunakan `re.fullmatch`) untuk nama modul yang akan ditempatkan sebagai "skip" dalam mode "cache". Dalam mode ini, modul dihitung sepenuhnya selama langkah awal atau penyegaran, tetapi mengembalikan tensor nol (sesuai bentuk yang direkam) selama langkah prediksi untuk melewati komputasi secara hemat.

cache_identifiers (`list[str]`, *opsional*, defaultnya `None`) : Pola regex (menggunakan `re.fullmatch`) untuk nama modul yang akan ditempatkan dalam mode penampungan deret Taylor, di mana output didekati dan ditampungkan untuk digunakan kembali.

use_lite_mode (`bool`, *opsional*, defaultnya `False`) : Mengaktifkan varian TaylorSeer ringan yang meminimalkan penggunaan memori dengan menerapkan pola yang telah ditentukan untuk melewati dan meng-cache (misalnya, melewati blok dan meng-cache proyeksi). Ini menimpa `inactive_identifiers` atau `active_identifiers` kustom apa pun.

Konfigurasi untuk cache TaylorSeer. Lihat: https://huggingface.co/papers/2503.06923

Catatan:
- Pola dicocokkan menggunakan `re.fullmatch` pada nama modul.
- Jika `skip_predict_identifiers` atau `cache_identifiers` diberikan, hanya modul yang cocok yang akan di-hook.
- Jika keduanya tidak disediakan, semua modul yang mirip perhatian (attention-like) akan di-hook secara default.

Contoh penggunaan tidak aktif dan aktif:

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

Nilai mock untuk jalur bertitik (mis. `torch.float32`): rantai akses atribut, panggilan berperilaku sebagai dekorator pass-through, `repr` adalah jalur bertitik, dan penggunaannya sebagai kelas dasar menggantikan kelas dasar `type` polos (PEP 560 `__mro_entries__`), sehingga subclass asli tetap mempertahankan metaclass normal dan `inspect.signature` membaca `__init__` asli mereka, bukan milik mock.

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

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

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

**Parameter:**

module (torch.nn.Module) : Subpohon model tempat hook diterapkan.

config (TaylorSeerCacheConfig) : Konfigurasi untuk cache.

Menerapkan cache TaylorSeer ke pipeline tertentu (biasanya transformer / UNet).

Fungsi ini mengaitkan modul-modul tertentu dalam model untuk memungkinkan peng-cache-an atau pengabaian berdasarkan konfigurasi yang diberikan, sehingga mengurangi komputasi yang redundan dalam loop denoising difusi.

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

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

**Parameter:**

threshold (`float`, defaultnya `0.06`) : Ambang batas untuk kesalahan yang terakumulasi. Jika kesalahan yang terakumulasi berada di bawah ambang batas ini, komputasi blok akan dilewati. Ambang batas yang lebih tinggi memungkinkan pengabaian yang lebih agresif (lebih cepat) tetapi dapat menurunkan kualitas.

max_skip_steps (`int`, defaultnya `3`) : Jumlah maksimum langkah berurutan yang dapat dilewati (K dalam makalah).

retention_ratio (`float`, defaultnya `0.2`) : Fraksi langkah awal di mana pengabaian dinonaktifkan untuk memastikan stabilitas. Misalnya, jika `num_inference_steps` adalah 28 dan `retention_ratio` adalah 0.2, 6 langkah pertama tidak akan pernah diabaikan.

num_inference_steps (`int`, defaultnya `28`) : Jumlah langkah inferensi yang digunakan dalam pipeline. Ini diperlukan untuk menginterpolasi `mag_ratios` dengan benar.

mag_ratios (`torch.Tensor`, *opsional*) : Rasio magnitudo yang telah dihitung sebelumnya untuk model. Nilai ini bergantung pada checkpoint. Jika tidak disediakan, Anda harus mengatur `calibrate=True` untuk menghitungnya untuk model spesifik Anda. Untuk model Flux, Anda dapat menggunakan `diffusers.hooks.mag_cache.FLUX_MAG_RATIOS`.

calibrate (`bool`, defaultnya `False`) : Jika True, mengaktifkan mode kalibrasi. Dalam mode ini, tidak ada blok yang dilewati. Sebaliknya, hook menghitung rasio magnitudo untuk eksekusi saat ini dan mencatatnya di akhir. Gunakan ini untuk memperoleh `mag_ratios` untuk model atau scheduler baru.

Konfigurasi untuk [MagCache](https://github.com/Zehong-Ma/MagCache).

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

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

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

**Parameter:**

module (`torch.nn.Module`) : Modul yang akan diterapkan MagCache.

config (`MagCacheConfig`) : Konfigurasi untuk MagCache.

Menerapkan MagCache ke modul tertentu (biasanya 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)
```

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

**Parameter:**

threshold (`float`, defaultnya `0.25`) : Anggaran relative-L1 yang terakumulasi. Nilai yang lebih besar membuat cache lebih sering digunakan kembali.

residual_order (`int`, defaultnya `1`) : Urutan yang digunakan untuk memprediksi residual transformer. `0` langsung menggunakan ulang residual terbaru dan `1` melakukan ekstrapolasi linear dari dua eksekusi penuh terbaru.

retention_steps (`int`, defaultnya `1`) : Jumlah langkah awal scheduler yang selalu dieksekusi secara penuh.

cache_end_steps (`int`, defaultnya `1`) : Jumlah langkah scheduler akhir yang selalu dieksekusi secara penuh.

max_consecutive_cached (`int`, defaultnya `2`) : Jumlah maksimum penggunaan ulang residual berurutan per konteks cache sebelum memaksa eksekusi penuh. `0` menonaktifkan batas tersebut.

power_exp (`float`, defaultnya `3.0`) : Eksponen dari prior kekuatan sinyal bersih SEA. SeaCache menggunakan `3.0` untuk fitur video.

raw_vision_callback (`Callable`, *opsional*) : Adapter model lanjutan yang mengembalikan latens visual yang membentuk output yang dihasilkan, masing-masing dengan bentuk `(C, T, H, W)`. Sertakan frame kondisioning bersih di dalam lintasan output, tetapi hilangkan petunjuk visual terpisah yang bukan bagian dari output. Jika diabaikan, adapter bawaan akan digunakan jika tersedia.

Konfigurasi untuk [SeaCache](https://huggingface.co/papers/2602.18993).

SeaCache dinonaktifkan secara default dan hanya diaktifkan setelah konfigurasi ini diteruskan ke `transformer.enable_cache(config)`.

SeaCache membandingkan indikator Spectral-Evolution-Aware (SEA) antar langkah scheduler. Jika perubahan relatif terakumulasi mereka tetap di bawah `threshold`, tumpukan blok transformer yang diulang diganti dengan residual yang di-cache. Adapter spesifik model dapat memperluas batas residual melampaui blok-blok tersebut. Transformer video lainnya dapat menggunakan jalur generik dengan mendaftarkan metadata blok mereka dan menyediakan `raw_vision_callback`; pipeline mereka harus memasuki `cache_context` untuk setiap trajektori transformer.

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

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

**Parameter:**

module (`torch.nn.Module`) : modul Transformer untuk di-cache.

config (`SeaCacheConfig`) : Konfigurasi SeaCache.

Terapkan SeaCache pada transformer yang didukung.

SeaCache menggunakan ulang residual yang di-cache untuk tumpukan blok berulang dari transformer. Adapter model dapat menyesuaikan ekstraksi indikator dan batas residual; jalur generik menggunakan metadata blok yang terdaftar dan `raw_vision_callback`. Parameter kompatibilitas dan cache harus divalidasi untuk setiap model.