Düşük VRAM ile Stable Diffusion Optimizasyonu

Yazar:komut.io ekibi
0 Yorum

4GB VRAM’li bir ekran kartıyla Stable Diffusion çalıştırmaya çalışmak, bazen sonsuz “CUDA out of memory” hataları ve yarım kalan render’larla boğuşmak demek oluyor. Bu yazıda, düşük VRAM’li sistemlerde Stable Diffusion’ı makul hızda ve kararlı biçimde çalıştırmak için kullanabileceğiniz optimizasyon tekniklerini, komutları ve yapılandırmaları ele alacağım. Konuyu özellikle 4GB ve 6GB VRAM’li kartlar üzerinden işleyeceğim ama 8GB’a kadar olan sistemlerde de büyük kısmı geçerli.

Durumu Anlamak: VRAM Neden Sorun Oluyor?

Stable Diffusion bir görüntü üretirken aynı anda birçok bileşeni bellekte tutuyor. Model ağırlıkları (weights), aktivasyon tensörleri, ara çıktılar ve VAE tamponu bunların başında geliyor. SD 1.5 modeli float32 hassasiyetle yaklaşık 4GB VRAM istiyor, SDXL ise bu rakamı 10GB’ın üzerine çıkarabiliyor. Dolayısıyla optimizasyon stratejiniz hem hangi modeli kullandığınıza hem de hedeflediğiniz çözünürlüğe göre şekillenecek.

Önce sisteminizin mevcut VRAM durumuna bakın:

# NVIDIA kartlar için
nvidia-smi --query-gpu=name,memory.total,memory.free,memory.used --format=csv,noheader

# Daha ayrıntılı izleme için
watch -n 1 nvidia-smi

AMD kartlar için (ROCm kullanıyorsanız):

rocm-smi --showmeminfo vram

Bu çıktılardan toplam VRAM’inizi ve boş kapasiteyi görürsünüz. Eğer masaüstü ortamınız 500MB-1GB arası VRAM kullanıyorsa, gerçek kullanılabilir alanınız daha da düşük demektir.

AUTOMATIC1111 Başlatma Parametreleri

AUTOMATIC1111 WebUI, düşük VRAM için özelleştirilmiş başlatma argümanları sunuyor. webui.sh (Linux) veya webui-user.bat (Windows) dosyanızı açarak COMMANDLINE_ARGS değişkenini düzenlemeniz gerekiyor.

# Linux: webui.sh veya webui-user.sh içinde
export COMMANDLINE_ARGS="--medvram --opt-split-attention --no-half-vae"
# 4GB ve altı için daha agresif ayarlar
export COMMANDLINE_ARGS="--lowvram --opt-split-attention --opt-sub-quad-attention --no-half-vae --always-batch-cond-uncond"

Bu parametrelerin ne işe yaradığını bilmek önemli, çünkü yanlış kombinasyon performansı daha da düşürebilir:

  • –lowvram: Modelin büyük bölümlerini CPU RAM’e aktarır, çok yavaş ama çok az VRAM kullanır
  • –medvram: Daha dengeli bir yaklaşım, model bileşenlerini gerektiğinde yükler
  • –opt-split-attention: Dikkat (attention) mekanizmasını parçalara bölerek işler, VRAM tasarrufu sağlar
  • –opt-sub-quad-attention: Özellikle yüksek çözünürlüklerde sub-quadratic attention kullanır
  • –no-half-vae: VAE için float16 yerine float32 kullanır, siyah görüntü sorununu çözer
  • –always-batch-cond-uncond: Classifier-free guidance hesaplamalarını ayrı batch’lere böler

Gerçek dünyadan bir örnek: RTX 3050 (4GB) kullanıcıları genellikle --medvram --opt-split-attention --no-half-vae kombinasyonuyla 512×512 görüntüleri stabil üretebiliyor. Ancak 768×768 ve üzeri için --opt-sub-quad-attention eklemek neredeyse zorunlu hale geliyor.

Model Formatları ve Hassasiyet Optimizasyonu

Modeli nasıl yüklediğiniz, VRAM kullanımını doğrudan etkiliyor. Float32 yerine float16 kullanmak, model boyutunu yarıya indiriyor.

# Model dönüştürme scripti (PyTorch)
python3 << 'EOF'
import torch

# float32 modeli float16'ya dönüştür
model_path = "/path/to/your/model.ckpt"
output_path = "/path/to/your/model_fp16.ckpt"

checkpoint = torch.load(model_path, map_location="cpu")

