LocalAI ile Yerel Görsel Üretme Modeli Kurulumu

Yazar:komut.io ekibi
0 Yorum

Görsel üretme modelleri artık sadece bulut servislerine mahsus değil. Kendi sunucunda, kendi verilerinle, dışarıya hiçbir istek atmadan Stable Diffusion ve benzeri modelleri çalıştırabilirsin. LocalAI bu işi inanılmaz derecede kolaylaştırıyor çünkü OpenAI API uyumlu bir arayüz sunuyor; yani mevcut araçlarını değiştirmeden yerel modellere yönlendirebiliyorsun. Bu yazıda sıfırdan bir görsel üretme ortamı kuracağız, modelleri yapılandıracağız ve gerçek kullanım senaryolarıyla sistemi test edeceğiz.

LocalAI Nedir ve Neden Görsel Üretme?

LocalAI, Go diliyle yazılmış, OpenAI API’si ile birebir uyumlu bir yerel yapay zeka sunucusudur. Metin üretme, embedding, ses tanıma gibi özelliklerin yanı sıra image generation için de destek sunuyor. Stable Diffusion modellerini çalıştırmak için arka planda stablediffusion.cpp kullanıyor; bu sayede GPU olmadan CPU üzerinde de çalışabiliyor, elbette çok daha yavaş.

Neden kendi sunucunda çalıştırmak istersin?

  • Veri gizliliği: Ürettiğin görseller hiçbir zaman dışarı çıkmıyor
  • Maliyet kontrolü: API ücretleri yok, sadece elektrik faturan var
  • Özelleştirme: İstediğin modeli, LoRA’ları, VAE’leri yükleyebilirsin
  • Otomasyon: CI/CD pipeline’larına, iç araçlara kolayca entegre edebilirsin

Sistem Gereksinimleri

Görsel üretme, metin modellerine göre daha fazla kaynak istiyor. Pratikte şunlara ihtiyacın var:

  • CPU modu: En az 8 GB RAM, 4+ çekirdek (512×512 görsel için 2-5 dakika beklemeyi göze al)
  • GPU modu (CUDA): NVIDIA kartı, en az 6 GB VRAM, CUDA 11.7+
  • Depolama: Modeller 2-7 GB arası, en az 20 GB boş alan
  • OS: Ubuntu 22.04 LTS ideal, Debian 12 de sorunsuz çalışıyor

Bu yazıda Ubuntu 22.04 üzerinde Docker kullanarak kurulum yapacağız. Docker olmadan binary ile de kurabilirsin ama Docker izolasyon ve güncelleme açısından çok daha pratik.

Docker ve Docker Compose Kurulumu

Önce temeli sağlam atalım:

# Eski Docker sürümlerini temizle
sudo apt remove docker docker-engine docker.io containerd runc -y

# Gerekli paketleri kur
sudo apt update && sudo apt install -y 
    ca-certificates 
    curl 
    gnupg 
    lsb-release

# Docker GPG anahtarını ekle
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | 
    sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# Repository ekle
echo 
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] 
  https://download.docker.com/linux/ubuntu 
  $(lsb_release -cs) stable" | 
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Docker'ı kur
sudo apt update && sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

# Kullanıcını docker grubuna ekle (logout/login gerekebilir)
sudo usermod -aG docker $USER

NVIDIA GPU kullanıyorsan container runtime’ı da kurman gerekiyor:

