Mevcut Görseli Dönüştürme: Stable Diffusion img2img Kullanımı

Yazar:komut.io ekibi
0 Yorum

Stable Diffusion dünyasında img2img, belki de en güçlü ama aynı zamanda en az anlaşılan özelliklerden biri. Metinden görsel üretmek (txt2img) harika, ama elinizde zaten bir görsel varsa ve bunu dönüştürmek, iyileştirmek ya da tamamen farklı bir stile sokmak istiyorsanız, işte o zaman img2img devreye giriyor. Sysadmin olarak biz genellikle “neden böyle çalışıyor?” sorusunu sorarız. Bu yazıda hem teknik altyapıyı anlayacağız hem de gerçek dünya senaryolarıyla img2img kullanımını derinlemesine inceleyeceğiz.

img2img Nedir ve Nasıl Çalışır?

txt2img’de model sıfırdan başlar, tamamen gürültüden bir görsel üretir. img2img ise farklı bir yaklaşım kullanır: mevcut görselinizi belirli miktarda gürültüyle “kirletir” ve ardından bu gürültüden başlayarak yeni bir görsel oluşturur. Bu sürecin temelinde denoising strength (gürültü giderme kuvveti) parametresi yatıyor.

Matematiksel olarak şunu düşünebilirsiniz: Eğer denoising strength 0.0 ise görseliniz hiç değişmez. 1.0 ise model tamamen sıfırdan başlar ve girdi görselinizin yalnızca genel kompozisyonunu hatırlayabilir. 0.5-0.75 arası genellikle “bu görseli dönüştür ama kökten değiştirme” için ideal aralıktır.

Bu teknik yaklaşımın bizim için önemi şudur: Görsel pipeline’larını otomatize ettiğinizde, hangi parametrenin ne yapacağını bilmeden işler karmaşık bir hale gelir.

Stable Diffusion WebUI’da img2img Sekmesi

AUTOMATIC1111 WebUI kullanıyorsanız, img2img sekmesi ana arayüzde sizi karşılar. Önce WebUI’nın çalışır durumda olduğundan emin olalım:

# WebUI'yı başlatma
cd /opt/stable-diffusion-webui
source venv/bin/activate
python launch.py --listen --port 7860 --api --xformers

# Eğer GPU bellek sorunları yaşıyorsanız
python launch.py --listen --port 7860 --api --xformers --medvram

# Çok sınırlı VRAM için (4GB altı)
python launch.py --listen --port 7860 --api --xformers --lowvram

WebUI açıldıktan sonra img2img sekmesine geçin. Burada şu alt sekmeleri göreceksiniz:

  • img2img: Standart görsel dönüştürme
  • Sketch: El çizimi tarzı girdi
  • Inpaint: Görselin belirli bölgelerini yeniden oluşturma
  • Inpaint Sketch: Elle çizilmiş maskeyle inpainting
  • Inpaint Upload: Harici maske dosyasıyla inpainting
  • Batch: Toplu işlem modu

API Üzerinden img2img Kullanımı

Sysadmin olarak muhtemelen en çok ilgilendiğiniz kısım burası. Görsel dönüştürme işlemlerini script’ler aracılığıyla otomatize etmek gerçek gücü ortaya çıkarıyor. WebUI’nın REST API’si bu konuda oldukça kapsamlı.

# Temel img2img API çağrısı - önce görseli base64'e dönüştür
IMAGE_BASE64=$(base64 -w 0 /path/to/input.jpg)

curl -X POST http://localhost:7860/sdapi/v1/img2img 
  -H "Content-Type: application/json" 
  -d "{
    "init_images": ["$IMAGE_BASE64"],
    "prompt": "oil painting style, masterpiece, detailed brushwork",
    "negative_prompt": "blurry, low quality, jpeg artifacts",
    "denoising_strength": 0.65,
    "steps": 30,
    "cfg_scale": 7.5,
    "width": 512,
    "height": 512,
    "sampler_name": "DPM++ 2M Karras"
  }"

Bu çağrı sonucunda dönen JSON içindeki base64 kodlanmış görseli dosyaya yazmak için:

#!/bin/bash
# img2img_convert.sh - Görsel dönüştürme script'i

INPUT_IMAGE="$1"
OUTPUT_DIR="$2"
PROMPT="$3"
DENOISING="${4:-0.65}"

if [ -z "$INPUT_IMAGE" ] || [ -z "$OUTPUT_DIR" ] || [ -z "$PROMPT" ]; then
    echo "Kullanim: $0 <input_gorsel> <output_dizin> <prompt> [denoising_strength]"
    exit 1
fi

mkdir -p "$OUTPUT_DIR"

