Görsel Anlayan Yapay Zeka: OpenAI Vision API Rehberi

Yazar:komut.io ekibi
0 Yorum

Sunucularınızın log dosyalarını analiz etmek, ekran görüntülerinden hata tespiti yapmak veya altyapı diyagramlarını otomatik dokümante etmek istediğinizi düşünün. Birkaç yıl önce bu işlemler için ya manuel inceleme yapmanız ya da özel görüntü işleme modelleri eğitmeniz gerekirdi. Artık OpenAI’nin Vision API’si sayesinde bu tür görevleri birkaç satır Python koduyla halledebilirsiniz. Sysadmin dünyasında görsel analiz genellikle göz ardı edilen bir otomasyon alanıdır, ancak doğru kullanıldığında inanılmaz zaman tasarrufu sağlar.

Vision API Nedir ve Nasıl Çalışır

OpenAI’nin GPT-4o ve GPT-4 Turbo modelleri, metin yanında görsel içerikleri de anlayabilen multimodal yapıya sahiptir. Yani bir modele hem metin hem de resim gönderebilir, modelin bu ikisini birlikte değerlendirerek yanıt üretmesini sağlayabilirsiniz.

Teknik açıdan bakıldığında Vision API, standart Chat Completions endpoint’ini kullanır. Tek fark, mesaj içeriğinde metin yerine ya da metinle birlikte bir görsel URL’si veya base64 encoded görsel verisi göndermenizdir. Model bu görseli analiz eder, içeriği anlar ve sorunuza göre yanıt üretir.

Desteklenen görsel formatları şunlardır:

  • PNG: Ekran görüntüleri ve diyagramlar için ideal
  • JPEG/JPG: Fotoğraflar ve genel kullanım için
  • GIF: Statik GIF’ler desteklenir, animasyonlarda yalnızca ilk kare işlenir
  • WEBP: Modern web görselleri için

Görsel boyutu konusunda dikkat etmeniz gereken noktalar var. Model, görseli dahili olarak yeniden boyutlandırır ve bu işlem token maliyetini etkiler. low detail modunda görsel 512×512 piksele indirilir ve 85 token harcar. high detail modunda ise görsel 2048×2048 limitinde tutulur ve daha fazla token harcar ama daha hassas analiz yapılır.

Ortam Kurulumu

Başlamadan önce gerekli kütüphaneleri kurmanız gerekiyor. Python 3.8 veya üzeri bir versiyon kullandığınızdan emin olun.

# Sanal ortam oluşturun
python3 -m venv vision_env
source vision_env/bin/activate

# Gerekli paketleri kurun
pip install openai requests pillow python-dotenv

# API anahtarınızı ortam değişkeni olarak ayarlayın
export OPENAI_API_KEY="sk-your-api-key-here"

# Ya da .env dosyası oluşturun
echo "OPENAI_API_KEY=sk-your-api-key-here" > .env

Temel bir Vision API çağrısını test etmek için şu scripti çalıştırabilirsiniz:

# test_vision.py dosyası oluşturun
cat << 'EOF' > test_vision.py
import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Bu görselde ne görüyorsun? Kısaca açıkla."
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/4/47/PNG_transparency_demonstration_1.png/280px-PNG_transparency_demonstration_1.png",
                        "detail": "low"
                    }
                }
            ]
        }
    ],
    max_tokens=300
)

print(response.choices[0].message.content)
EOF

python3 test_vision.py

Yerel Görsel Dosyalarını Gönderme

Sunucunuzda bulunan yerel görsel dosyalarını API’ye göndermek için base64 encoding kullanmanız gerekir. Özellikle log analizi veya monitoring screenshot’ları için bu yöntemi sık kullanacaksınız.

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

import os
import base64
import sys
from openai import OpenAI
from pathlib import Path

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def encode_image_to_base64(image_path: str) -> str:
    """Yerel görsel dosyasını base64 formatına çevirir."""
    with open(image_path, "rb") as image_file:
        return base64.standard_b64encode(image_file.read()).decode("utf-8")