# NVIDIA Container Toolkit kurulumu
distribution=$(. /etc/os-release; echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | 
    sudo tee /etc/apt/sources.list.d/nvidia-docker.list

sudo apt update && sudo apt install -y nvidia-docker2
sudo systemctl restart docker

# Test et
docker run --rm --gpus all nvidia/cuda:11.8.0-base-ubuntu22.04 nvidia-smi

Dizin Yapısı ve Yapılandırma

Düzenli bir yapı kurmak ileride çok işe yarıyor. Her şeyi tek bir yerde toplayalım:

# Ana dizini oluştur
sudo mkdir -p /opt/localai/{models,images,config}
sudo chown -R $USER:$USER /opt/localai
cd /opt/localai

Şimdi docker-compose.yml dosyasını hazırlayalım. CPU modu için:

# /opt/localai/docker-compose.yml
version: '3.8'

services:
  localai:
    image: localai/localai:latest-aio-cpu
    container_name: localai
    ports:
      - "8080:8080"
    volumes:
      - ./models:/build/models
      - ./images:/tmp/generated/images
      - ./config:/build/models/config
    environment:
      - THREADS=4
      - CONTEXT_SIZE=512
      - DEBUG=false
      - GALLERIES=github:go-skynet/model-gallery/index.yaml
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/readyz"]
      interval: 30s
      timeout: 10s
      retries: 5

GPU varsa image ve environment kısmını değiştir:

# GPU için docker-compose.yml (sadece farklı kısımlar)
services:
  localai:
    image: localai/localai:latest-aio-gpu-nvidia-cuda-12
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - GPU_LAYERS=35

Stable Diffusion Modeli İndirme ve Yapılandırma

LocalAI için birkaç farklı yöntemle model ekleyebilirsin. En temizi config dosyası yöntemi.

Önce servisi başlatalım:

cd /opt/localai
docker compose up -d

# Logları izle
docker compose logs -f localai

Servis ayağa kalktıktan sonra (readyz endpoint’i 200 dönünce) model yapılandırmasını oluşturabiliriz. Stable Diffusion 1.5 ile başlayalım çünkü hem hızlı hem de kaynak tüketimi makul:

# SD 1.5 modelini indir (yaklaşık 4 GB)
cd /opt/localai/models
wget -c https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.safetensors 
    -O sd-1.5.safetensors

# İndirme tamamlandı mı kontrol et
ls -lh sd-1.5.safetensors

Şimdi bu model için YAML yapılandırma dosyası oluştur:

# /opt/localai/config/stablediffusion.yaml
name: stablediffusion
backend: stablediffusion
parameters:
  model: sd-1.5.safetensors
stablediffusion:
  diffusers:
    pipeline_type: StableDiffusionPipeline
  cfg_scale: 7.5
  sample_steps: 20
  width: 512
  height: 512
  clip_skip: 1

Yapılandırma dosyasını container’a yansıtmak için servisi yeniden başlat:

docker compose restart localai
docker compose logs -f localai | grep -E "model|error|ready"

İlk Görsel Üretme Testi

Model yüklendikten sonra API’yi test edelim. LocalAI, OpenAI’nın /v1/images/generations endpoint’ini taklit ediyor:

# Basit bir test isteği
curl -X POST http://localhost:8080/v1/images/generations 
  -H "Content-Type: application/json" 
  -d '{
    "model": "stablediffusion",
    "prompt": "a beautiful mountain landscape at sunset, photorealistic, high quality",
    "size": "512x512",
    "n": 1
  }' | jq .

Başarılı bir yanıt şöyle görünür:

{
  "created": 1703001234,
  "data": [
    {
      "url": "http://localhost:8080/generated-images/abc123.png"
    }
  ]
}

Üretilen görseli indir:

# URL'den görseli al
IMAGE_URL=$(curl -s -X POST http://localhost:8080/v1/images/generations 
  -H "Content-Type: application/json" 
  -d '{"model": "stablediffusion", "prompt": "red apple on white background", "size": "512x512"}' 
  | jq -r '.data[0].url')

curl -o /tmp/test_output.png "$IMAGE_URL"
echo "Görsel kaydedildi: /tmp/test_output.png"

Python ile Otomatik Görsel Üretme

Gerçek dünyada bu API’yi genellikle bir script veya uygulama üzerinden kullanıyorsun. OpenAI Python kütüphanesi LocalAI ile direkt çalışıyor:

#!/usr/bin/env python3
# /opt/localai/scripts/generate_images.py

from openai import OpenAI
import os
import requests
from datetime import datetime

# LocalAI'ya bağlan (OpenAI kütüphanesi ile)
client = OpenAI(
    api_key="not-needed",  # LocalAI için API key gerekmez
    base_url="http://localhost:8080/v1"
)