IMAGE_BASE64=$(base64 -w 0 "$INPUT_IMAGE")
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
OUTPUT_FILE="$OUTPUT_DIR/converted_${TIMESTAMP}.png"

RESPONSE=$(curl -s -X POST http://localhost:7860/sdapi/v1/img2img 
  -H "Content-Type: application/json" 
  -d "{
    "init_images": ["$IMAGE_BASE64"],
    "prompt": "$PROMPT",
    "negative_prompt": "blurry, low quality, distorted",
    "denoising_strength": $DENOISING,
    "steps": 30,
    "cfg_scale": 7.5,
    "sampler_name": "DPM++ 2M Karras"
  }")

echo "$RESPONSE" | python3 -c "
import sys, json, base64
data = json.load(sys.stdin)
img_data = base64.b64decode(data['images'][0])
with open('$OUTPUT_FILE', 'wb') as f:
    f.write(img_data)
print('Gorsel kaydedildi: $OUTPUT_FILE')
"

Python ile Toplu img2img İşlemi

Bir dizindeki tüm görselleri dönüştürmek istediğinizde, bu Python script’i işinizi büyük ölçüde kolaylaştırır:

#!/usr/bin/env python3
# batch_img2img.py

import os
import sys
import base64
import json
import time
import requests
from pathlib import Path

def image_to_base64(image_path):
    with open(image_path, 'rb') as f:
        return base64.b64encode(f.read()).decode('utf-8')

def save_base64_image(base64_str, output_path):
    img_data = base64.b64decode(base64_str)
    with open(output_path, 'wb') as f:
        f.write(img_data)

def convert_image(
    image_path,
    prompt,
    negative_prompt="blurry, low quality, distorted, watermark",
    denoising_strength=0.65,
    steps=30,
    cfg_scale=7.5,
    sampler="DPM++ 2M Karras",
    api_url="http://localhost:7860"
):
    image_b64 = image_to_base64(image_path)
    
    payload = {
        "init_images": [image_b64],
        "prompt": prompt,
        "negative_prompt": negative_prompt,
        "denoising_strength": denoising_strength,
        "steps": steps,
        "cfg_scale": cfg_scale,
        "sampler_name": sampler,
        "restore_faces": False,
        "tiling": False
    }
    
    response = requests.post(
        f"{api_url}/sdapi/v1/img2img",
        json=payload,
        timeout=300
    )
    
    if response.status_code == 200:
        return response.json()
    else:
        raise Exception(f"API hatasi: {response.status_code} - {response.text}")

def batch_convert(input_dir, output_dir, prompt, **kwargs):
    input_path = Path(input_dir)
    output_path = Path(output_dir)
    output_path.mkdir(parents=True, exist_ok=True)
    
    supported_formats = {'.jpg', '.jpeg', '.png', '.bmp', '.webp'}
    images = [f for f in input_path.iterdir() 
              if f.suffix.lower() in supported_formats]
    
    print(f"Toplam {len(images)} gorsel bulundu.")
    
    for i, image_file in enumerate(images, 1):
        print(f"[{i}/{len(images)}] Isleniyor: {image_file.name}")
        
        try:
            result = convert_image(str(image_file), prompt, **kwargs)
            
            output_file = output_path / f"converted_{image_file.stem}.png"
            save_base64_image(result['images'][0], str(output_file))
            
            print(f"  Kaydedildi: {output_file.name}")
            time.sleep(1)  # API'yi bunaltmamak icin
            
        except Exception as e:
            print(f"  HATA: {e}")
            continue
    
    print(f"nToplu donusum tamamlandi. Cikti: {output_dir}")

if __name__ == "__main__":
    batch_convert(
        input_dir="./input_images",
        output_dir="./output_images",
        prompt="anime style, vibrant colors, studio ghibli inspired",
        denoising_strength=0.70,
        steps=25
    )

Bu script’i çalıştırmak için:

pip install requests pillow
python3 batch_img2img.py

Denoising Strength: En Kritik Parametre

Bu parametreyi doğru anlamak, img2img kullanımının yüzde seksenini çözüyor. Şöyle düşünün:

  • 0.1 – 0.3: Görseli neredeyse hiç değiştirme, sadece hafif iyileştirme, gürültü giderme
  • 0.4 – 0.6: Belirgin stil dönüşümü ama kompozisyon korunur
  • 0.65 – 0.75: Güçlü dönüşüm, orijinal görsel yalnızca referans olarak kalır
  • 0.8 – 1.0: Neredeyse tam yeniden oluşturma, orijinalle çok az bağlantı

Örneğin bir fotoğrafı çizgi roman stiline dönüştürmek istiyorsanız 0.65-0.75 arası idealdir. Ancak bir logonun renklerini değiştirmek istiyorsanız 0.3-0.4 daha uygun olur.

