Stable Diffusion ile Video Oluşturma: Img2Vid ve AnimateDiff Kullanımı

Görüntüden videoya geçiş, yapay zeka dünyasının son yıllarda en heyecan verici gelişmelerinden biri. Stable Diffusion ekosistemi bu konuda da öne çıkıyor; özellikle Img2Vid ve AnimateDiff araçları sayesinde statik görüntüleri hareketli videolara dönüştürmek artık çok daha erişilebilir hale geldi. Bu yazıda, bir sysadmin perspektifinden bu araçları nasıl kuracağınızı, yapılandıracağınızı ve optimize edeceğinizi anlatacağım.

Gereksinimler ve Sistem Hazırlığı

Başlamadan önce donanım gereksinimlerini netleştirelim. Video üretimi, statik görüntü üretiminden çok daha fazla kaynak tüketiyor.

Minimum gereksinimler:

• NVIDIA GPU, en az 8GB VRAM (RTX 3060 veya üzeri)
• 32GB RAM (16GB ile de çalışır ama acı çekersiniz)
• 50GB boş disk alanı
• CUDA 11.8 veya üzeri
• Python 3.10.x

Önerilen kurulum:

• RTX 3090 veya RTX 4090 (24GB VRAM)
• 64GB RAM
• NVMe SSD

Önce sistem paketlerini güncelleyelim ve gerekli bağımlılıkları kuralım:

# Ubuntu/Debian için
sudo apt update && sudo apt upgrade -y
sudo apt install -y git wget curl python3.10 python3.10-venv python3-pip
sudo apt install -y libgl1-mesa-glx libglib2.0-0 ffmpeg

# FFmpeg versiyonunu kontrol et
ffmpeg -version

# CUDA kurulumunu doğrula
nvidia-smi
nvcc --version

Python sanal ortamını oluşturmak şart. Global Python ortamını kirletmek istemiyoruz:

# Çalışma dizinini oluştur
mkdir -p ~/stable-diffusion-video
cd ~/stable-diffusion-video

# Sanal ortam kur
python3.10 -m venv venv
source venv/bin/activate

# pip'i güncelle
pip install --upgrade pip setuptools wheel

AUTOMATIC1111 WebUI Kurulumu ve Video Uzantıları

AnimateDiff için en yaygın kullanılan arayüz AUTOMATIC1111 WebUI. Kurulumu adım adım yapalım:

# WebUI'yi klonla
git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git
cd stable-diffusion-webui

# Uzantılar dizinine git
cd extensions

# AnimateDiff uzantısını kur
git clone https://github.com/continue-revolution/sd-webui-animatediff.git

# Img2Vid için video uzantısı
git clone https://github.com/deforum-art/sd-webui-deforum.git

# Ana dizine dön
cd ..

WebUI’yi başlatmadan önce webui-user.sh dosyasını düzenlememiz gerekiyor. Video üretimi için ekstra argümanlar önemli:

# webui-user.sh dosyasını düzenle
cat > webui-user.sh << 'EOF'
#!/bin/bash
export COMMANDLINE_ARGS="--xformers --medvram-sdxl --opt-split-attention --no-half-vae"
export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512
export CUDA_VISIBLE_DEVICES=0
venv_dir="venv"
EOF

chmod +x webui-user.sh

# WebUI'yi başlat
./webui.sh

Eğer birden fazla GPU’nuz varsa ve yükü dağıtmak istiyorsanız:

# İki GPU için örnek yapılandırma
export CUDA_VISIBLE_DEVICES=0,1
export COMMANDLINE_ARGS="--xformers --medvram --opt-split-attention --listen --port 7860"

AnimateDiff Modeli ve Motion Module Kurulumu

AnimateDiff’in çalışması için motion modülleri şart. Bu modüller, görüntüler arasındaki hareketi öğrenmiş ağırlıkları içeriyor:

# Model dizinlerini oluştur
mkdir -p models/AnimateDiff
cd models/AnimateDiff

# Motion modüllerini indir (huggingface-cli kullanarak)
pip install huggingface_hub

python3 << 'EOF'
from huggingface_hub import hf_hub_download
import os

# Ana motion modülü
hf_hub_download(
    repo_id="guoyww/animatediff",
    filename="mm_sd_v15_v2.ckpt",
    local_dir="./models/AnimateDiff"
)