def generate_image(prompt: str, size: str = "512x512", output_dir: str = "/opt/localai/images"):
    """Görsel üret ve diske kaydet"""
    
    print(f"Görsel üretiliyor: {prompt[:50]}...")
    
    response = client.images.generate(
        model="stablediffusion",
        prompt=prompt,
        size=size,
        n=1
    )
    
    image_url = response.data[0].url
    
    # Görseli indir
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"{output_dir}/generated_{timestamp}.png"
    
    img_response = requests.get(image_url)
    with open(filename, 'wb') as f:
        f.write(img_response.content)
    
    print(f"Kaydedildi: {filename}")
    return filename

# Batch üretim örneği
prompts = [
    "modern office interior, minimalist design, natural lighting",
    "mountain lake reflection, golden hour, professional photography",
    "abstract geometric art, vibrant colors, digital art style"
]

for prompt in prompts:
    try:
        result = generate_image(prompt)
        print(f"Basarili: {result}")
    except Exception as e:
        print(f"Hata: {e}")

if __name__ == "__main__":
    generate_image("test image, simple, clean background")

Scripti çalıştır:

pip3 install openai requests
python3 /opt/localai/scripts/generate_images.py

Gerçek Dünya Senaryosu: Otomatik Ürün Görseli Üretme

Bir e-ticaret senaryosu düşün. Ürün açıklamalarından otomatik görsel üretmek istiyorsun. Aşağıdaki script bir CSV dosyasından ürün listesini okuyup her biri için görsel üretiyor:

#!/bin/bash
# /opt/localai/scripts/batch_product_images.sh

PRODUCTS=(
    "leather wallet, dark brown, minimalist, product photography, white background"
    "wireless headphones, black, modern design, studio lighting"
    "coffee mug, ceramic, blue, handmade, rustic style"
)

OUTPUT_DIR="/opt/localai/images/products"
mkdir -p "$OUTPUT_DIR"

API_URL="http://localhost:8080/v1/images/generations"

for i in "${!PRODUCTS[@]}"; do
    PROMPT="${PRODUCTS[$i]}"
    PRODUCT_NUM=$((i + 1))
    
    echo "[$PRODUCT_NUM/${#PRODUCTS[@]}] Uretiliyor: ${PROMPT:0:40}..."
    
    RESPONSE=$(curl -s -X POST "$API_URL" 
        -H "Content-Type: application/json" 
        -d "{
            "model": "stablediffusion",
            "prompt": "$PROMPT",
            "size": "512x512",
            "n": 1
        }")
    
    IMAGE_URL=$(echo "$RESPONSE" | jq -r '.data[0].url')
    
    if [ "$IMAGE_URL" != "null" ] && [ -n "$IMAGE_URL" ]; then
        OUTPUT_FILE="$OUTPUT_DIR/product_${PRODUCT_NUM}.png"
        curl -s -o "$OUTPUT_FILE" "$IMAGE_URL"
        echo "Kaydedildi: $OUTPUT_FILE"
    else
        echo "Hata: $RESPONSE"
    fi
    
    # Rate limiting - sunucuyu bunaltma
    sleep 2
done

echo "Tum gorseller: $OUTPUT_DIR"
ls -lh "$OUTPUT_DIR"

Nginx ile Reverse Proxy Kurulumu

Prodüksiyonda LocalAI’yı direkt açık bırakmak yerine Nginx arkasına almak gerekiyor:

sudo apt install nginx -y

sudo tee /etc/nginx/sites-available/localai << 'EOF'
server {
    listen 80;
    server_name ai.sirketiniz.com;

    client_max_body_size 50M;
    
    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_read_timeout 300s;
        proxy_connect_timeout 60s;
        proxy_send_timeout 300s;
    }

    location /generated-images/ {
        alias /opt/localai/images/;
        expires 7d;
        add_header Cache-Control "public, immutable";
    }
}
EOF

sudo ln -s /etc/nginx/sites-available/localai /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx

Model Yönetimi ve Galeri Kullanımı

LocalAI’nın model galerisi özelliği modelleri tek komutla indirip yapılandırmanı sağlıyor:

# Mevcut görsel modellerini listele
curl -s http://localhost:8080/models/available | jq '.[] | select(.tags[] == "image") | .name'

# Stable Diffusion XL'i galeri üzerinden yükle
curl -X POST http://localhost:8080/models/apply 
  -H "Content-Type: application/json" 
  -d '{
    "id": "model-gallery@stablediffusion-xl"
  }'

# Yükleme durumunu takip et
JOB_ID=$(curl -s -X POST http://localhost:8080/models/apply 
  -H "Content-Type: application/json" 
  -d '{"id": "model-gallery@stablediffusion"}' | jq -r '.uuid')

# Job durumunu kontrol et
watch -n 5 "curl -s http://localhost:8080/models/jobs/$JOB_ID | jq '{progress, error}'"

Performans İzleme ve Loglar

Sistemi canlıda kullanırken izleme kritik:

# Container kaynak kullanımını izle
docker stats localai --format "table {{.Name}}t{{.CPUPerc}}t{{.MemUsage}}t{{.MemPerc}}"

# Üretim sürelerini loglardan çek
docker logs localai 2>&1 | grep -E "generated|took|seconds" | tail -20

# Disk kullanımını kontrol et (modeller yer kaplayabiliyor)
du -sh /opt/localai/models/*
du -sh /opt/localai/images/

# Eski görselleri temizle (7 günden eski)
find /opt/localai/images -name "*.png" -mtime +7 -delete
echo "Temizlik tamamlandi"

Logrotate ile görsel dizinini otomatik temizleyebilirsin:

sudo tee /etc/cron.d/localai-cleanup << 'EOF'
# Her gece 02:00'de 7 günden eski görselleri sil
0 2 * * * root find /opt/localai/images -name "*.png" -mtime +7 -delete && 
    echo "$(date): Gorsel temizligi tamamlandi" >> /var/log/localai-cleanup.log
EOF

Yaygın Sorunlar ve Çözümleri

Model yüklenemiyor hatası: Config dosyasında model adının dosya adıyla birebir eşleştiğini kontrol et. Uzantıyı unutma.

Out of memory: docker-compose.yml dosyasına bellek limiti ekle ve THREADS değerini düşür. CPU modunda 4 GB RAM ile 512×512 genellikle çalışıyor ama 768×768 için 8 GB şart.

Görsel üretimi çok yavaş: CPU modunda bu normal. Adım sayısını (sample_steps) 20’den 10’a düşürmeyi dene, kalite biraz düşer ama hız artar.

Port 8080 çakışması: docker-compose.yml içinde sol tarafı değiştir. "9080:8080" yaparak 9080’den yayınlayabilirsin.

Container başlamıyor: İzinleri kontrol et:

ls -la /opt/localai/models/
# localai container'ı içinde uid 1000 kullanıcısı çalışıyor
sudo chown -R 1000:1000 /opt/localai/models /opt/localai/images
docker compose restart localai

Sonuç

LocalAI ile yerel görsel üretme ortamı kurmak başta karmaşık görünüyor ama adımlar netleşince oldukça sistematik bir süreç. Kurulumun özeti şu: Docker üzerinde LocalAI kaldır, model dosyasını indirip YAML config ile tanımla, API’yi test et ve ihtiyacına göre otomasyon ekle.

Prodüksiyona almadan önce birkaç şeyi kesinlikle yap: Nginx arkasına al, disk temizliği için cron kur ve model dizinini yedekle. Modeller gigabyte’larla ifade edildiği için yeniden indirmek can sıkıcı olabiliyor.

CPU modunda sabırlı ol; 512×512 görsel için 1-5 dakika bekleme normal. Eğer bu süre işini görmüyorsa, ikinci el NVIDIA kartlar artık makul fiyatlara bulunabiliyor ve GPU modu işi gerçekten farklı bir noktaya taşıyor. SDXL ile 1024×1024 kaliteli görseller üretebilmek, tüm veriyi kendi sunucunda tutarak yapmak mümkün; bu kombinin değeri giderek artıyor.

Bir yanıt yazın

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