def analyze_local_image(image_path: str, question: str, detail: str = "high") -> str:
    """
    Yerel bir görsel dosyasını analiz eder.
    
    detail parametresi:
    - low: Hızlı analiz, düşük maliyet (85 token)
    - high: Detaylı analiz, yüksek doğruluk
    - auto: Model kendisi karar verir
    """
    
    # Dosya uzantısından MIME type belirle
    extension = Path(image_path).suffix.lower()
    mime_types = {
        ".png": "image/png",
        ".jpg": "image/jpeg",
        ".jpeg": "image/jpeg",
        ".gif": "image/gif",
        ".webp": "image/webp"
    }
    mime_type = mime_types.get(extension, "image/png")
    
    # Görseli base64'e çevir
    base64_image = encode_image_to_base64(image_path)
    
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": question
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:{mime_type};base64,{base64_image}",
                            "detail": detail
                        }
                    }
                ]
            }
        ],
        max_tokens=1000
    )
    
    return response.choices[0].message.content

if __name__ == "__main__":
    if len(sys.argv) < 3:
        print("Kullanım: python3 local_image_analyzer.py <görsel_yolu> <soru>")
        sys.exit(1)
    
    image_path = sys.argv[1]
    question = sys.argv[2]
    
    if not os.path.exists(image_path):
        print(f"Hata: {image_path} dosyası bulunamadı")
        sys.exit(1)
    
    result = analyze_local_image(image_path, question)
    print(result)

Gerçek Dünya Senaryosu: Monitoring Dashboard Analizi

Grafana, Zabbix veya Prometheus dashboard’larının ekran görüntülerini otomatik analiz etmek, nöbetçi sysadmin için hayat kurtarıcı olabilir. Şöyle bir senaryo düşünelim: Gece 3’te alarm çaldı, Slack’e bir screenshot geldi ve sen de ne olduğunu hızlıca anlamak istiyorsun.

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

import os
import base64
import json
from datetime import datetime
from openai import OpenAI

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

MONITORING_SYSTEM_PROMPT = """Sen deneyimli bir DevOps mühendisisin ve monitoring dashboard'larını analiz ediyorsun.
Grafana, Zabbix, Prometheus ve Datadog gibi araçlarla çalışıyorsun.

Bir dashboard görüntüsü gönderildiğinde şunları yapmanı istiyorum:
1. Tespit edilen anomalileri ve alarm durumlarını listele
2. Hangi servisler veya metriklerin sorunlu göründüğünü belirt
3. Öncelik sırasına göre müdahale adımlarını öner
4. Varsa kök neden tahminini paylaş

Yanıtını JSON formatında ver:
{
    "alarm_durumu": "kritik/uyarı/normal",
    "sorunlu_metrikler": [],
    "kök_neden_tahmini": "",
    "öncelikli_aksiyonlar": [],
    "ek_notlar": ""
}"""

def analyze_dashboard_screenshot(screenshot_path: str) -> dict:
    """Monitoring dashboard ekran görüntüsünü analiz eder."""
    
    with open(screenshot_path, "rb") as f:
        base64_image = base64.standard_b64encode(f.read()).decode("utf-8")
    
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": MONITORING_SYSTEM_PROMPT
            },
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": f"Bu monitoring dashboard görüntüsünü analiz et. Tarih: {datetime.now().strftime('%Y-%m-%d %H:%M')}"
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{base64_image}",
                            "detail": "high"
                        }
                    }
                ]
            }
        ],
        max_tokens=1500,
        response_format={"type": "json_object"}
    )
    
    result = json.loads(response.choices[0].message.content)
    
    # Sonucu log dosyasına kaydet
    log_entry = {
        "timestamp": datetime.now().isoformat(),
        "screenshot": screenshot_path,
        "analysis": result,
        "tokens_used": response.usage.total_tokens
    }
    
    with open("monitoring_analysis.log", "a") as log:
        log.write(json.dumps(log_entry, ensure_ascii=False) + "n")
    
    return result

# Örnek kullanım
if __name__ == "__main__":
    # Slack webhook ile entegrasyon örneği
    import sys
    
    screenshot = sys.argv[1] if len(sys.argv) > 1 else "dashboard.png"
    
    if os.path.exists(screenshot):
        analysis = analyze_dashboard_screenshot(screenshot)
        
        alarm = analysis.get("alarm_durumu", "bilinmiyor")
        print(f"n[{alarm.upper()}] Dashboard Analiz Sonucu:")
        print("-" * 50)
        
        for aksiyon in analysis.get("öncelikli_aksiyonlar", []):
            print(f"  -> {aksiyon}")
        
        if analysis.get("kök_neden_tahmini"):
            print(f"nOlası kök neden: {analysis['kök_neden_tahmini']}")