# SDXL için motion modülü
hf_hub_download(
    repo_id="guoyww/animatediff",
    filename="mm_sdxl_v10_beta.ckpt",
    local_dir="./models/AnimateDiff"
)

print("Modeller başarıyla indirildi!")
EOF

Motion modülleri indirildikten sonra WebUI’deki AnimateDiff sekmesini açıp yapılandırma yapmanız gerekiyor. Ancak bazı ayarları API üzerinden de yapabilirsiniz.

Img2Vid: Görüntüden Video Oluşturma

Img2Vid işlemi için Stable Video Diffusion (SVD) modelini kullanacağız. Bu model özellikle görüntüden video üretimi için tasarlanmış:

# SVD modelini indir
cd ~/stable-diffusion-video/stable-diffusion-webui/models

mkdir -p svd
python3 << 'EOF'
from huggingface_hub import snapshot_download

# Stable Video Diffusion modelini indir
snapshot_download(
    repo_id="stabilityai/stable-video-diffusion-img2vid-xt",
    local_dir="./svd/stable-video-diffusion-img2vid-xt",
    ignore_patterns=["*.md", "*.txt"]
)
print("SVD modeli hazır!")
EOF

Python ile doğrudan SVD kullanımı için basit bir script yazalım. Bu scripti production ortamında batch işlem için kullanabilirsiniz:

cat > img2vid_generate.py << 'EOF'
import torch
from diffusers import StableVideoDiffusionPipeline
from diffusers.utils import load_image, export_to_video
import sys
import os

def generate_video(image_path, output_path, num_frames=25, fps=7):
    """
    Görüntüden video oluşturur
    
    Parametreler:
    - image_path: Kaynak görüntünün yolu
    - output_path: Çıktı video yolu (.mp4)
    - num_frames: Üretilecek kare sayısı (14 veya 25)
    - fps: Saniyedeki kare sayısı
    """
    
    print(f"Model yükleniyor...")
    pipe = StableVideoDiffusionPipeline.from_pretrained(
        "stabilityai/stable-video-diffusion-img2vid-xt",
        torch_dtype=torch.float16,
        variant="fp16"
    )
    pipe.to("cuda")
    
    # Bellek optimizasyonu
    pipe.enable_model_cpu_offload()
    pipe.unet.enable_forward_chunking()
    
    # Görüntüyü yükle ve boyutlandır
    image = load_image(image_path)
    image = image.resize((1024, 576))
    
    print(f"Video oluşturuluyor: {num_frames} kare, {fps} FPS")
    
    generator = torch.manual_seed(42)
    
    frames = pipe(
        image,
        decode_chunk_size=8,
        generator=generator,
        num_frames=num_frames,
        motion_bucket_id=127,
        noise_aug_strength=0.02,
    ).frames[0]
    
    export_to_video(frames, output_path, fps=fps)
    print(f"Video kaydedildi: {output_path}")

if __name__ == "__main__":
    if len(sys.argv) < 3:
        print("Kullanım: python img2vid_generate.py <görüntü_yolu> <çıktı_yolu>")
        sys.exit(1)
    
    generate_video(sys.argv[1], sys.argv[2])
EOF

# Scripti çalıştır
python3 img2vid_generate.py /path/to/input.jpg /path/to/output.mp4

AnimateDiff ile Metin Tabanlı Video Üretimi

AnimateDiff, mevcut Stable Diffusion checkpoint’lerini kullanarak doğrudan metinden video üretebilir. Bu özellikle tutarlı stil gerektiren projelerde işe yarıyor:

cat > animatediff_api.py << 'EOF'
import requests
import base64
import json
import time
from pathlib import Path

WEBUI_URL = "http://localhost:7860"