if "state_dict" in checkpoint:
    state_dict = checkpoint["state_dict"]
else:
    state_dict = checkpoint

# Tüm tensörleri float16'ya dönüştür
fp16_state_dict = {k: v.half() if v.is_floating_point() else v 
                   for k, v in state_dict.items()}

torch.save({"state_dict": fp16_state_dict}, output_path)
print(f"Dönüştürüldü: {output_path}")
EOF

SafeTensor formatı da önemli bir optimizasyon noktası. .ckpt dosyaları PyTorch’un tüm pickle yapısını içerirken, .safetensors sadece tensör verilerini saklar. Bu hem güvenlik hem de yükleme hızı açısından avantajlı:

# safetensors dönüşümü için gerekli paket
pip install safetensors

python3 << 'EOF'
import torch
from safetensors.torch import save_file

checkpoint = torch.load("model.ckpt", map_location="cpu")
state_dict = checkpoint.get("state_dict", checkpoint)

# float16'ya dönüştürerek safetensors olarak kaydet
fp16_dict = {k: v.half() if v.is_floating_point() else v 
             for k, v in state_dict.items()}

save_file(fp16_dict, "model_fp16.safetensors")
print("SafeTensors dönüşümü tamamlandı")
EOF

xformers Kurulumu ve Konfigürasyonu

xformers kütüphanesi, attention hesaplamalarını optimize ederek hem VRAM kullanımını hem de işlem süresini ciddi ölçüde azaltıyor. Bazı kullanıcılarda %40-50 oranında VRAM tasarrufu ve hız artışı rapor ediliyor.

# AUTOMATIC1111 sanal ortamında xformers kurulumu
cd stable-diffusion-webui
source venv/bin/activate

# CUDA versiyonunuza uygun xformers kurulumu
pip install xformers==0.0.21 --extra-index-url https://download.pytorch.org/whl/cu118

# Veya doğrudan pip ile (uyumlu sürümü otomatik seçer)
pip install xformers

xformers kurduktan sonra WebUI’yi --xformers argümanıyla başlatın:

export COMMANDLINE_ARGS="--medvram --xformers --opt-split-attention --no-half-vae"

xformers’ın düzgün yüklenip yüklenmediğini kontrol etmek için WebUI’nin başlangıç loglarına bakabilirsiniz. “xformers version” satırını görüyorsanız aktif demektir. Görmüyorsanız CUDA sürüm uyumsuzluğu ihtimali yüksek, bu durumda CUDA versiyonunuzu kontrol edin:

nvcc --version
python3 -c "import torch; print(torch.version.cuda)"

Tile VAE ve Upscaling Optimizasyonu

Yüksek çözünürlüklü görüntüler üretirken VAE aşaması genellikle en fazla VRAM tüketen kısım oluyor. Tiled VAE özelliği, büyük görüntüleri küçük parçalar halinde işleyerek bu sorunu çözüyor. AUTOMATIC1111’de “Tiled VAE” eklentisi bunu sağlıyor:

# Eklentiyi komut satırından kurmak için
cd stable-diffusion-webui/extensions
git clone https://github.com/pkuliyi2015/multidiffusion-upscaler-for-automatic1111.git

# WebUI'yi yeniden başlatın
cd ..
./webui.sh

Tiled VAE ayarları için WebUI’de “Settings > Tiled VAE” bölümüne gidin. 4GB VRAM için önerilen değerler:

  • Encoder Tile Size: 512 (yüksek çözünürlük için 256’ya indirin)
  • Decoder Tile Size: 64 (bellek sorunlarında 32’ye indirin)
  • Fast Decoder: Etkin
  • Fast Encoder: Etkin

Batch Size ve Sampling Optimizasyonu

Birden fazla görüntüyü aynı anda üretmeye çalışmak, VRAM kullanımını katlar. 4GB sistemlerde batch size her zaman 1 tutulmalı. Bunun yanında sampling method seçimi de VRAM’i etkiliyor:

# config.json veya ui-config.json içinde varsayılan değerleri ayarlayın
cat > stable-diffusion-webui/ui-config.json << 'EOF'
{
  "txt2img/Batch size/value": 1,
  "txt2img/Width/value": 512,
  "txt2img/Height/value": 512,
  "txt2img/Sampling steps/value": 20,
  "txt2img/Sampling method/value": "DPM++ 2M Karras",
  "img2img/Batch size/value": 1
}
EOF