Birden Fazla Görsel ile Karşılaştırmalı Analiz

Bazen tek bir görsel yeterli değildir. Önceki ve sonraki durumu karşılaştırmak, deployment öncesi ve sonrası metrikleri analiz etmek gibi senaryolarda birden fazla görsel gönderebilirsiniz.

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

import os
import base64
from openai import OpenAI

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def compare_two_screenshots(before_path: str, after_path: str, context: str = "") -> str:
    """
    İki ekran görüntüsünü karşılaştırır.
    Deployment öncesi/sonrası veya hata öncesi/sonrası karşılaştırması için kullanışlıdır.
    """
    
    def load_image(path):
        with open(path, "rb") as f:
            return base64.standard_b64encode(f.read()).decode("utf-8")
    
    before_b64 = load_image(before_path)
    after_b64 = load_image(after_path)
    
    comparison_prompt = f"""İki ekran görüntüsünü karşılaştır.
İlk görsel 'ÖNCE', ikinci görsel 'SONRA' durumunu gösteriyor.

{f'Bağlam: {context}' if context else ''}

Şunları analiz et:
- İki görsel arasındaki temel farklar neler?
- Performans veya durum açısından iyileşme var mı, kötüleşme mi?
- Dikkat çeken anomaliler veya değişiklikler neler?
- Genel değerlendirme nedir?"""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": comparison_prompt},
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{before_b64}",
                            "detail": "high"
                        }
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{after_b64}",
                            "detail": "high"
                        }
                    }
                ]
            }
        ],
        max_tokens=1200
    )
    
    return response.choices[0].message.content

# Kullanım örneği
if __name__ == "__main__":
    result = compare_two_screenshots(
        "before_deploy.png",
        "after_deploy.png",
        context="v2.4.1 deployment sonrası CPU ve memory kullanımı"
    )
    print(result)

Ağ Topoloji Diyagramı Dokümantasyonu

Sysadmin hayatında en can sıkıcı işlerden biri ağ diyagramlarını güncel tutmak ve dokümante etmektir. Vision API ile çizilmiş bir ağ diyagramından otomatik olarak yapılandırılmış dokümantasyon üretebilirsiniz.

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

import os
import base64
import json
from openai import OpenAI

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

NETWORK_ANALYSIS_PROMPT = """Sen deneyimli bir network mühendisisin.
Sana bir ağ topoloji diyagramı göndereceğim.

Bu diyagramdan şunları çıkar:
1. Tespit edilen cihaz türleri ve isimleri (router, switch, firewall, server vb.)
2. Ağ segmentleri ve VLAN'lar (varsa)
3. Bağlantı türleri (WAN, LAN, DMZ vb.)
4. IP adresi aralıkları veya subnet bilgileri (görünüyorsa)
5. Güvenlik katmanları ve segmentasyon

Sonucu şu JSON formatında ver:
{
    "cihazlar": [
        {"isim": "", "tür": "", "konum": "", "ip_bilgisi": ""}
    ],
    "ağ_segmentleri": [
        {"isim": "", "tür": "", "subnet": "", "cihazlar": []}
    ],
    "bağlantılar": [
        {"kaynak": "", "hedef": "", "tür": "", "notlar": ""}
    ],
    "güvenlik_notları": [],
    "genel_mimari_özeti": ""
}"""