Gerçek Dünya Senaryosu 1: Ürün Fotoğrafı Arkaplanını Değiştirme

E-ticaret siteleri için sık karşılaşılan bir senaryo: yüzlerce ürün fotoğrafının arka planını değiştirmek istiyorsunuz ama bütçeniz profesyonel fotoğrafçıya yetmiyor.

#!/bin/bash
# product_bg_change.sh

PRODUCT_IMAGE="$1"
NEW_BG_STYLE="${2:-professional studio background, white backdrop, soft lighting}"

IMAGE_BASE64=$(base64 -w 0 "$PRODUCT_IMAGE")

# Inpaint ile sadece arka planı degistir
curl -s -X POST http://localhost:7860/sdapi/v1/img2img 
  -H "Content-Type: application/json" 
  -d "{
    "init_images": ["$IMAGE_BASE64"],
    "prompt": "product photography, $NEW_BG_STYLE, high quality, commercial",
    "negative_prompt": "blurry, distorted product, changed product shape",
    "denoising_strength": 0.45,
    "steps": 35,
    "cfg_scale": 8.0,
    "sampler_name": "Euler a",
    "width": 768,
    "height": 768
  }" | python3 -c "
import sys, json, base64
data = json.load(sys.stdin)
img_data = base64.b64decode(data['images'][0])
with open('product_output.png', 'wb') as f:
    f.write(img_data)
print('Urun gorseli donusturuldu: product_output.png')
"

Gerçek Dünya Senaryosu 2: Görsel Kalite İyileştirme Pipeline’ı

Eski veya düşük kaliteli görselleri upscale etmeden önce img2img ile temizlemek, son kaliteyi ciddi ölçüde artırır. Bu yaklaşım özellikle arşiv görselleri için işe yarıyor:

#!/usr/bin/env python3
# quality_enhance.py - Gorsel kalitesini iyilestirme pipeline'i

import requests
import base64
import json
from pathlib import Path

def enhance_image_quality(image_path, output_path, api_url="http://localhost:7860"):
    """
    Dusuk kaliteli gorseli iyilestir:
    1. Adim: img2img ile noise reduction ve detay ekleme
    2. Adim: Upscale ile cozunurluk artirma
    """
    
    # Gorseli oku
    with open(image_path, 'rb') as f:
        image_b64 = base64.b64encode(f.read()).decode('utf-8')
    
    # Adim 1: img2img ile iyilestirme
    print(f"Adim 1: Gorsel kalitesi iyilestiriliyor...")
    
    enhance_payload = {
        "init_images": [image_b64],
        "prompt": "high quality, sharp details, clean, professional photography",
        "negative_prompt": "blurry, noise, jpeg artifacts, grain, pixelated",
        "denoising_strength": 0.35,
        "steps": 40,
        "cfg_scale": 6.0,
        "sampler_name": "DPM++ 2M Karras"
    }
    
    response = requests.post(
        f"{api_url}/sdapi/v1/img2img",
        json=enhance_payload,
        timeout=300
    )
    
    if response.status_code != 200:
        raise Exception(f"Iyilestirme hatasi: {response.status_code}")
    
    enhanced_b64 = response.json()['images'][0]
    
    # Adim 2: Upscale
    print(f"Adim 2: Upscale yapiliyor...")
    
    upscale_payload = {
        "resize_mode": 0,
        "show_extras_results": True,
        "gfpgan_visibility": 0,
        "codeformer_visibility": 0,
        "codeformer_weight": 0,
        "upscaling_resize": 2,
        "upscaling_resize_w": 1024,
        "upscaling_resize_h": 1024,
        "upscaling_crop": True,
        "upscaler_1": "R-ESRGAN 4x+",
        "upscaler_2": "None",
        "extras_upscaler_2_visibility": 0,
        "image": enhanced_b64
    }
    
    upscale_response = requests.post(
        f"{api_url}/sdapi/v1/extra-single-image",
        json=upscale_payload,
        timeout=300
    )
    
    if upscale_response.status_code != 200:
        raise Exception(f"Upscale hatasi: {upscale_response.status_code}")
    
    final_b64 = upscale_response.json()['image']
    
    # Sonucu kaydet
    img_data = base64.b64decode(final_b64)
    with open(output_path, 'wb') as f:
        f.write(img_data)
    
    print(f"Tamamlandi: {output_path}")

# Kullanim
enhance_image_quality(
    image_path="./old_photo.jpg",
    output_path="./enhanced_photo.png"
)

img2img İçin Systemd Servisi