DPM++ 2M Karras ve DPM++ SDE Karras, az adımda (15-25 adım) iyi sonuç veren sampler’lar. DDIM ve Euler a da VRAM açısından verimli seçenekler. PLMS ise biraz daha fazla bellek kullanıyor.

Quantization ile Model Sıkıştırma

4-bit veya 8-bit quantization, model boyutunu dramatik biçimde küçültüyor. bitsandbytes kütüphanesi bu iş için standart araç haline geldi:

pip install bitsandbytes accelerate

python3 << 'EOF'
from diffusers import StableDiffusionPipeline
import torch

# 8-bit quantization ile model yükleme
from diffusers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_8bit=True,
    llm_int8_threshold=6.0
)

pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16,
    device_map="auto"
)

pipe.enable_attention_slicing()
pipe.enable_vae_slicing()
pipe.enable_model_cpu_offload()

prompt = "a beautiful landscape, 8k, detailed"
image = pipe(prompt, num_inference_steps=20).images[0]
image.save("output.png")
print("Görüntü oluşturuldu!")
EOF

enable_model_cpu_offload() özellikle kritik, çünkü aktif olarak kullanılmayan model bileşenlerini CPU RAM’e taşıyarak VRAM’i boşaltıyor. 4GB sistemlerde bu yöntemi enable_attention_slicing() ile birlikte kullanmak en stabil sonucu veriyor.

Otomatik Bellek Yönetimi Script’i

Üretim ortamında birden fazla görüntü üretirken bellek sızıntılarını önlemek için basit bir yönetim script’i yazabilirsiniz:

#!/bin/bash
# sd_memory_manager.sh - VRAM izleme ve temizleme scripti

THRESHOLD=3500  # MB cinsinden uyarı eşiği
LOG_FILE="/var/log/sd_vram.log"

monitor_vram() {
    while true; do
        USED=$(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits | head -1 | tr -d ' ')
        TOTAL=$(nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits | head -1 | tr -d ' ')
        TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
        
        echo "$TIMESTAMP - VRAM Kullanimi: ${USED}MB / ${TOTAL}MB" >> "$LOG_FILE"
        
        if [ "$USED" -gt "$THRESHOLD" ]; then
            echo "$TIMESTAMP - UYARI: VRAM esigi asildi! (${USED}MB)" >> "$LOG_FILE"
            # WebUI'ye sinyal gonder veya cache temizle
            kill -SIGUSR1 $(pgrep -f "webui.py") 2>/dev/null
        fi
        
        sleep 30
    done
}

cleanup_vram() {
    echo "GPU bellek cache temizleniyor..."
    python3 -c "import torch; torch.cuda.empty_cache(); print('Cache temizlendi')"
    sync
    echo 3 > /proc/sys/vm/drop_caches
    echo "Sistem bellek cache temizlendi"
}

case "$1" in
    monitor)
        monitor_vram &
        echo "VRAM izleme baslatildi (PID: $!)"
        ;;
    cleanup)
        cleanup_vram
        ;;
    status)
        nvidia-smi --query-gpu=name,memory.total,memory.free,memory.used --format=csv
        ;;
    *)
        echo "Kullanim: $0 {monitor|cleanup|status}"
        exit 1
        ;;
esac

ControlNet ve LoRA ile VRAM Dengeleme

ControlNet ve LoRA kullanırken VRAM baskısı daha da artıyor. ControlNet modelleri ortalama 1-1.5GB ek VRAM gerektiriyor. Bazı pratik önlemler:

  • ControlNet için half precision: WebUI ayarlarında “ControlNet > Model caching” kapalı tutun, her seferinde yeniden yüklemek yerine sadece bir model aktif bırakın
  • LoRA için küçük rank değerleri: r=4 veya r=8 olan LoRA’lar, r=64 olanlardan çok daha az VRAM kullanıyor
# ControlNet modellerini fp16'ya dönüştürme toplu scripti
#!/bin/bash

CONTROLNET_DIR="stable-diffusion-webui/extensions/sd-webui-controlnet/models"
OUTPUT_DIR="${CONTROLNET_DIR}/fp16"

mkdir -p "$OUTPUT_DIR"