def document_network_diagram(diagram_path: str, output_format: str = "json") -> str:
    """
    Ağ diyagramı görselini analiz ederek yapılandırılmış dokümantasyon üretir.
    
    output_format:
    - json: Ham JSON çıktısı
    - markdown: Markdown formatında dokümantasyon
    """
    
    with open(diagram_path, "rb") as f:
        base64_image = base64.standard_b64encode(f.read()).decode("utf-8")
    
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": NETWORK_ANALYSIS_PROMPT
            },
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": "Bu ağ topoloji diyagramını analiz et ve dokümante et."
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{base64_image}",
                            "detail": "high"
                        }
                    }
                ]
            }
        ],
        max_tokens=2000,
        response_format={"type": "json_object"}
    )
    
    data = json.loads(response.choices[0].message.content)
    
    if output_format == "markdown":
        # JSON'u markdown dokümantasyona çevir
        md = "# Ağ Topoloji Dokümantasyonunn"
        md += f"## Genel Mimarin{data.get('genel_mimari_özeti', '')}nn"
        
        md += "## Cihaz Envanterin"
        for cihaz in data.get("cihazlar", []):
            md += f"- **{cihaz['isim']}** ({cihaz['tür']}): {cihaz.get('ip_bilgisi', 'IP belirtilmemiş')}n"
        
        md += "n## Ağ Segmentlerin"
        for segment in data.get("ağ_segmentleri", []):
            md += f"- **{segment['isim']}** - Tür: {segment['tür']}, Subnet: {segment.get('subnet', '-')}n"
        
        md += "n## Güvenlik Notların"
        for not_ in data.get("güvenlik_notları", []):
            md += f"- {not_}n"
        
        return md
    
    return json.dumps(data, ensure_ascii=False, indent=2)

Batch İşleme: Çok Sayıda Görseli Toplu Analiz

Bir incident sonrası onlarca ekran görüntüsü incelemeniz gerektiğinde toplu işleme scripti işinizi kolaylaştırır.

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

import os
import base64
import json
import time
from pathlib import Path
from openai import OpenAI
from concurrent.futures import ThreadPoolExecutor, as_completed

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def analyze_single_image(image_path: str, question: str) -> dict:
    """Tek bir görseli analiz eder, hata durumunda retry uygular."""
    
    max_retries = 3
    retry_delay = 2
    
    for attempt in range(max_retries):
        try:
            with open(image_path, "rb") as f:
                base64_image = base64.standard_b64encode(f.read()).decode("utf-8")
            
            response = client.chat.completions.create(
                model="gpt-4o",
                messages=[
                    {
                        "role": "user",
                        "content": [
                            {"type": "text", "text": question},
                            {
                                "type": "image_url",
                                "image_url": {
                                    "url": f"data:image/png;base64,{base64_image}",
                                    "detail": "low"  # Batch işlemde low detail maliyet düşürür
                                }
                            }
                        ]
                    }
                ],
                max_tokens=500
            )
            
            return {
                "dosya": image_path,
                "durum": "başarılı",
                "analiz": response.choices[0].message.content,
                "token_kullanimi": response.usage.total_tokens
            }
            
        except Exception as e:
            if attempt < max_retries - 1:
                time.sleep(retry_delay * (attempt + 1))
            else:
                return {
                    "dosya": image_path,
                    "durum": "hata",
                    "hata_mesaji": str(e)
                }

def batch_analyze_directory(directory: str, question: str, max_workers: int = 3) -> list:
    """
    Bir dizindeki tüm görselleri paralel olarak analiz eder.
    Rate limit'e takılmamak için max_workers 3 olarak ayarlandı.
    """
    
    image_extensions = {".png", ".jpg", ".jpeg", ".gif", ".webp"}
    image_files = [
        str(p) for p in Path(directory).iterdir()
        if p.suffix.lower() in image_extensions
    ]
    
    print(f"Toplam {len(image_files)} görsel bulundu.")
    results = []
    total_tokens = 0
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = {
            executor.submit(analyze_single_image, img, question): img
            for img in image_files
        }
        
        for i, future in enumerate(as_completed(futures), 1):
            result = future.result()
            results.append(result)
            
            if result["durum"] == "başarılı":
                total_tokens += result.get("token_kullanimi", 0)
                print(f"[{i}/{len(image_files)}] Tamamlandı: {result['dosya']}")
            else:
                print(f"[{i}/{len(image_files)}] HATA: {result['dosya']} - {result.get('hata_mesaji')}")
    
    # Sonuçları kaydet
    output_file = "batch_analysis_results.json"
    with open(output_file, "w", encoding="utf-8") as f:
        json.dump({
            "toplam_görsel": len(image_files),
            "başarılı": sum(1 for r in results if r["durum"] == "başarılı"),
            "hatalı": sum(1 for r in results if r["durum"] == "hata"),
            "toplam_token": total_tokens,
            "tahmini_maliyet_usd": round(total_tokens * 0.000005, 4),
            "sonuçlar": results
        }, f, ensure_ascii=False, indent=2)
    
    print(f"nSonuçlar {output_file} dosyasına kaydedildi.")
    print(f"Toplam token kullanımı: {total_tokens}")
    
    return results

