Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /tr /optimization /memory.md
mishig
about 11 hours ago
preview code
download
raw
31.3 kB
# Bellek kullanımını azaltın

[Flux](../api/pipelines/flux) ve [Wan](../api/pipelines/wan) gibi modern difüzyon modelleri, çıkarım sırasında donanımınızda çok fazla bellek alan milyarlarca parametreye sahiptir. Bu, yaygın GPU'ların genellikle yeterli belleğe sahip olmaması nedeniyle zorlayıcıdır. Bellek kısıtlamalarını aşmak için birden fazla GPU kullanabilir (mevcutsa), hattın bazı bileşenlerini CPU'ya aktarabilir ve daha fazlasını yapabilirsiniz.

Bu kılavuz, bellek kullanımınızı nasıl azaltacağınızı gösterecektir.

> [!TIP]
> Bu tekniklerin modele göre ayarlanmasının gerekebileceğini unutmayın. Örneğin, transformer tabanlı bir difüzyon modeli, UNet tabanlı bir modelden bu bellek optimizasyonlarından aynı ölçüde fayda görmeyebilir.

## Birden fazla GPU

Birden fazla GPU'ya erişiminiz varsa, büyük bir modeli donanımınız arasında verimli bir şekilde yüklemek ve dağıtmak için birkaç seçenek mevcuttur. Bu özellikler [Accelerate](https://huggingface.co/docs/accelerate/index) kütüphanesi tarafından desteklenir, bu nedenle önce kütüphanenin yüklü olduğundan emin olun.

```bash
pip install -U accelerate
```

### Parçalı denetim noktaları

Büyük kontrol noktalarını (checkpoint) birden fazla parça (shard) halinde yüklemek faydalıdır, çünkü parçalar tek tek yüklenir. Bu, bellek kullanımını düşük tutar; yalnızca model boyutu ve en büyük parça boyutu kadar bellek gerektirir. fp32 kontrol noktası 5GB'tan büyükse parçalama (sharding) öneririz. Varsayılan parça boyutu 5GB'tır.

Bir kontrol noktasını [save_pretrained()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.save_pretrained) içinde `max_shard_size` parametresiyle parçalara ayırın.

```py
from diffusers import AutoModel
unet = AutoModel.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", subfolder="unet"
)
unet.save_pretrained("sdxl-unet-sharded", max_shard_size="5GB")
```

Artık belleği tasarruflu kullanmak için normal kontrol noktası yerine parçalı kontrol noktasını kullanabilirsiniz.

```py
import torch
from diffusers import AutoModel, StableDiffusionXLPipeline
unet = AutoModel.from_pretrained(
    "username/sdxl-unet-sharded", dtype=torch.float16
)
pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    unet=unet,
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
```

### Cihaz yerleşimi

> [!WARNING]
> Cihaz yerleşimi deneysel bir özelliktir ve API değişebilir. Şu anda yalnızca `balanced` stratejisi desteklenmektedir. Gelecekte ek eşleme stratejilerini desteklemeyi planlıyoruz.

`device_map` parametresi, bir pipeline'daki model bileşenlerinin veya tek bir modeldeki katmanların cihazlar arasında nasıl dağıtılacağını kontrol eder.

`balanced` cihaz yerleştirme stratejisi, hattı tüm kullanılabilir cihazlar arasında eşit olarak böler.

```py
import torch
from diffusers import AutoModel, StableDiffusionXLPipeline
pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16,
    device_map="balanced"
)
```

Bir hattın cihaz haritasını `hf_device_map` ile inceleyebilirsiniz.

```py
print(pipeline.hf_device_map)
{'unet': 1, 'vae': 1, 'safety_checker': 0, 'text_encoder': 0}
```

