Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /tr /api /cache.md
mishig
about 16 hours ago
preview code
download
raw
33.8 kB
# Önbellekleme yöntemleri

Cache yöntemleri, dikkat ve ileri besleme katmanları gibi belirli katmanların ara çıktıları her çıkarım adımında yeniden hesaplanmak yerine saklanıp yeniden kullanılarak difüzyon dönüştürücülerini hızlandırır.

## CacheMixin[[diffusers.CacheMixin]]

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

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

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

Difüzyon modellerinde önbellekleme tekniklerini etkinleştirme/devre dışı bırakma için bir sınıf.

Desteklenen önbellekleme teknikleri:
- [Piramit Dikkat Yayınlama](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)
```

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

Önbellek yönetimi için bilgi sağlayan bağlam yöneticisi.

`name`, gürültü azaltma çağrısının adıdır ve genellikle `"cond"` veya `"uncond"` şeklindedir. Anahtar kelime argümanları, gürültü azaltma döngüsünün nerede olduğunu açıklar; kabul edilen alanlar için `CacheContext` sınıfına bakın, örneğin `cache_context("cond", step_index=i, sigma=sigma)`.

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

```python
enable_cache(config)
```

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

**Parametreler:**

config (`PyramidAttentionBroadcastConfig | FasterCacheConfig | FirstBlockCacheConfig | SeaCacheConfig | TextKVCacheConfig`) : Önbellekleme tekniğinin uygulanması için yapılandırma. Şu anda desteklenen önbellekleme teknikleri şunlardır: - [PyramidAttentionBroadcastConfig](/docs/diffusers/main/tr/api/cache#diffusers.PyramidAttentionBroadcastConfig) - [FasterCacheConfig](/docs/diffusers/main/tr/api/cache#diffusers.FasterCacheConfig) - [FirstBlockCacheConfig](/docs/diffusers/main/tr/api/cache#diffusers.FirstBlockCacheConfig) - [SeaCacheConfig](/docs/diffusers/main/tr/api/cache#diffusers.SeaCacheConfig) - `TextKVCacheConfig`

Modelde önbellekleme tekniklerini etkinleştirin.

Örnek:

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

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

**Parametreler:**

spatial_attention_block_skip_range (`int`, *isteğe bağlı*, varsayılan `None`) : Dikkat durumlarının yeniden kullanılabilmesi için hesaplanmadan önce belirli bir uzamsal dikkat yayılımının kaç kez atlanacağı. Bu değer `N` olarak ayarlanırsa, yeni dikkat durumları tekrar hesaplanmadan önce dikkat hesabı `N - 1` kez atlanır (yani eski dikkat durumları yeniden kullanılır).

temporal_attention_block_skip_range (`int`, *isteğe bağlı*, varsayılan `None`) : Dikkat durumlarının yeniden kullanılabilmesi için hesaplanmadan önce belirli bir zamansal dikkat yayılımının kaç kez atlanacağı. Bu değer `N` olarak ayarlanırsa, yeni dikkat durumları tekrar hesaplanmadan önce dikkat hesabı `N - 1` kez atlanır (yani eski dikkat durumları yeniden kullanılır).

cross_attention_block_skip_range (`int`, *opsiyonel*, varsayılan `None`) : Dikkat durumlarının yeniden kullanılabilmesi için hesaplanmadan önce belirli bir çapraz dikkat yayılımının kaç kez atlanacağı. Bu değer `N` olarak ayarlanırsa, yeni dikkat durumları tekrar hesaplanmadan önce dikkat hesabı `N - 1` kez atlanır (yani eski dikkat durumları yeniden kullanılır).

spatial_attention_timestep_skip_range (`tuple[int, int]`, varsayılan `(100, 800)`) : Uzamsal dikkat katmanında atlanacak zaman adımları aralığı. Mevcut zaman adımı belirtilen aralık içindeyse dikkat hesaplamaları koşullu olarak atlanır.

temporal_attention_timestep_skip_range (`tuple[int, int]`, varsayılan `(100, 800)`) : Zaman dikkat katmanında atlanacak zaman adımları aralığı. Mevcut zaman adımı belirtilen aralık içindeyse dikkat hesaplamaları koşullu olarak atlanır.

cross_attention_timestep_skip_range (`tuple[int, int]`, varsayılan `(100, 800)`) : Çapraz dikkat katmanında atlanacak zaman adımı aralığı. Mevcut zaman adımı belirtilen aralık içindeyse dikkat hesaplamaları koşullu olarak atlanır.

spatial_attention_block_identifiers (`tuple[str, ...]`) : Katmanın bir uzamsal dikkat katmanı olup olmadığını belirlemek için katman adlarıyla eşleştirilecek tanımlayıcılar.
temporal_attention_block_identifiers (`tuple[str, ...]`) : Katmanın zamansal dikkat katmanı olup olmadığını belirlemek için katman adlarıyla eşleştirilecek tanımlayıcılar.

cross_attention_block_identifiers (`tuple[str, ...]`) : Katman adlarıyla eşleştirilecek ve katmanın çapraz-dikkat (cross-attention) katmanı olup olmadığını belirlemek için kullanılacak tanımlayıcılar.
Pyramid Attention Broadcast yapılandırması.
#### diffusers.apply_pyramid_attention_broadcast[[diffusers.apply_pyramid_attention_broadcast]]
```python
diffusers.apply_pyramid_attention_broadcast(module: Module, config: PyramidAttentionBroadcastConfig)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/pyramid_attention_broadcast.py#L181)
**Parametreler:**
module (`torch.nn.Module`) : Pyramid Attention Broadcast uygulanacak modül.
config (`PyramidAttentionBroadcastConfig | None`, `optional`, varsayılan `None`) : Pyramid Attention Broadcast için kullanılacak yapılandırma.
Belirli bir pipeline'a [Pyramid Attention Broadcast](https://huggingface.co/papers/2408.12588) uygulayın.
PAB, timestep'ler arasındaki dikkat durumlarındaki benzerlikten yararlanarak dikkat hesaplama maliyetini azaltan bir dikkat yaklaşım yöntemidir. Makalenin temel çıkarımı, timestep'ler arasındaki cross-attention katmanlarında dikkat benzerliğinin yüksek olduğu, ardından temporal ve spatial katmanlarda benzerliğin daha düşük olduğu yönündedir. Bu durum, cross-attention katmanlarında dikkat hesaplamasının temporal ve spatial katmanlara kıyasla daha sık atlanmasına olanak tanır. Dolayısıyla PAB uygulandığında inference süreci hızlanır.
Örnek:
```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'))
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/faster_cache.py#L50)
**Parametreler:**
spatial_attention_block_skip_range (`int`, varsayılan `2`) : Dikkat durumlarını her `N` iterasyonda hesaplar. Bu değer `N` olarak ayarlanırsa, yeni dikkat durumları tekrar hesaplanmadan önce dikkat hesabı `N - 1` kez atlanır (yani önbelleğe alınmış dikkat durumları yeniden kullanılır).
temporal_attention_block_skip_range (`int`, *isteğe bağlı*, varsayılan `None`) : Dikkat durumlarını her `N` iterasyonda hesaplar. Bu değer `N` olarak ayarlanırsa, yeni dikkat durumları tekrar hesaplanmadan önce dikkat hesabı `N - 1` kez atlanır (yani önbelleğe alınmış dikkat durumları yeniden kullanılır).
spatial_attention_timestep_skip_range (`tuple[float, float]`, varsayılan `(-1, 681)`) : Uzamsal dikkat hesabının kalitede önemli bir kayba yol açmadan atlanabileceği zaman adımı aralığı. Bu değer, altta yatan modele göre kullanıcı tarafından belirlenmelidir. Demetin ilk değeri alt sınırı, ikinci değeri ise üst sınırı temsil eder. Genellikle, gürültüden arındırma için difüzyon zaman adımları 0'dan 1000'e ters aralıktadır (yani gürültüden arındırma 1000. zaman adımında başlar ve 0. zaman adımında biter). Varsayılan değerler için bu, uzamsal dikkat hesabının atlanmasının yalnızca 681. gürültüden arındırma zaman adımına ulaşıldıktan sonra geçerli olacağı ve gürültüden arındırma sürecinin sonuna kadar devam edeceği anlamına gelir.
temporal_attention_timestep_skip_range (`tuple[float, float]`, *isteğe bağlı*, varsayılan `None`) : Zaman dikkat hesabının kalitede önemli bir kayba yol açmadan atlanabileceği zaman adımı aralığı. Bu, kullanıcı tarafından altta yatan modele göre belirlenmelidir. Demetin ilk değeri alt sınırı, ikinci değeri ise üst sınırı temsil eder. Genellikle, gürültüden arındırma için difüzyon zaman adımları 0'dan 1000'e ters aralıktadır (yani gürültüden arındırma 1000. zaman adımında başlar ve 0. zaman adımında biter).
low_frequency_weight_update_timestep_range (`tuple[int, int]`, varsayılan `(99, 901)`) : Düşük frekans ağırlık ölçekleme güncellemesinin uygulandığı zaman adımı aralığı. Demetin ilk değeri zaman adımı aralığının alt sınırı, ikinci değeri ise üst sınırıdır. Güncelleme için geri çağrı fonksiyonu yalnızca bu aralık içinde çağrılır.

high_frequency_weight_update_timestep_range (`tuple[int, int]`, varsayılan `(-1, 301)`) : Yüksek frekans ağırlık ölçekleme güncellemesinin uygulandığı zaman adımı aralığı. Demetin ilk değeri zaman adımı aralığının alt sınırı, ikinci değeri ise üst sınırıdır. Güncelleme için geri çağrı fonksiyonu yalnızca bu aralık içinde çağrılır.
alpha_low_frequency (`float`, varsayılan `1.1`) : Düşük frekanslı güncellemelerin ölçeklenmesi için kullanılan ağırlık. Bu, koşullu dalga çıktılarından koşulsuz dala yaklaşım yapmak için kullanılır.
alpha_high_frequency (`float`, varsayılan `1.1`) : Yüksek frekanslı güncellemelerin ölçeklenmesi için kullanılan ağırlık. Bu, koşullu dalga çıktılarından koşulsuz dala yaklaşım yapmak için kullanılır.
unconditional_batch_skip_range (`int`, varsayılan `5`) : Koşulsuz dalı her `N` iterasyonda işler. Bu değer `N` olarak ayarlanırsa, yeni koşulsuz dal durumları yeniden hesaplanmadan önce koşulsuz dal hesabı `N - 1` kez atlanır (yani önbelleğe alınmış koşulsuz dal durumları yeniden kullanılır).

unconditional_batch_timestep_skip_range (`tuple[float, float]`, varsayılan `(-1, 641)`) : Koşulsuz dal hesabının kalitede önemli bir kayba yol açmadan atlanabileceği zaman adımı aralığı. Bu, altta yatan modele göre kullanıcı tarafından belirlenmelidir. Demetin ilk değeri alt sınırı, ikinci değeri ise üst sınırı belirtir.

spatial_attention_block_identifiers (`tuple[str, ...]`, varsayılan `("blocks.*attn1", "transformer_blocks.*attn1", "single_transformer_blocks.*attn1")`) : Modeldeki uzamsal dikkat bloklarını eşleştirmek için kullanılacak tanımlayıcılar. Bir bloğun adı bu tanımlayıcılardan herhangi birini içeriyorsa, o bloğa FasterCache uygulanır. Bunlar tam katman adları, kısmi katman adları veya regex desenleri olabilir. Eşleştirme her zaman bir regex eşleşmesi kullanılarak yapılır.

temporal_attention_block_identifiers (`tuple[str, ...]`, varsayılan `("temporal_transformer_blocks.*attn1",)`) : Modeldeki zamansal dikkat bloklarını eşleştirmek için kullanılan tanımlayıcılar. Bloğun adı bu tanımlayıcılardan herhangi birini içeriyorsa, o bloğa FasterCache uygulanır. Bunlar tam katman adları, kısmi katman adları veya regex desenleri olabilir. Eşleştirme her zaman regex eşleşmesi kullanılarak yapılır.
attention_weight_callback (`Callable[[torch.nn.Module], float]`, varsayılan olarak `None`) : Dikkat çıktılarının ölçeklenmesi için ağırlığı belirleyen geri çağrı işlevi. Bu işlev, girdi olarak dikkat modülünü almalı ve bir float değeri döndürmelidir. Bu, koşullu dalga çıktılarından koşulsuz dala yaklaşmak için kullanılır. Sağlanmazsa, tüm zaman adımları için varsayılan ağırlık 0.5'tir. Makalede belirtildiği üzere, bu ağırlık genellikle çıkarım ilerledikçe 0'dan 1'e doğru kademeli olarak artmalıdır. Kullanıcıların, çıkarım adım sayısı ve gürültü giderme ilerledikçe alttaki model davranışını dikkate alan özel ağırlık zamanlamaları denemeleri ve sağlamaları önerilir.
low_frequency_weight_callback (`Callable[[torch.nn.Module], float]`, varsayılan `None`) : Düşük frekanslı güncellemelerin ölçeklenmesinde kullanılacak ağırlığı belirlemek için geri çağrı fonksiyonu. Sağlanmazsa, kâğıtta belirtildiği gibi, aralık içindeki zaman adımları için varsayılan ağırlık 1.1'dir.

high_frequency_weight_callback (`Callable[[torch.nn.Module], float]`, varsayılan `None`) : Yüksek frekanslı güncellemelerin ölçeklenmesi için ağırlığı belirleyen geri çağrı işlevi. Sağlanmazsa, kâğıtta belirtildiği gibi, aralık içindeki zaman adımları için varsayılan ağırlık 1.1'dir.
tensor_format (`str`, varsayılan `"BCFHW"`) : Girdi tensörlerinin biçimi. Bu, `"BCFHW"`, `"BFCHW"` veya `"BCHW"` biçimlerinden biri olmalıdır. Biçim, düşük ve yüksek frekanslı bileşenlerin hesaplanabilmesi için bireysel gizli karelerin ayrıştırılmasında kullanılır.

is_guidance_distilled (`bool`, varsayılan `False`) : Modelin rehberlik damıtması yapılıp yapılmadığını belirtir. Model rehberlik damıtması yapılmışsa, koşulsuz dal hesaplamasını atlamak için (böyle bir dal olmadığından) FasterCache, gürültü azaltıcı (denoiser) seviyesinde uygulanmaz.

_unconditional_conditional_input_kwargs_identifiers (`list[str]`, varsayılan `("hidden_states", "encoder_hidden_states", "timestep", "attention_mask", "encoder_attention_mask")`) : Toplu olarak birleştirilmiş koşulsuz ve koşullu girdileri içeren girdi kwargs'larını eşleştirmek için kullanılan tanımlayıcılar. Girdi kwargs'larının adı bu tanımlayıcılardan herhangi birini içeriyorsa, FasterCache girdileri koşulsuz ve koşullu dallara böler. Bu, toplu olarak birleştirilmiş koşulsuz ve koşullu girdileri içeren girdi kwargs'larının tam adlarının bir listesi olmalıdır.
[FasterCache](https://huggingface.co/papers/2410.19355) yapılandırması.
#### diffusers.apply_faster_cache[[diffusers.apply_faster_cache]]
```python
diffusers.apply_faster_cache(module: Module, config: FasterCacheConfig)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/faster_cache.py#L486)
**Parametreler:**
module (`torch.nn.Module`) : FasterCache'in uygulanacağı pytorch modülü. Genellikle bu, Diffusers'ta desteklenen bir transformer mimarisi olmalıdır, örneğin `CogVideoXTransformer3DModel`, ancak harici uygulamalar da işe yarayabilir.
config (`FasterCacheConfig`) : FasterCache için kullanılacak yapılandırma.
Belirtilen bir pipeline'a [FasterCache](https://huggingface.co/papers/2410.19355) uygular.
Örnek:
```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)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/first_block_cache.py#L33)
**Parametreler:**
threshold (`float`, varsayılan `0.05`) : Modelin tüm katmanlarından bir ileri geçişin (forward pass) gerekli olup olmadığını belirlemek için kullanılan eşik. Daha yüksek bir eşik genellikle daha az katmandan ileri geçiş ve daha hızlı çıkarım (inference) sağlar, ancak üretim kalitesinin düşmesine neden olabilir. Daha düşük bir eşik, önemli bir üretim hızlanmasına yol açmayabilir. Eşik, ilk transformer bloğundan gelen mevcut ve önbelleğe alınmış çıktılar arasındaki artıkların (residuals) mutlak ortalama farkıyla karşılaştırılır. Fark eşik değerinin altındaysa, ileri geçiş atlanır.
[First Block Cache](https://github.com/chengzeyi/ParaAttention/blob/7a266123671b55e7e5a2fe9af3121f07a36afc78/README.md#first-block-cache-our-dynamic-caching) yapılandırması.
#### diffusers.apply_first_block_cache[[diffusers.apply_first_block_cache]]
```python
diffusers.apply_first_block_cache(module: Module, config: FirstBlockCacheConfig)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/first_block_cache.py#L193)
**Parametreler:**
module (`torch.nn.Module`) : FBCache'in uygulanacağı pytorch modülü. Genellikle, Diffusers'ta desteklenen bir transformer mimarisi olmalıdır, örneğin `CogVideoXTransformer3DModel`, ancak harici uygulamalar da işe yarayabilir.
config (`FirstBlockCacheConfig`) : FBCache yönteminin uygulanması için kullanılacak yapılandırma.
Belirtilen bir modüle [First Block Cache](https://github.com/chengzeyi/ParaAttention/blob/4de137c5b96416489f06e43e19f2c14a772e28fd/README.md#first-block-cache-our-dynamic-caching) uygular.
First Block Cache, [TeaCache](https://huggingface.co/papers/2411.19108) fikirleri üzerine inşa edilmiştir. Geniş bir model yelpazesinde genel olarak uygulanması çok daha basittir ve deneysel amaçlarla ilk olarak entegre edilmiştir.
Örnek:
```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)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/hooks/taylorseer_cache.py#L26)
**Parametreler:**
cache_interval (`int`, varsayılan `5`) : Tam hesaplama adımları arasındaki aralık. Tam bir hesaplama sonrasında, önbelleğe alınan (tahmin edilen) çıktılar, yeni bir tam ileri geçişle yenilenmeden önce bu kadar sonraki gürültü azaltma adımında yeniden kullanılır.
disable_cache_before_step (`int`, varsayılan `3`) : Önbelleklemenin devre dışı bırakıldığı, yani başlangıç adımları (0'dan disable_cache_before_step - 1'e kadar) için tam hesaplamanın Taylor serisi yaklaşımları için veri toplamak amacıyla gerçekleştirildiği gürültü giderme adım indeksi. Bu adımlar sırasında Taylor katsayıları güncellenir, ancak önbellekleme/tahminler uygulanmaz. Önbellekleme bu adımda başlar.
disable_cache_after_step (`int`, *isteğe bağlı*, varsayılan `None`) : Önbelleklemenin devre dışı bırakıldığı gürültü azaltma adım indeksi. Ayarlanırsa, bu değere eşit veya büyük olan adımlarda tüm modüller, tahmin veya durum güncellemeleri olmadan tam hesaplamaları çalıştırır; böylece gerekirse sonraki aşamalarda doğruluk sağlanır.
max_order (`int`, varsayılan `1`) : Modül çıktılarını yaklaşık olarak hesaplamak için Taylor serisi açılımında kullanılan en yüksek derece. Daha yüksek dereceler daha iyi yaklaşımlar sağlar ancak hesaplama ve bellek kullanımını artırır.
taylor_factors_dtype (`torch.dtype`, varsayılan `torch.bfloat16`) : Taylor serisi katsayılarını depolamak ve hesaplamak için kullanılan veri türü. Daha düşük hassasiyet belleği azaltır ancak kararlılığı etkileyebilir; daha yüksek hassasiyet, daha fazla bellek maliyeti karşılığında doğruluğu artırır.
skip_predict_identifiers (`list[str]`, *isteğe bağlı*, varsayılan `None`) : "cache" modunda "skip" olarak yerleştirilecek modül adları için regex desenleri (`re.fullmatch` kullanılarak). Bu modda, modül başlangıç veya yenileme adımlarında tamamen hesaplanır ancak tahmin adımlarında hesaplamayı ucuz bir şekilde atlamak için kaydedilen şekle uyan sıfır bir tensör döndürür.
cache_identifiers (`list[str]`, *isteğe bağlı*, varsayılan `None`) : Taylor serisi önbellekleme moduna yerleştirilecek modül adları için regex desenleri (`re.fullmatch` kullanılarak), burada çıktılar yaklaşık olarak hesaplanır ve yeniden kullanım için önbelleğe alınır.
use_lite_mode (`bool`, *isteğe bağlı*, varsayılan `False`) : Atlanma ve önbelleğe alma için önceden tanımlı desenleri uygulayarak bellek kullanımını en aza indiren hafif bir TaylorSeer varyantını etkinleştirir (ör. blokları atlama ve projeksiyonları önbelleğe alma). Bu, özel `inactive_identifiers` veya `active_identifiers` değerlerinin üzerine yazar.
TaylorSeer önbelleği için yapılandırma. Bakınız: https://huggingface.co/papers/2503.06923
Notlar:
- Desenler, modül adında `re.fullmatch` kullanılarak eşleştirilir.
- `skip_predict_identifiers` veya `cache_identifiers` sağlanırsa, yalnızca eşleşen modüller kancalanır.
- Her ikisi de sağlanmazsa, varsayılan olarak tüm dikkat benzeri modüller kancalanır.
Pasif ve aktif kullanım örneği:
```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)
```

Noktalı bir yol için sahte bir değer (ör. `torch.float32`): öznitelik erişim zincirleri, çağrılar geçiş (pass-through) dekoratörleri gibi davranır, `repr` noktalı yoldur ve bir taban sınıf olarak kullanıldığında düz bir `type` tabanı yerine geçer (PEP 560 `__mro_entries__`), böylece gerçek alt sınıflar normal bir meta sınıfı korur ve `inspect.signature` sahtenin yerine gerçek `__init__` değerlerini okur.

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

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

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

**Parametreler:**

module (torch.nn.Module) : Hook'ların uygulanacağı model alt ağacı.

config (TaylorSeerCacheConfig) : Önbellek yapılandırması.

TaylorSeer önbelleğini verilen bir iş akışına (genellikle transformer / UNet) uygular.

Bu fonksiyon, modeldeki seçili modülleri, sağlanan yapılandırmaya göre önbelleğe alma veya atlama işlevini etkinleştirmek için kancalar; bu sayede difüzyon gürültü giderme döngülerindeki gereksiz hesaplamaları azaltır.

Örnek:
```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)
```

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

**Parametreler:**

threshold (`float`, varsayılan `0.06`) : Birikmiş hata için eşik değeri. Birikmiş hata bu eşiğin altındaysa, blok hesaplama atlanır. Daha yüksek bir eşik, daha agresif atlama (daha hızlı) imkânı tanır ancak kaliteyi düşürebilir.

max_skip_steps (`int`, varsayılan `3`) : Atlanabilecek ardışık adım sayısının üst sınırı (makaledeki K).

retention_ratio (`float`, varsayılan `0.2`) : Kararlılığı sağlamak için atlamanın devre dışı bırakıldığı başlangıç adımlarının oranı. Örneğin, `num_inference_steps` 28 ve `retention_ratio` 0.2 ise, ilk 6 adım asla atlanmaz.

num_inference_steps (`int`, varsayılan `28`) : Pipeline'da kullanılan çıkarım adım sayısı. Bu, `mag_ratios`'un doğru şekilde interpolasyonu için gereklidir.

mag_ratios (`torch.Tensor`, *isteğe bağlı*) : Model için önceden hesaplanmış büyüklük oranları. Bunlar checkpoint'e bağlıdır. Sağlanmazsa, bunları belirli modeliniz için hesaplamak üzere `calibrate=True` değerini ayarlamalısınız. Flux modelleri için `diffusers.hooks.mag_cache.FLUX_MAG_RATIOS` kullanabilirsiniz.

calibrate (`bool`, varsayılan `False`) : True ise, kalibrasyon modunu etkinleştirir. Bu modda hiçbir blok atlanmaz. Bunun yerine, hook, geçerli çalıştırma için büyüklük oranlarını hesaplar ve bunları sonunda kaydeder. Yeni modeller veya zamanlayıcılar için `mag_ratios` değerlerini elde etmek için bunu kullanın.

[MagCache](https://github.com/Zehong-Ma/MagCache) yapılandırması.

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

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

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

**Parametreler:**

module (`torch.nn.Module`) : MagCache'in uygulanacağı modül.

config (`MagCacheConfig`) : MagCache yapılandırması.

MagCache'i belirli bir modüle (genellikle bir Transformer'a) uygular.

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

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

**Parametreler:**

threshold (`float`, varsayılan `0.25`) : Birikmiş göreli-L1 bütçesi. Daha büyük değerler önbelleğin daha sık yeniden kullanılmasını sağlar.

residual_order (`int`, varsayılan `1`) : Transformer artığını tahmin etmek için kullanılan sıra. `0` en son artığı doğrudan yeniden kullanır ve `1` son iki tam çalıştırmadan doğrusal olarak dışa vurum yapar.
retention_steps (`int`, varsayılan `1`) : Her zaman tam olarak çalıştırılan başlangıç zamanlayıcı adımlarının sayısı.

cache_end_steps (`int`, varsayılan `1`) : Her zaman tam olarak çalıştırılan son zamanlayıcı adım sayısı.

max_consecutive_cached (`int`, varsayılan `2`) : Tam bir çalıştırma zorlanmadan önce önbellek bağlamı başına izin verilen maksimum ardışık artımsal yeniden kullanımlar. `0` bu sınırı devre dışı bırakır.

power_exp (`float`, varsayılan `3.0`) : SEA temiz sinyal gücü öncelinin üssü. SeaCache, video özellikleri için `3.0` kullanır.
raw_vision_callback (`Callable`, *isteğe bağlı*) : Üretilen çıktıyı oluşturan görsel latentleri döndüren gelişmiş model adaptörü, her biri `(C, T, H, W)` biçiminde. Çıktı yörüngesi içinde temiz koşullandırma karelerini dahil edin, ancak çıktının parçası olmayan ayrı görsel ipuçlarını hariç tutun. Atlandığında, mevcut bir yerleşik adaptör kullanılır.
[SeaCache](https://huggingface.co/papers/2602.18993) yapılandırması.
SeaCache varsayılan olarak devre dışıdır ve yalnızca bu yapılandırma `transformer.enable_cache(config)` fonksiyonuna iletildikten sonra etkinleşir.

SeaCache, zamanlayıcı adımları arasında Spektral-Evrim-Bilinçli (SEA) göstergelerini karşılaştırır. Birikimli göreli değişimleri `threshold` değerinin altında kalıyorsa, tekrarlanan transformer blok yığını önbelleğe alınmış bir artıkla değiştirilir. Model özel adaptörler, artık sınırını bu blokların ötesine genişletebilir. Diğer video transformer'ları, blok meta verilerini kaydederek ve `raw_vision_callback` sağlayarak genel yolu kullanabilir; bu boru hatlarının her transformer yörüngesi için bir `cache_context` içine girmesi gerekir.

Örnek:
```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)
```

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

**Parametreler:**

module (`torch.nn.Module`) : Önbelleğe alınacak Transformer modülü.

config (`SeaCacheConfig`) : SeaCache yapılandırması.

Desteklenen bir dönüştürücüye SeaCache uygulayın.

SeaCache, bir transformer'ın tekrarlanan blok yığını için önbelleğe alınmış bir artığı yeniden kullanır. Model adaptörleri, gösterge çıkarımını ve artık sınırını özelleştirebilir; genel yol, kayıtlı blok meta verilerini ve `raw_vision_callback` işlevini kullanır. Uyumluluk ve önbellek parametreleri her model için doğrulanmalıdır.
Xet Storage Details

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