def generate_animated_gif(
    prompt,
    negative_prompt="",
    model="dreamshaper_8.safetensors",
    motion_module="mm_sd_v15_v2.ckpt",
    num_frames=16,
    fps=8,
    width=512,
    height=512,
    steps=20,
    cfg_scale=7.5
):
    """AnimateDiff API üzerinden video üretir"""
    
    payload = {
        "prompt": prompt,
        "negative_prompt": negative_prompt,
        "steps": steps,
        "cfg_scale": cfg_scale,
        "width": width,
        "height": height,
        "sampler_name": "DPM++ 2M Karras",
        "alwayson_scripts": {
            "AnimateDiff": {
                "args": [{
                    "model": motion_module,
                    "format": ["GIF", "MP4"],
                    "enable": True,
                    "video_length": num_frames,
                    "fps": fps,
                    "loop_number": 0,
                    "closed_loop": "R+P",
                    "batch_size": 16,
                    "stride": 1,
                    "overlap": -1,
                    "interp": "Off",
                    "interp_x": 10,
                    "video_source": None,
                    "video_path": "",
                    "latent_power": 1,
                    "latent_scale": 32,
                    "last_frame": None,
                    "latent_power_last": 1,
                    "latent_scale_last": 32,
                    "request_id": ""
                }]
            }
        }
    }
    
    print(f"Video üretimi başlıyor...")
    print(f"Prompt: {prompt[:50]}...")
    
    response = requests.post(
        f"{WEBUI_URL}/sdapi/v1/txt2img",
        json=payload,
        timeout=300
    )
    
    if response.status_code == 200:
        result = response.json()
        print("Video başarıyla üretildi!")
        return result
    else:
        print(f"Hata: {response.status_code}")
        print(response.text)
        return None

# Kullanım örneği
if __name__ == "__main__":
    result = generate_animated_gif(
        prompt="a beautiful sunset over ocean waves, cinematic, 4k",
        negative_prompt="blurry, low quality, distorted",
        num_frames=16,
        fps=8
    )
    
    if result:
        print(f"İşlem tamamlandı")
EOF

python3 animatediff_api.py

Video Kalitesini Artırma: Upscaling ve Post-Processing

Ham video çıktısı çoğu zaman yeterli kalitede olmaz. FFmpeg ve Real-ESRGAN ile kaliteyi artırabiliriz:

# Real-ESRGAN kurulumu
pip install realesrgan

# Video frame'lerini ayır, upscale et ve birleştir
cat > video_upscale.sh << 'EOF'
#!/bin/bash

INPUT_VIDEO=$1
OUTPUT_VIDEO="${INPUT_VIDEO%.*}_upscaled.mp4"
TEMP_DIR="/tmp/video_frames_$$"

if [ -z "$INPUT_VIDEO" ]; then
    echo "Kullanım: $0 <video_dosyası>"
    exit 1
fi

echo "Geçici dizin oluşturuluyor: $TEMP_DIR"
mkdir -p "$TEMP_DIR/input" "$TEMP_DIR/output"

# FPS değerini al
FPS=$(ffprobe -v error -select_streams v -of default=noprint_wrappers=1:nokey=1 
    -show_entries stream=r_frame_rate "$INPUT_VIDEO" | bc)

echo "Orijinal FPS: $FPS"

# Frame'lere ayır
echo "Video frame'lere ayrılıyor..."
ffmpeg -i "$INPUT_VIDEO" -q:v 1 "$TEMP_DIR/input/frame_%05d.png" -y

FRAME_COUNT=$(ls "$TEMP_DIR/input/" | wc -l)
echo "Toplam kare: $FRAME_COUNT"

# Her frame'i upscale et
echo "Upscaling işlemi başlıyor (2x)..."
for frame in "$TEMP_DIR/input"/frame_*.png; do
    filename=$(basename "$frame")
    realesrgan-ncnn-vulkan -i "$frame" 
        -o "$TEMP_DIR/output/$filename" 
        -n realesrgan-x2plus 
        -s 2 -f png
done

# Frame'leri birleştir
echo "Video birleştiriliyor..."
ffmpeg -framerate "$FPS" 
    -i "$TEMP_DIR/output/frame_%05d.png" 
    -c:v libx264 
    -crf 18 
    -preset slow 
    -pix_fmt yuv420p 
    "$OUTPUT_VIDEO" -y

# Temizlik
rm -rf "$TEMP_DIR"
echo "İşlem tamamlandı: $OUTPUT_VIDEO"
EOF

chmod +x video_upscale.sh

Batch İşlem ve Otomasyon

Gerçek dünyada tek tek video üretmek yerine toplu işlem yapmanız gerekebilir. Mesela bir e-ticaret sitesi için ürün görsellerini animasyonlu videolara dönüştürmek istiyorsunuz:

cat > batch_img2vid.py << 'EOF'
#!/usr/bin/env python3

import os
import sys
import json
import logging
import subprocess
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor
import torch
from diffusers import StableVideoDiffusionPipeline
from diffusers.utils import load_image, export_to_video

# Logging yapılandırması
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('batch_processing.log'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

class BatchVideoGenerator:
    def __init__(self, model_path, output_dir, num_frames=25, fps=7):
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(parents=True, exist_ok=True)
        self.num_frames = num_frames
        self.fps = fps
        
        logger.info("Model yükleniyor...")
        self.pipe = StableVideoDiffusionPipeline.from_pretrained(
            model_path,
            torch_dtype=torch.float16,
            variant="fp16"
        )
        self.pipe.to("cuda")
        self.pipe.enable_model_cpu_offload()
        logger.info("Model hazır!")
    
    def process_image(self, image_path, seed=42):
        image_path = Path(image_path)
        output_path = self.output_dir / f"{image_path.stem}_video.mp4"
        
        if output_path.exists():
            logger.info(f"Atlanıyor (mevcut): {image_path.name}")
            return str(output_path)
        
        try:
            logger.info(f"İşleniyor: {image_path.name}")
            image = load_image(str(image_path)).resize((1024, 576))
            generator = torch.manual_seed(seed)
            
            frames = self.pipe(
                image,
                decode_chunk_size=8,
                generator=generator,
                num_frames=self.num_frames,
                motion_bucket_id=127,
            ).frames[0]
            
            export_to_video(frames, str(output_path), fps=self.fps)
            logger.info(f"Tamamlandı: {output_path.name}")
            return str(output_path)
            
        except Exception as e:
            logger.error(f"Hata ({image_path.name}): {e}")
            return None
    
    def process_directory(self, input_dir):
        input_dir = Path(input_dir)
        image_files = list(input_dir.glob("*.jpg")) + 
                     list(input_dir.glob("*.png")) + 
                     list(input_dir.glob("*.webp"))
        
        logger.info(f"Toplam {len(image_files)} görüntü bulundu")
        
        results = {"success": [], "failed": []}
        
        for i, img_path in enumerate(image_files, 1):
            logger.info(f"İlerleme: {i}/{len(image_files)}")
            result = self.process_image(img_path, seed=i*42)
            
            if result:
                results["success"].append(str(img_path))
            else:
                results["failed"].append(str(img_path))
        
        # Sonuç raporu
        report_path = self.output_dir / "batch_report.json"
        with open(report_path, "w") as f:
            json.dump(results, f, indent=2, ensure_ascii=False)
        
        logger.info(f"Batch tamamlandı!")
        logger.info(f"Başarılı: {len(results['success'])}")
        logger.info(f"Başarısız: {len(results['failed'])}")
        
        return results

if __name__ == "__main__":
    generator = BatchVideoGenerator(
        model_path="stabilityai/stable-video-diffusion-img2vid-xt",
        output_dir="./output_videos",
        num_frames=25,
        fps=7
    )
    
    generator.process_directory("./input_images")
EOF

python3 batch_img2vid.py

Performans Optimizasyonu ve Sorun Giderme

Video üretiminde en sık karşılaşılan sorunlar VRAM yetersizliği ve yavaş işlem süreleri. Bunlarla başa çıkmak için bazı ipuçları:

VRAM yetersizliği için:

• –medvram: Orta seviye VRAM optimizasyonu
• –lowvram: Minimum VRAM kullanımı, çok yavaş
• decode_chunk_size=4: Daha az bellek, daha yavaş işlem
• enable_model_cpu_offload(): CPU-GPU arası yük paylaşımı

Hız optimizasyonu için:

• xformers: Attention hesaplamalarını hızlandırır
• torch.compile(): PyTorch 2.0+ ile model derleme
• fp16 precision: float32’ye göre 2x hızlanma

Sistem durumunu izlemek için basit bir monitoring scripti:

cat > monitor_gpu.sh << 'EOF'
#!/bin/bash
# GPU ve bellek kullanımını izle

echo "GPU İzleme Başladı (Ctrl+C ile durdur)"
echo "=================================="

while true; do
    TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
    GPU_UTIL=$(nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader,nounits)
    VRAM_USED=$(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits)
    VRAM_TOTAL=$(nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits)
    GPU_TEMP=$(nvidia-smi --query-gpu=temperature.gpu --format=csv,noheader,nounits)
    
    VRAM_PERCENT=$(echo "scale=1; $VRAM_USED * 100 / $VRAM_TOTAL" | bc)
    
    echo "[$TIMESTAMP] GPU: %$GPU_UTIL | VRAM: ${VRAM_USED}MB/${VRAM_TOTAL}MB (%$VRAM_PERCENT) | Sıcaklık: ${GPU_TEMP}°C"
    
    # Yüksek sıcaklık uyarısı
    if [ "$GPU_TEMP" -gt 85 ]; then
        echo "UYARI: GPU sıcaklığı yüksek! ${GPU_TEMP}°C"
    fi
    
    sleep 5
done
EOF

chmod +x monitor_gpu.sh
# Arka planda çalıştır
./monitor_gpu.sh &
MONITOR_PID=$!
echo "Monitor PID: $MONITOR_PID"

Systemd Servisi ile WebUI Otomasyonu

Production ortamında WebUI’yi systemd servisi olarak çalıştırmak çok daha mantıklı. Sunucu her açıldığında otomatik başlasın ve çökmesinde kendini yeniden başlatsın:

sudo cat > /etc/systemd/system/sd-webui.service << 'EOF'
[Unit]
Description=Stable Diffusion WebUI Service
After=network.target
Wants=network-online.target

[Service]
Type=simple
User=sduser
Group=sduser
WorkingDirectory=/home/sduser/stable-diffusion-video/stable-diffusion-webui
ExecStart=/home/sduser/stable-diffusion-video/stable-diffusion-webui/webui.sh
Restart=on-failure
RestartSec=10
StandardOutput=append:/var/log/sd-webui/access.log
StandardError=append:/var/log/sd-webui/error.log
Environment="CUDA_VISIBLE_DEVICES=0"
Environment="PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512"

[Install]
WantedBy=multi-user.target
EOF

# Log dizinini oluştur
sudo mkdir -p /var/log/sd-webui
sudo chown sduser:sduser /var/log/sd-webui

# Servisi etkinleştir
sudo systemctl daemon-reload
sudo systemctl enable sd-webui
sudo systemctl start sd-webui

# Durumu kontrol et
sudo systemctl status sd-webui

Gerçek Dünya Senaryoları

Bu araçları nerede kullanabilirsiniz? Birkaç pratik senaryo:

E-ticaret ürün videoları: Statik ürün fotoğraflarından kısa, çekici tanıtım videoları üretmek için batch_img2vid.py scriptini kullanabilirsiniz. 500 ürün görseli için gece boyunca çalıştırıp sabah sonuçları toplayabilirsiniz.

Sosyal medya içeriği: AnimateDiff ile marka kimliğinize uygun stillerde animasyonlu içerikler üretmek için belirli LoRA modelleri ve motion modülleri kombinasyonu kullanabilirsiniz.

Oyun asset üretimi: Background animasyonları, loading ekranları veya cinematic sekanslar için bu araçlar oldukça uygun maliyetli alternatifler sunuyor.

Arşiv canlandırma: Tarihi fotoğrafları animasyonlu videolara dönüştürmek için Img2Vid mükemmel sonuçlar veriyor. Özellikle yüz ve portre görüntüleri için motion_bucket_id değerini 80-100 arasında tutmak daha doğal sonuçlar veriyor.

Sonuç

Img2Vid ve AnimateDiff, Stable Diffusion ekosisteminin en güçlü araçları arasına girmiş durumda. Sysadmin açısından bakıldığında, bu araçları production ortamına almak birkaç önemli nokta gerektiriyor: doğru donanım boyutlandırması, servis yönetimi, batch işlem altyapısı ve GPU monitoring.

8GB VRAM ile başlayıp AnimateDiff’i deneyebilirsiniz, ancak SVD tabanlı Img2Vid için en az 12GB VRAM şart. Eğer donanımınız yetersizse, bu işleri cloud GPU’larına (RunPod, Vast.ai) taşımak çok daha mantıklı. Saatlik maliyet hesabı yapıp kendi sunucunuzu mu alacağınızı yoksa bulut mu kullanacağınızı karşılaştırmanızı tavsiye ederim.

FFmpeg entegrasyonu ve batch processing scriptleri, bu araçları gerçekten kullanılabilir iş akışlarına dönüştürmenin anahtarı. Ham WebUI kullanımından API tabanlı otomasyona geçmek, uzun vadede çok daha verimli bir yapı oluşturmanızı sağlıyor. Monitoring ve logging’i ihmal etmeyin; uzun süren video üretim işlemlerinde neyin nerede takıldığını bilmek büyük zaman kazandırıyor.