`device_map`, Flux difüzyon dönüştürücüsü gibi 12,5 milyar parametreye sahip büyük modelleri yüklemek için kullanışlıdır. Modelin önce en hızlı cihaza, ardından daha yavaş cihazlara otomatik olarak dağıtılmasını sağlamak için `"auto"` olarak ayarlayın. Daha fazla ayrıntı için [Parçalı denetim noktaları](#sharded-checkpoints) bölümüne bakın.

```py
import torch
from diffusers import AutoModel
transformer = AutoModel.from_pretrained(
    "black-forest-labs/FLUX.1-dev", 
    subfolder="transformer",
    device_map="auto",
    dtype=torch.bfloat16
)
```

Bir modelin cihaz haritasını `hf_device_map` ile inceleyebilirsiniz.

```py
print(transformer.hf_device_map)
```

Kendi `device_map` tasarımınızı oluştururken, bir sözlük olmalıdır; bu sözlük, modelin belirli bir modül adı veya katmanı ile bir cihaz tanımlayıcısını (GPU'lar için bir tamsay, CPU'lar için `cpu` ve disk için `disk`) eşleştirir.

Bir modelde `hf_device_map` çağrısını yaparak model katmanlarının nasıl dağıtıldığını görün ve ardından kendi dağıtımınızı tasarlayın.

```py
print(transformer.hf_device_map)
{'pos_embed': 0, 'time_text_embed': 0, 'context_embedder': 0, 'x_embedder': 0, 'transformer_blocks': 0, 'single_transformer_blocks.0': 0, 'single_transformer_blocks.1': 0, 'single_transformer_blocks.2': 0, 'single_transformer_blocks.3': 0, 'single_transformer_blocks.4': 0, 'single_transformer_blocks.5': 0, 'single_transformer_blocks.6': 0, 'single_transformer_blocks.7': 0, 'single_transformer_blocks.8': 0, 'single_transformer_blocks.9': 0, 'single_transformer_blocks.10': 'cpu', 'single_transformer_blocks.11': 'cpu', 'single_transformer_blocks.12': 'cpu', 'single_transformer_blocks.13': 'cpu', 'single_transformer_blocks.14': 'cpu', 'single_transformer_blocks.15': 'cpu', 'single_transformer_blocks.16': 'cpu', 'single_transformer_blocks.17': 'cpu', 'single_transformer_blocks.18': 'cpu', 'single_transformer_blocks.19': 'cpu', 'single_transformer_blocks.20': 'cpu', 'single_transformer_blocks.21': 'cpu', 'single_transformer_blocks.22': 'cpu', 'single_transformer_blocks.23': 'cpu', 'single_transformer_blocks.24': 'cpu', 'single_transformer_blocks.25': 'cpu', 'single_transformer_blocks.26': 'cpu', 'single_transformer_blocks.27': 'cpu', 'single_transformer_blocks.28': 'cpu', 'single_transformer_blocks.29': 'cpu', 'single_transformer_blocks.30': 'cpu', 'single_transformer_blocks.31': 'cpu', 'single_transformer_blocks.32': 'cpu', 'single_transformer_blocks.33': 'cpu', 'single_transformer_blocks.34': 'cpu', 'single_transformer_blocks.35': 'cpu', 'single_transformer_blocks.36': 'cpu', 'single_transformer_blocks.37': 'cpu', 'norm_out': 'cpu', 'proj_out': 'cpu'}
```

Örneğin, aşağıdaki `device_map`, `single_transformer_blocks.10` ile `single_transformer_blocks.20` arasındaki blokları ikinci bir GPU'ya (`1`) yerleştirir.

```py
import torch
from diffusers import AutoModel
device_map = {
    'pos_embed': 0, 'time_text_embed': 0, 'context_embedder': 0, 'x_embedder': 0, 'transformer_blocks': 0, 'single_transformer_blocks.0': 0, 'single_transformer_blocks.1': 0, 'single_transformer_blocks.2': 0, 'single_transformer_blocks.3': 0, 'single_transformer_blocks.4': 0, 'single_transformer_blocks.5': 0, 'single_transformer_blocks.6': 0, 'single_transformer_blocks.7': 0, 'single_transformer_blocks.8': 0, 'single_transformer_blocks.9': 0, 'single_transformer_blocks.10': 1, 'single_transformer_blocks.11': 1, 'single_transformer_blocks.12': 1, 'single_transformer_blocks.13': 1, 'single_transformer_blocks.14': 1, 'single_transformer_blocks.15': 1, 'single_transformer_blocks.16': 1, 'single_transformer_blocks.17': 1, 'single_transformer_blocks.18': 1, 'single_transformer_blocks.19': 1, 'single_transformer_blocks.20': 1, 'single_transformer_blocks.21': 'cpu', 'single_transformer_blocks.22': 'cpu', 'single_transformer_blocks.23': 'cpu', 'single_transformer_blocks.24': 'cpu', 'single_transformer_blocks.25': 'cpu', 'single_transformer_blocks.26': 'cpu', 'single_transformer_blocks.27': 'cpu', 'single_transformer_blocks.28': 'cpu', 'single_transformer_blocks.29': 'cpu', 'single_transformer_blocks.30': 'cpu', 'single_transformer_blocks.31': 'cpu', 'single_transformer_blocks.32': 'cpu', 'single_transformer_blocks.33': 'cpu', 'single_transformer_blocks.34': 'cpu', 'single_transformer_blocks.35': 'cpu', 'single_transformer_blocks.36': 'cpu', 'single_transformer_blocks.37': 'cpu', 'norm_out': 'cpu', 'proj_out': 'cpu'
}
transformer = AutoModel.from_pretrained(
    "black-forest-labs/FLUX.1-dev", 
    subfolder="transformer",
    device_map=device_map,
    dtype=torch.bfloat16
)
```

Her cihaz için maksimum bellek kullanımını eşleyen bir sözlük geçirerek bir sınır uygulayın. Bir cihaz `max_memory` içinde değilse, yok sayılır ve pipeline bileşenleri ona dağıtılmaz.

```py
import torch
from diffusers import AutoModel, StableDiffusionXLPipeline
max_memory = {0:"1GB", 1:"1GB"}
pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16,
    device_map="balanced",
    max_memory=max_memory
)
```

Diffusers varsayılan olarak tüm cihazların maksimum belleğini kullanır, ancak bunlar GPU'lara sığmıyorsa aşağıdaki yöntemlerle tek bir GPU kullanıp CPU'ya taşımak gerekir.

- [enable_model_cpu_offload()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload) yalnızca tek bir GPU üzerinde çalışır ancak çok büyük bir model bu GPU'ya sığmayabilir
- [enable_sequential_cpu_offload()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.enable_sequential_cpu_offload) çalışabilir ancak son derece yavaştır ve ayrıca tek bir GPU ile sınırlıdır

`device_map`'i sıfırlamak için [reset_device_map()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.reset_device_map) yöntemini kullanın. Bir pipeline cihaz eşlemeli olarak yapılandırıldıysa ve `.to()`, [enable_sequential_cpu_offload()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.enable_sequential_cpu_offload) ve [enable_model_cpu_offload()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload) gibi yöntemleri kullanmak istiyorsanız bu işlem gereklidir.

```py
pipeline.reset_device_map()
```

## VAE dilimleme

VAE slicing, büyük girdi partilerini tek bir veri partisine bölerek ve bunları ayrı ayrı işleyerek bellek tasarrufu sağlar. Bu yöntem, aynı anda birden fazla görüntü oluşturulduğunda en iyi sonucu verir.

Örneğin, aynı anda 4 görsel üretiyorsanız, çözümleme (decoding) işlemi tepe aktivasyon belleğini 4 kat artırır. VAE dilimleme (slicing), 4 görselin tamamını aynı anda çözmek yerine her seferinde yalnızca 1 görseli çözerek bu artışı azaltır.

Dilimlenmiş VAE'yi etkinleştirmek için `enable_slicing()` çağrısını yapın. Çoklu görüntü toplu işlemlerini çözerken performansın küçük ölçüde artmasını, tek görüntülü toplu işlemlerde ise performans etkisi görmemenizi bekleyebilirsiniz.

```py
import torch
from diffusers import AutoModel, StableDiffusionXLPipeline
pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16,
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.vae.enable_slicing()
pipeline(["An astronaut riding a horse on Mars"]*32).images[0]
print(f"Max memory reserved: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB")
```

> [!WARNING]
> [AutoencoderKLWan](/docs/diffusers/main/tr/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan) ve [AsymmetricAutoencoderKL](/docs/diffusers/main/tr/api/models/asymmetricautoencoderkl#diffusers.AsymmetricAutoencoderKL) sınıfları dilimlemeyi desteklemez.

## VAE karolama

VAE tiling, bir görüntüyü tek seferde işlemek yerine daha küçük, üst üste binen karolara bölerek bellek tasarrufu sağlar. Bu, GPU'nun bir anda yalnızca bir karoyu işlemesi nedeniyle tepe bellek kullanımını da azaltır.

VAE karolarını etkinleştirmek için `enable_tiling()` çağrısını yapın. Karolar ayrı ayrı çözümlendiği için üretilen görüntüde karoladan karolaya hafif ton farklılıkları görülebilir, ancak karolar arasında belirgin dikişler olmamalıdır. Çözünürlük, önceden belirlenmiş (ancak yapılandırılabilir) bir sınırın altındaysa karolama devre dışı bırakılır. Örneğin, [StableDiffusionPipeline](/docs/diffusers/main/tr/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) içindeki VAE için bu sınır 512x512'dir.

```py
import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import load_image
pipeline = AutoPipelineForImage2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.vae.enable_tiling()
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-sdxl-init.png")
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
pipeline(prompt, image=init_image, strength=0.5).images[0]
print(f"Max memory reserved: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB")
```

> [!WARNING]
> [AutoencoderKLWan](/docs/diffusers/main/tr/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan) ve [AsymmetricAutoencoderKL](/docs/diffusers/main/tr/api/models/asymmetricautoencoderkl#diffusers.AsymmetricAutoencoderKL) karoları (tiling) desteklemez.

## Offloading

Offload stratejileri, şu anda aktif olmayan katmanları veya modelleri GPU belleğinin artmasını önlemek için CPU'ya taşır. Bu stratejiler, çıkarım hızı ile bellek kullanımı arasında denge kurmak için kuantizasyon ve torch.compile ile birleştirilebilir.

Daha fazla ayrıntı için [Derlenmiş ve offload edilmiş kuantize modeller](./speed-memory-optims) kılavuzuna başvurun.

### CPU'ya aktarma

CPU offloading, ağırlıkları seçici olarak GPU'dan CPU'ya taşır. Bir bileşen gerektiğinde GPU'ya aktarılır, gerekmediğinde ise CPU'ya taşınır. Bu yöntem, tüm modeller yerine alt modüller üzerinde çalışır. Tüm modeli GPU'da depolamaktan kaçınarak bellek tasarrufu sağlar.

CPU offloading bellek kullanımını dramatik olarak azaltır ancak alt modüllerin cihazlar arasında birden fazla kez ileri geri geçirilmesi nedeniyle **son derece yavaştır**. Bu kadar yavaş olması nedeniyle çoğu zaman pratik olmayabilir.

> [!WARNING]
> [enable_sequential_cpu_offload()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.enable_sequential_cpu_offload) çağrısından önce pipeline'ı CUDA'ya taşımayın, aksi takdirde tasarruf edilen bellek miktarı yalnızca minimal olacaktır (daha fazla ayrıntı için bu [issue](https://github.com/huggingface/diffusers/issues/1934)'a bakın). Bu, modele kancalar (hooks) kuran durumlu bir işlemdir.

Bir pipeline üzerinde etkinleştirmek için [enable_sequential_cpu_offload()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.enable_sequential_cpu_offload) çağrısını yapın.

```py
import torch
from diffusers import DiffusionPipeline
pipeline = DiffusionPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell", dtype=torch.bfloat16
)
pipeline.enable_sequential_cpu_offload()
pipeline(
    prompt="An astronaut riding a horse on Mars",
    guidance_scale=0.,
    height=768,
    width=1360,
    num_inference_steps=4,
    max_sequence_length=256,
).images[0]
print(f"Max memory reserved: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB")
```

### Model aktarımı

Model offloading, *bazı* katmanların veya model bileşenlerinin seçici olarak taşınması yerine tüm modelleri GPU'ya taşır. Ana hat modellerinden biri, genellikle metin kodlayıcı, UNet ve VAE, GPU'ya yerleştirilirken diğer bileşenler CPU'da tutulur. Birden fazla kez çalışan UNet gibi bileşenler, tamamen bitirilip artık ihtiyaç duyulmadığına kadar GPU'da kalır. Bu, [CPU offloading](#cpu-offloading) iletişiminin getirdiği ek yükü ortadan kaldırır ve model offloading'i daha hızlı bir alternatif haline getirir. Bunun bedeli ise bellek tasarrufunun o kadar büyük olmayacağıdır.

> [!WARNING]
> Modeler, hookler kurulduktan sonra pipeline dışında yeniden kullanılırsa (daha fazla ayrıntı için [Hook Kaldırma](https://huggingface.co/docs/accelerate/en/package_reference/big_modeling#accelerate.hooks.remove_hook_from_module) bölümüne bakın), bunları doğru şekilde offload edebilmek için tüm pipeline'ı ve modelleri beklenen sırayla çalıştırmanız gerektiğini unutmayın. Bu, modele hooklar kuran durumlu bir işlemdir.

Bir pipeline üzerinde etkinleştirmek için [enable_model_cpu_offload()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload) çağrısını yapın.

```py
import torch
from diffusers import DiffusionPipeline
pipeline = DiffusionPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell", dtype=torch.bfloat16
)
pipeline.enable_model_cpu_offload()
pipeline(
    prompt="An astronaut riding a horse on Mars",
    guidance_scale=0.,
    height=768,
    width=1360,
    num_inference_steps=4,
    max_sequence_length=256,
).images[0]
print(f"Max memory reserved: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB")
```

[enable_model_cpu_offload()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload), metin kodlayıcıların gizli durumunu üretmek için [encode_prompt()](/docs/diffusers/main/tr/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLPipeline.encode_prompt) yöntemini tek başına kullanırken de yardımcı olur.

### Grup dışa aktarma

Group offloading, iç katman gruplarını ([torch.nn.ModuleList](https://pytorch.org/docs/stable/generated/torch.nn.ModuleList.html) veya [torch.nn.Sequential](https://pytorch.org/docs/stable/generated/torch.nn.Sequential.html)) CPU'ya taşır. [model offloading](#model-offloading)'den daha az bellek kullanır ve iletişim maliyetini azalttığı için [CPU offloading](#cpu-offloading)'den daha hızlıdır.

> [!WARNING]
> Group offloading, ileri (forward) uygulaması girdilerin ağırlıklara bağlı cihaz dökümünü (device casting) içeriyorsa, tüm modellerle çalışmayabilir; çünkü bu durum, group offloading'in kendi cihaz döküm mekanizmasıyla çelişebilir.

`offload_type` parametresini `block_level` veya `leaf_level` olarak yapılandırarak grup boşaltmayı etkinleştirin.

- `block_level`, `num_blocks_per_group` parametresine göre katman gruplarını taşır (offload). Örneğin, 40 katmanlı bir modelde `num_blocks_per_group=2` ise, her seferinde 2 katman yüklenir (onload) ve taşınır (offload) (toplamda 20 onload/offload). Bu, bellek gereksinimlerini önemli ölçüde azaltır.
- `leaf_level`, en düşük seviyede katmanları tek tek taşır ve [CPU offloading](#cpu-offloading) ile eşdeğerdir. Ancak, çıkarım hızından ödün vermeden akışlar (streams) kullanarak daha hızlı hale getirilebilir.

Grup offload, tüm pipeline'lar veya bireysel modeller için desteklenir. Grup offload'ın tüm pipeline'a uygulanması en kolay seçenekken, bireysel modellere seçici olarak uygulanması, kullanıcılara farklı modeller için farklı offload teknikleri kullanma konusunda daha fazla esneklik sağlar.

Bir pipeline üzerinde [enable_group_offload()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.enable_group_offload) çağırın.

```py
import torch
from diffusers import CogVideoXPipeline
from diffusers.hooks import apply_group_offloading
from diffusers.utils import export_to_video
onload_device = torch.device("cuda")
offload_device = torch.device("cpu")
pipeline = CogVideoXPipeline.from_pretrained("THUDM/CogVideoX-5b", dtype=torch.bfloat16)
pipeline.enable_group_offload(
    onload_device=onload_device,
    offload_device=offload_device,
    offload_type="leaf_level",
    use_stream=True
)
prompt = (
    "A panda, dressed in a small, red jacket and a tiny hat, sits on a wooden stool in a serene bamboo forest. "
    "The panda's fluffy paws strum a miniature acoustic guitar, producing soft, melodic tunes. Nearby, a few other "
    "pandas gather, watching curiously and some clapping in rhythm. Sunlight filters through the tall bamboo, "
    "casting a gentle glow on the scene. The panda's face is expressive, showing concentration and joy as it plays. "
    "The background includes a small, flowing stream and vibrant green foliage, enhancing the peaceful and magical "
    "atmosphere of this unique musical performance."
)
video = pipeline(prompt=prompt, guidance_scale=6, num_inference_steps=50).frames[0]
print(f"Max memory reserved: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB")
export_to_video(video, "output.mp4", fps=8)
```

[ModelMixin](/docs/diffusers/main/tr/api/models/overview#diffusers.ModelMixin) sınıfından türeyen standart Diffusers model bileşenlerinde [enable_group_offload()](/docs/diffusers/main/tr/api/models/overview#diffusers.ModelMixin.enable_group_offload) çağrın. [ModelMixin](/docs/diffusers/main/tr/api/models/overview#diffusers.ModelMixin) sınıfından türemeyen, örneğin genel bir [torch.nn.Module](https://pytorch.org/docs/stable/generated/torch.nn.Module.html) gibi diğer model bileşenleri için bunun yerine [apply_group_offloading()](/docs/diffusers/main/tr/api/utilities#diffusers.hooks.apply_group_offloading) kullanın.

```py
import torch
from diffusers import CogVideoXPipeline
from diffusers.hooks import apply_group_offloading
from diffusers.utils import export_to_video
onload_device = torch.device("cuda")
offload_device = torch.device("cpu")
pipeline = CogVideoXPipeline.from_pretrained("THUDM/CogVideoX-5b", dtype=torch.bfloat16)
# Use the enable_group_offload method for Diffusers model implementations
pipeline.transformer.enable_group_offload(onload_device=onload_device, offload_device=offload_device, offload_type="leaf_level")
pipeline.vae.enable_group_offload(onload_device=onload_device, offload_type="leaf_level")
# Use the apply_group_offloading method for other model components
apply_group_offloading(pipeline.text_encoder, onload_device=onload_device, offload_type="block_level", num_blocks_per_group=2)
prompt = (
    "A panda, dressed in a small, red jacket and a tiny hat, sits on a wooden stool in a serene bamboo forest. "
    "The panda's fluffy paws strum a miniature acoustic guitar, producing soft, melodic tunes. Nearby, a few other "
    "pandas gather, watching curiously and some clapping in rhythm. Sunlight filters through the tall bamboo, "
    "casting a gentle glow on the scene. The panda's face is expressive, showing concentration and joy as it plays. "
    "The background includes a small, flowing stream and vibrant green foliage, enhancing the peaceful and magical "
    "atmosphere of this unique musical performance."
)
video = pipeline(prompt=prompt, guidance_scale=6, num_inference_steps=50).frames[0]
print(f"Max memory reserved: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB")
export_to_video(video, "output.mp4", fps=8)
```

#### CUDA akışı

`use_stream` parametresi, asenkron veri aktarım akışlarını destekleyen CUDA cihazlarında, [CPU offloading](#cpu-offloading) ile karşılaştırıldığında genel çalışma süresini azaltmak için etkinleştirilebilir. Katman ön yükleme (layer prefetching) kullanarak veri aktarımı ile hesaplamayı üst üste bindirir. Çalıştırılacak bir sonraki katman, mevcut katman hâlâ çalıştırılırken GPU'ya yüklenir. Bu, CPU belleğini önemli ölçüde artırabilir; bu nedenle model boyutunun iki katı kadar belleğe sahip olduğunuzdan emin olun.

Daha fazla hızlanma için hafif bir bellek kullanımı artışı pahasına `record_stream=True` ayarlayın. Daha fazla bilgi için [torch.Tensor.record_stream](https://pytorch.org/docs/stable/generated/torch.Tensor.record_stream.html) belgelerine bakın.

> [!TIP]
> Tiling etkinleştirilmiş VAE'lerde `use_stream=True` kullanırken, cihaz uyumsuzluğu hatalarını önlemek için çıkarımdan önce sahte bir ileri geçiş (sahte girdilerle de yapılabilir) yapmanızdan emin olun. Bu, tüm uygulamalarda çalışmayabilir, bu nedenle herhangi bir sorunla karşılaşırsanız bir sorun (issue) açmaktan çekinmeyin.
`block_level` grup offloading kullanıyorsanız ve `use_stream` etkinleştirildiyse, `num_blocks_per_group` parametresi `1` olarak ayarlanmalıdır, aksi takdirde bir uyarı oluşturulur.

```py
pipeline.transformer.enable_group_offload(onload_device=onload_device, offload_device=offload_device, offload_type="leaf_level", use_stream=True, record_stream=True)
```

`low_cpu_mem_usage` parametresi, grup dışa aktarma sırasında akışlar kullanılırken CPU bellek kullanımını azaltmak için `True` olarak ayarlanabilir. Bu, `leaf_level` dışa aktarma ve CPU belleğinin darboğaz olduğu durumlarda en iyi seçenektir. Bellek, önceden sabitlemek yerine sabitlenmiş tensörleri anlık olarak oluşturarak tasarruf edilir. Ancak bu, genel çalışma süresini artırabilir.

#### Disk'e aktarma

Grup dışa aktarma, model boyutuna bağlı olarak önemli miktarda sistem belleği tüketebilir. Sınırlı belleğe sahip sistemlerde, ikincil bellek olarak diske grup dışa aktarmayı deneyin.

Modeli diske taşımak için `offload_to_disk_path` argümanını [enable_group_offload()](/docs/diffusers/main/tr/api/models/overview#diffusers.ModelMixin.enable_group_offload) veya [apply_group_offloading()](/docs/diffusers/main/tr/api/utilities#diffusers.hooks.apply_group_offloading) içinde ayarlayın.

```py
pipeline.transformer.enable_group_offload(onload_device=onload_device, offload_device=offload_device, offload_type="leaf_level", offload_to_disk_path="path/to/disk")
apply_group_offloading(pipeline.text_encoder, onload_device=onload_device, offload_type="block_level", num_blocks_per_group=2, offload_to_disk_path="path/to/disk")
```

Hız ve bellek ödünleşimlerini karşılaştırmak için bu [iki](https://github.com/huggingface/diffusers/pull/11682#issue-3129365363) [tabloya](https://github.com/huggingface/diffusers/pull/11682#issuecomment-2955715126) başvurun.

## Katman bazlı döküm

> [!TIP]
> Daha fazla bellek tasarrufu için katman bazlı dökümleme (casting) ile [grup offloading](#group-offloading) özelliğini birleştirin.

Layerwise casting, ağırlıkları daha küçük bir veri biçiminde (örneğin `torch.float8_e4m3fn` ve `torch.float8_e5m2`) saklayarak daha az bellek kullanır ve bu ağırlıkları hesaplama için `torch.float16` veya `torch.bfloat16` gibi daha yüksek bir hassasiyete yükseltir. fp8'de saklanmalarının üretim kalitesini düşürebilmesi nedeniyle belirli katmanlar (normalizasyon ve modülasyon ile ilgili ağırlıklar) atlanır.

> [!WARNING]
> Katman bazlı dönüştürme, ileri (forward) uygulaması ağırlıkların içsel tip dönüşümünü içeriyorsa tüm modellerle çalışmayabilir. Katman bazlı dönüştürmenin mevcut uygulaması, ileri geçişin ağırlık hassasiyetinden bağımsız olduğunu ve girdi veri türlerinin her zaman `compute_dtype` olarak belirtildiğini varsayar (uyumsuz bir uygulama için [buraya](https://github.com/huggingface/transformers/blob/7f5077e53682ca855afc826162b204ebf809f1f9/src/transformers/models/t5/modeling_t5.py#L294-L299) bakın).
>
> Katman bazlı dönüştürme, [PEFT](https://huggingface.co/docs/peft/index) katmanlarına sahip özel modelleme uygulamalarında da başarısız olabilir. Bazı kontroller mevcuttur ancak bunlar kapsamlı şekilde test edilmemiştir ve tüm durumlarda çalışacağı garanti edilmemektedir.
Depolama ve hesaplama veri türlerini ayarlamak için [enable_layerwise_casting()](/docs/diffusers/main/tr/api/models/overview#diffusers.ModelMixin.enable_layerwise_casting) çağrın.
```py
import torch
from diffusers import CogVideoXPipeline, CogVideoXTransformer3DModel
from diffusers.utils import export_to_video
transformer = CogVideoXTransformer3DModel.from_pretrained(
    "THUDM/CogVideoX-5b",
    subfolder="transformer",
    dtype=torch.bfloat16
)
transformer.enable_layerwise_casting(storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16)
pipeline = CogVideoXPipeline.from_pretrained("THUDM/CogVideoX-5b",
    transformer=transformer,
    dtype=torch.bfloat16
).to("cuda")  # or "mps", "xpu", "cpu"
prompt = (
    "A panda, dressed in a small, red jacket and a tiny hat, sits on a wooden stool in a serene bamboo forest. "
    "The panda's fluffy paws strum a miniature acoustic guitar, producing soft, melodic tunes. Nearby, a few other "
    "pandas gather, watching curiously and some clapping in rhythm. Sunlight filters through the tall bamboo, "
    "casting a gentle glow on the scene. The panda's face is expressive, showing concentration and joy as it plays. "
    "The background includes a small, flowing stream and vibrant green foliage, enhancing the peaceful and magical "
    "atmosphere of this unique musical performance."
)
video = pipeline(prompt=prompt, guidance_scale=6, num_inference_steps=50).frames[0]
print(f"Max memory reserved: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB")
export_to_video(video, "output.mp4", fps=8)
```
Daha fazla kontrol ve esneklik gerekiyorsa [apply_layerwise_casting()](/docs/diffusers/main/tr/api/utilities#diffusers.hooks.apply_layerwise_casting) metodu da kullanılabilir. Belirli iç modüller üzerinde çağrılarak model katmanlarına kısmen uygulanabilir. Normalizasyon ve modülasyon katmanları gibi kaçınılması gereken modülleri belirtmek için `skip_modules_pattern` veya `skip_modules_classes` parametrelerini kullanın.
```python
import torch
from diffusers import CogVideoXTransformer3DModel
from diffusers.hooks import apply_layerwise_casting
transformer = CogVideoXTransformer3DModel.from_pretrained(
    "THUDM/CogVideoX-5b",
    subfolder="transformer",
    dtype=torch.bfloat16
)
# skip the normalization layer
apply_layerwise_casting(
    transformer,
    storage_dtype=torch.float8_e4m3fn,
    compute_dtype=torch.bfloat16,
    skip_modules_classes=["norm"],
    non_blocking=True,
)
```
## torch.channels_last
[torch.channels_last](https://pytorch.org/tutorials/intermediate/memory_format_tutorial.html), tensörlerin depolanma biçimini `(batch size, channels, height, width)` düzeninden `(batch size, height, width, channels)` düzenine çevirir. Bu, tensörlerin bellekteki depolama düzeniyle donanımın tensörlere sıralı erişim yapma biçimini hizalar ve piksel değerlerine erişmek için bellekte ileri geri atlamaları önler.
Tüm operatörler şu anda channels-last formatını desteklememekte ve bu durum daha düşük performansa yol açabilir, ancak yine de denemeye değerdir.
```py
print(pipeline.unet.conv_out.state_dict()["weight"].stride())  # (2880, 9, 3, 1)
pipeline.unet.to(memory_format=torch.channels_last)  # in-place operation
print(
    pipeline.unet.conv_out.state_dict()["weight"].stride()
)  # (2880, 1, 960, 320) having a stride of 1 for the 2nd dimension proves that it works
```
## Hafıza-verimli dikkat
Diffusers, [set_attention_backend()](/docs/diffusers/main/tr/api/models/overview#diffusers.ModelMixin.set_attention_backend) aracılığıyla birden fazla bellek verimli dikkat (attention) arka uçunu (FlashAttention, xFormers, SageAttention ve diğerleri) destekler. Bunlar arasında nasıl geçiş yapılacağını öğrenmek için [Attention backends](./attention_backends) kılavuzuna başvurun.
Xet Storage Details

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