Üretim ortamında img2img pipeline’larını çalıştırıyorsanız, bunu bir systemd servisi olarak yapılandırmak işleri daha yönetilebilir kılar:

# /etc/systemd/system/sd-img2img-worker.service dosyasini olustur
sudo tee /etc/systemd/system/sd-img2img-worker.service << 'EOF'
[Unit]
Description=Stable Diffusion img2img Worker Service
After=network.target sd-webui.service
Requires=sd-webui.service

[Service]
Type=simple
User=sduser
WorkingDirectory=/opt/sd-pipeline
Environment=SD_API_URL=http://localhost:7860
Environment=INPUT_WATCH_DIR=/data/input_queue
Environment=OUTPUT_DIR=/data/output
ExecStartPre=/bin/sleep 30
ExecStart=/opt/sd-pipeline/venv/bin/python3 /opt/sd-pipeline/worker.py
Restart=on-failure
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable sd-img2img-worker
sudo systemctl start sd-img2img-worker

# Durum kontrol
sudo systemctl status sd-img2img-worker
sudo journalctl -u sd-img2img-worker -f

Sık Karşılaşılan Sorunlar ve Çözümleri

CUDA out of memory hatası: img2img, txt2img’den daha fazla VRAM tüketebilir çünkü hem girdi görselini hem de üretim sürecini bellekte tutmak gerekir.

# VRAM kullanimi optimize etmek icin
python launch.py --medvram --opt-split-attention --opt-channelslast

# Gorsel boyutunu kontrol edin - 512x512 yerine buyuk gorseller deneyin
# Her zaman 64'un katlari kullanin: 512, 576, 640, 768, 896, 1024

Görsel boyutu uyumsuzluğu: SD 1.5 modeli 512×512 için eğitilmiştir. Farklı boyutlarda görseller verdiğinizde sorunlarla karşılaşabilirsiniz.

  • Girdi görselini önce 512×512’ye yeniden boyutlandırın
  • ya da boyutu prompt’a göre ayarlayın
  • SDXL kullanıyorsanız 1024×1024 temel alın
  • Yüksek denoising strength ile büyük görseller daha fazla sapma gösterir

Renk kayması sorunu: Özellikle düşük denoising strength değerlerinde görsel doğru dönüşüyor ama renkler kaymış olabiliyor.

  • cfg_scale değerini düşürün (7.5’tan 6.0’a)
  • Sampler olarak “Euler a” yerine “DPM++ 2M Karras” deneyin
  • VAE modelinizin doğru olduğundan emin olun, özellikle vae-ft-mse-840000-ema-pruned kullanın

İnce Ayar İpuçları

Deneyimlerimden derlediğim bazı pratik ipuçları:

  • Steps değeri: img2img için txt2img’den daha az steps yeterli. 20-30 çoğu durumda ideal.
  • Seed kontrolü: Aynı görseli farklı prompt’larla test ederken seed’i sabit tutun, böylece değişkeni izole edebilirsiniz.
  • Prompt yazımı: Önce istediğiniz stili, sonra kalite kelimelerini ekleyin. “oil painting, Van Gogh style, masterpiece, high quality” sıralaması işe yarar.
  • Negative prompt zorunluluğu: “lowres, bad anatomy, worst quality, low quality” her img2img işleminde kullanın.
  • Resize mode: “Just resize” yerine “Crop and resize” veya “Resize and fill” seçenekleri boyut uyumsuzluklarını daha iyi yönetir.

Sonuç

img2img, Stable Diffusion ekosisteminin en değerli araçlarından biri ve doğru kullanıldığında iş akışlarını gerçekten dönüştürebiliyor. Sysadmin perspektifinden bakıldığında asıl güç, bu işlemleri API üzerinden otomatize edebilmek ve batch pipeline’larına entegre edebilmektir.

Denoising strength parametresini anlamak ve kontrol edebilmek, bu aracın yüzde seksenini size kazandırır. Geri kalan yüzde yirmi ise doğru model seçimi, sampler tercihi ve prompt mühendisliğidir. Her zaman küçük denoising değerleriyle başlayın, sonuçları gözlemleyin ve kademeli olarak artırın.

Üretim ortamında kullanırken mutlaka rate limiting ekleyin, hata yönetimini düzgün yapılandırın ve sistemd servisi üzerinden çalıştırın. GPU’nuz bir kaynak ve dikkatli yönetilmesi gerekiyor. Batch işlemler arasına kısa beklemeler eklemek, hem donanımı hem de API kararlılığını korur.

Son olarak, img2img’i inpainting ve ControlNet ile birleştirdiğinizde çok daha güçlü pipeline’lar oluşturabilirsiniz, ama o konu ayrı bir yazının konusu.

Bir yanıt yazın

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