if __name__ == "__main__":
    batch_analyze_directory(
        directory="./screenshots",
        question="Bu ekran görüntüsünde hata veya uyarı var mı? Kısaca açıkla.",
        max_workers=3
    )

Maliyet Optimizasyonu ve Rate Limit Yönetimi

Vision API kullanımında dikkat edilmesi gereken pratik noktalar:

Detail seviyesi seçimi:

  • low: Basit içerik tespiti, logo tanıma, genel kategorizasyon için yeterli. 85 sabit token harcar.
  • high: OCR benzeri metin okuma, detaylı metrik analizi, karmaşık diyagramlar için kullanın. Görsel boyutuna göre 170 ile 1000+ token arasında harcar.
  • auto: Modele bırakırsanız genellikle high seçer, maliyet kontrolü için önerilmez.

Rate limit sınırları:

  • RPM (Requests Per Minute): Tier 1 hesaplarda dakikada 60 istek
  • TPM (Tokens Per Minute): Tier 1’de dakikada 90.000 token
  • Batch işlemlerde: max_workers değerini 3-5 arasında tutun, exponential backoff uygulayın

Görsel optimizasyonu:

  • Göndermeden önce görseli yeniden boyutlandırabilirsiniz. 1024×1024 üzerindeki görseller için high detail zaten yeniden boyutlandırma yapar ama bant genişliği açısından önceden resize etmek daha iyidir.
  • PNG’ler JPEG’den daha büyük olabilir. Kalite kaybı kabul edilebilirse JPEG kullanın.
  • Beyaz arka plan üzerindeki diyagramlar için görsel sıkıştırma agresif şekilde uygulanabilir.

Model seçimi:

  • gpt-4o: En iyi görsel anlama kapasitesi, hız ve maliyet dengesi için önerilen model
  • gpt-4o-mini: Basit görsel sınıflandırma ve OCR için yeterli, çok daha düşük maliyet
  • gpt-4-turbo: Eski projeler için, yeni başlıyorsanız direkt gpt-4o kullanın

Güvenlik ve Gizlilik Konuları

Sysadmin olarak şunu aklınızda tutun: Vision API’ye gönderdiğiniz görseller OpenAI sunucularına iletilir. Bu nedenle:

  • Ekran görüntülerinde şifre, API key veya hassas kimlik bilgisi olup olmadığını kontrol edin
  • Production ortamının hassas metriklerini göndermeden önce görseli crop/mask etmeyi düşünün
  • Kurumsal politikalar gereği veri gizliliği önemliyse Azure OpenAI Service’i değerlendirin; Azure’da veriler tenant’ınızda kalır
  • Test ortamı görsellerini kullanarak iş akışınızı doğrulayın, sonra production’a geçin

Sonuç

OpenAI Vision API, sysadmin araç kutusuna ciddi bir otomasyon kapasitesi katıyor. Monitoring dashboard analizi, ağ diyagramı dokümantasyonu, batch ekran görüntüsü incelemesi gibi senaryolarda saatlik manuel çalışmayı dakikalara indirebilirsiniz. Başlangıç için monitoring screenshot’larınızı analiz eden basit bir script yazmanızı öneririm; hem API’yi öğrenirsiniz hem de hemen pratik değer üretirsiniz.

Maliyet tarafında endişeleriniz varsa, gpt-4o-mini ile low detail kombinasyonu çoğu operasyonel kullanım senaryosu için yeterince doğru sonuç verir ve maliyeti kayda değer ölçüde düşürür. Detaylı analiz gereken kritik senaryolar için ise gpt-4o ile high detail kombinasyonunu saklayın. Batch işlemlerde her zaman token kullanımını logladığınızdan emin olun; aylık faturalanmanın nereye gittiğini takip etmek, her zamanki sysadmin disiplinin bir parçası.

Bir yanıt yazın

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