for model in "$CONTROLNET_DIR"/*.pth; do
    filename=$(basename "$model")
    output="${OUTPUT_DIR}/${filename}"
    
    echo "Dönüstürülüyor: $filename"
    
    python3 << PYEOF
import torch
checkpoint = torch.load("$model", map_location="cpu")
fp16_checkpoint = {}
for k, v in checkpoint.items():
    if isinstance(v, torch.Tensor) and v.is_floating_point():
        fp16_checkpoint[k] = v.half()
    else:
        fp16_checkpoint[k] = v
torch.save(fp16_checkpoint, "$output")
print("Tamamlandi: $output")
PYEOF

done
echo "Tüm ControlNet modelleri dönüstürüldü"

Gerçek Dünya Senaryosu: 4GB RX 580 ile Çalışma

AMD kartlarla Stable Diffusion çalıştırmak daha zorlu çünkü ROCm desteği NVIDIA kadar olgun değil. Ancak 4GB VRAM’li RX 580 ile çalışmak mümkün:

# ROCm kurulumu kontrol
rocminfo | grep "gfx"

# HSA_OVERRIDE ile eski kartlar için zorla aktifleştirme
export HSA_OVERRIDE_GFX_VERSION=10.3.0
export PYTORCH_HIP_ALLOC_CONF=garbage_collection_threshold:0.8,max_split_size_mb:512

# WebUI başlatma
export COMMANDLINE_ARGS="--lowvram --precision full --no-half --opt-split-attention"
./webui.sh

max_split_size_mb parametresi PyTorch’un bellek ayırma stratejisini etkiliyor. Düşük değerler daha fazla parçalanma ama daha az büyük bellek bloğu ihtiyacı anlamına geliyor. 4GB kartlar için 256-512 arası değerler genellikle iyi sonuç veriyor.

Windows’ta Sayfalama Dosyası Optimizasyonu

Windows’ta VRAM yetersiz kaldığında sistem, GPU belleğini sanal bellek olarak kullanmaya çalışıyor. Bu aşırı yavaşlamaya sebep oluyor. Sayfalama dosyasını SSD üzerinde ve yeterli büyüklükte tutmak bu durumda yardımcı oluyor:

# PowerShell ile sayfalama dosyası ayarı
# (Yönetici olarak çalıştırın)
$computersys = Get-WmiObject Win32_ComputerSystem
$computersys.AutomaticManagedPagefile = $False
$computersys.Put()

$pagefile = Get-WmiObject -Query "Select * From Win32_PageFileSetting"
$pagefile.InitialSize = 16384  # 16GB başlangıç
$pagefile.MaximumSize = 32768  # 32GB maksimum
$pagefile.Put()

Write-Host "Sayfalama dosyasi ayarlandi. Yeniden baslatma gerekli."

ComfyUI ile Alternatif Yaklaşım

AUTOMATIC1111 yerine ComfyUI kullanmak, düşük VRAM sistemlerde bazen daha iyi sonuç veriyor. ComfyUI’nin node tabanlı yapısı, belleği daha granüler biçimde yönetmenize izin veriyor:

# ComfyUI kurulumu
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
pip install -r requirements.txt

# Düşük VRAM modu ile başlatma
python main.py --lowvram --fp16-vae

# Çok düşük VRAM için
python main.py --novram --fp16-vae --cpu-vae

ComfyUI’de --novram seçeneği tüm modeli CPU’ya taşıyor, bu son çare ama en azından çalışıyor. Bir A4000 benzeri iş istasyonu kartınız yoksa SDXL için ComfyUI + --lowvram + tiled VAE kombinasyonu 8GB altı sistemlerin en makul seçeneği.

Sonuç

Düşük VRAM’li sistemlerde Stable Diffusion çalıştırmak tamamen mümkün, sadece doğru araçları ve ayarları bulmak zaman alıyor. Özetlemek gerekirse öncelik sırası şu şekilde:

  • İlk adım olarak --medvram veya --lowvram ve --opt-split-attention ekleyin
  • xformers kurulumu ile başlayın, büyük kazanımlar sağlıyor
  • Model ağırlıklarını float16 veya safetensors formatına dönüştürün
  • Tiled VAE ile yüksek çözünürlük sorununu aşın
  • Batch size’ı 1’de tutun, adım sayısını gereksiz yükseltmeyin
  • ControlNet kullanıyorsanız modelleri de fp16’ya çevirin

Her sistemin konfigürasyonu farklı olduğu için bu parametreleri tek tek test etmenizi öneririm. Bir değişiklik yapıp VRAM kullanımını nvidia-smi ile izleyin, ardından bir sonraki optimizasyona geçin. Kör bir şekilde tüm parametreleri aynı anda uygulamak bazen çakışmalara ve beklenmedik sorunlara yol açıyor. Sabırlı, sistematik bir yaklaşımla 4GB VRAM’le bile makul kalitede görüntüler üretebilirsiniz.

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir