Python İle Nesne Tanıma Kütüphanesi Kullanarak Analiz Nasıl Yapılır?

Yapay zeka ve bilgisayarlı görü (computer vision) teknolojileri, günümüzde endüstriyel üretimden otonom araçlara, güvenlik sistemlerinden sağlık sektörüne kadar geniş bir alanda kritik çözümler sunmaktadır. Bu teknolojilerin temelini oluşturan en önemli süreçlerden biri de nesne tanımadır. Bu rehberimizde, modern yazılım dünyasının en güçlü araçlarını kullanarak Python İle Nesne Tanıma Kütüphanesi Kullanarak Analiz Nasıl Yapılır? sorusunun yanıtını adım adım, uygulamalı ve çalışır kod örnekleriyle inceleyeceğiz.

Bu makale, temel düzeyde Python bilgisine sahip olan ve projelerinde nesne tanıma (object detection) yeteneklerini kullanmak isteyen yazılım geliştiriciler, veri bilimciler ve mühendisler için hazırlanmıştır. Rehber boyunca, popüler bilgisayarlı görü kütüphanesi OpenCV ve günümüzün en hızlı, en doğru sonuç veren derin öğrenme tabanlı nesne tanıma kütüphanelerinden biri olan Ultralytics YOLO (You Only Look Once) mimarisini kullanacağız. Eğitim sonunda kendi görselleriniz ve video akışlarınız üzerinde analiz yapabilecek seviyeye geleceksiniz.

Nesne tanıma analizleri, sadece bir görselde ne olduğunu söylemekle kalmaz; bu nesnelerin görsel üzerindeki tam koordinatlarını (sınırlayıcı kutularını) ve doğruluk oranlarını (güven skorlarını) da bize sunar. Şimdi, bu analiz sürecini gerçekleştirmek için gerekli olan geliştirme ortamını hazırlayarak ilk adımımızı atalım.

Gereksinimler ve Ön Hazırlık: Geliştirme Ortamının Kurulması

Python ile nesne tanıma analizleri gerçekleştirmek için bilgisayarınızda Python 3.10 veya üzeri bir sürümün kurulu olması önerilir. Derin öğrenme modelleri yüksek işlem gücü gerektirdiğinden, kütüphanelerin uyumlu ve güncel sürümlerini kullanmak performans açısından kritik öneme sahiptir. Projemizde çakışmaları önlemek adına sanal bir ortam (virtual environment) oluşturarak işe başlayacağız.

İlk olarak terminal veya komut satırınızı açarak projeniz için yeni bir dizin oluşturun ve bu dizine geçiş yapın. Ardından aşağıdaki komutları sırasıyla çalıştırarak sanal ortamınızı oluşturun ve aktif hale getirin:

# Proje dizini oluşturma ve dizine geçiş yapma
mkdir python_nesne_tanima
cd python_nesne_tanima

# Sanal ortam oluşturma
python -m venv venv

# Sanal ortamı aktif etme (Windows için)
venv\Scripts\activate

# Sanal ortamı aktif etme (macOS ve Linux için)
source venv/bin/activate

Sanal ortamı aktif ettikten sonra, nesne tanıma analizi için kullanacağımız temel kütüphaneleri yüklememiz gerekmektedir. Bu rehberde görüntü işleme işlemleri için OpenCV, nesne tanıma modeli için ise Ultralytics YOLO kütüphanesini tercih edeceğiz. Ayrıca sayısal analizler için NumPy kütüphanesi de otomatik olarak yüklenecektir. Gerekli paketleri yüklemek için aşağıdaki pip komutunu çalıştırın:

pip install opencv-python ultralytics numpy matplotlib

Önemli Uyarı: Eğer sisteminizde NVIDIA marka bir grafik kartı bulunuyorsa ve CUDA desteğiyle GPU (Grafik İşlemci) üzerinden çok daha hızlı analizler yapmak istiyorsanız, PyTorch kütüphanesini sisteminize uygun CUDA sürümüyle manuel olarak kurmanız gerekebilir. CPU (Merkezi İşlemci) üzerinde de bu rehberdeki tüm kodlar sorunsuz çalışacaktır ancak gerçek zamanlı video analizlerinde FPS (Saniye Başına Kare) oranı daha düşük olacaktır.

Nesne Tanıma Mantığı ve Temel Kavramlar

Kodlama aşamasına geçmeden önce, nesne tanıma analizlerinde sıklıkla karşılaşacağımız ve algoritmanın çıktı olarak bize sunduğu üç temel kavramı anlamamız gerekir. Bu kavramlar, analiz sonuçlarını doğru yorumlayabilmemiz için hayati önem taşır:

• Sınırlayıcı Kutu (Bounding Box - BBox): Nesnenin görsel üzerinde bulunduğu alanı çevreleyen dikdörtgen kutudur. Genellikle sol üst köşenin koordinatları (x1, y1) ile sağ alt köşenin koordinatları (x2, y2) veya kutunun merkez koordinatları (x, y) ile genişlik (w) ve yükseklik (h) değerleri şeklinde temsil edilir.
• Güven Skoru (Confidence Score): Modelin, tespit ettiği nesnenin gerçekten o sınıfa ait olup olmadığından ne kadar emin olduğunu gösteren, 0 ile 1 arasında değişen bir olasılık değeridir. Örneğin, 0.85 değeri, modelin o nesnenin tanımlanan sınıfa ait olduğundan %85 oranında emin olduğunu gösterir.
• Sınıf Kimliği ve Etiketi (Class ID & Label): Modelin eğitime tabi tutulduğu veri setindeki nesne türleridir. Örneğin, COCO veri setinde "insan" (person) sınıfı 0, "bisiklet" (bicycle) sınıfı 1, "araba" (car) sınıfı ise 2 kimlik numarası ile temsil edilir.

Adım 1: Görüntü Yükleme ve Ön İşleme Nasıl Yapılır?

Nesne tanıma analizinin ilk adımı, analiz edilecek görselin sisteme yüklenmesi ve modelin kabul edebileceği formatta ön işlemden geçirilmesidir. OpenCV kütüphanesi varsayılan olarak görselleri BGR (Mavi-Yeşil-Kırmızı) renk uzayında yükler. Ancak modern derin öğrenme modelleri genellikle RGB (Kırmızı-Yeşil-Mavi) formatında eğitilmiştir. Bu nedenle renk dönüşümü yapılması gerekebilir.

Aşağıdaki örnek kodda, yerel diskinizde bulunan bir görseli OpenCV kullanarak nasıl yükleyeceğinizi, boyutlandıracağınızı ve analiz öncesi görsel özelliklerini nasıl inceleyeceğinizi adım adım görebilirsiniz:

import cv2

def gorsel_on_isleme(gorsel_yolu):
    # Görseli diskten yükle
    gorsel = cv2.imread(gorsel_yolu)
    
    if gorsel is None:
        print("Hata: Görsel yüklenemedi. Lütfen dosya yolunu kontrol edin.")
        return None
        
    # Görselin orijinal boyutlarını al
    yukseklik, genislik, kanal = gorsel.shape
    print(f"Orijinal Boyutlar: Genişlik: {genislik}px, Yükseklik: {yukseklik}px, Kanal Sayısı: {kanal}")
    
    # Analiz performansını artırmak için görseli standart bir boyuta getir (Opsiyonel)
    hedef_boyut = (640, 640)
    gorsel_yeniden_boyutlandirilmis = cv2.resize(gorsel, hedef_boyut)
    print(f"Yeniden Boyutlandırılmış Boyut: {gorsel_yeniden_boyutlandirilmis.shape}")
    
    return gorsel_yeniden_boyutlandirilmis

# Fonksiyonu test etme
if __name__ == "__main__":
    # Test için 'ornek_gorsel.jpg' adında bir görselin dizininizde olduğunu varsayıyoruz
    islenmis_resim = gorsel_on_isleme("ornek_gorsel.jpg")

Yukarıdaki kod bloğunda, öncelikle cv2.imread fonksiyonu ile görseli belleğe aldık. Görselin başarıyla yüklenip yüklenmediğini kontrol eden bir güvenlik mekanizması ekledik; bu, dosya yolu hatalarını debug (hata ayıklama) etmeyi kolaylaştırır. Ardından, modelimizin daha hızlı çalışması için görseli 640x640 piksel boyutlarına getirdik.

Adım 2: YOLO Modelini Yükleme ve İlk Tahmini Gerçekleştirme

Görselimizi hazırladıktan sonra, nesne tanıma kütüphanesi kullanarak analiz yapma aşamasına geçebiliriz. Bu adımda Ultralytics tarafından sunulan önceden eğitilmiş (pretrained) YOLOv8 modelini kullanacağız. Bu model, COCO (Common Objects in Context) veri seti üzerinde eğitilmiş olup, günlük hayatta karşılaşabileceğimiz 80 farklı nesne sınıfını (insan, araba, kedi, köpek, masa, telefon vb.) doğrudan tanıyabilmektedir.

Aşağıdaki kod örneğinde, YOLO modelini nasıl projenize dahil edeceğinizi ve yüklediğiniz görsel üzerinde ilk çıkarım (inference) işlemini nasıl gerçekleştireceğinizi görebilirsiniz:

from ultralytics import YOLO

def nesne_tanima_analizi(gorsel_yolu):
    # Önceden eğitilmiş YOLOv8 Nano modelini yükle (Hızlı ve hafif bir modeldir)
    # Model dosyası (.pt) dizinde yoksa otomatik olarak indirilecektir
    model = YOLO("yolov8n.pt")
    
    print("Model başarıyla yüklendi. Analiz başlatılıyor...")
    
    # Görsel üzerinde tahmin (inference) gerçekleştir
    # stream=False parametresi tüm sonuçları bellekte tutar
    sonuclar = model(gorsel_yolu, conf=0.25) # 0.25 üzerindeki güven skoruna sahip nesneleri getir
    
    print("Analiz tamamlandı.")
    return sonuclar

# Fonksiyonu test etme
if __name__ == "__main__":
    analiz_sonuclari = nesne_tanima_analizi("ornek_gorsel.jpg")
    # İlk sonucun detaylarını yazdır
    for sonuc in analiz_sonuclari:
        print(f"Tespit edilen nesne sayısı: {len(sonuc.boxes)}")

Bu kod bloğunda, YOLO("yolov8n.pt") satırı ile YOLOv8'in en hafif sürümü olan "Nano" modelini yükledik. Eğer sisteminizde bu dosya yoksa, kütüphane bunu internetten otomatik olarak indirir. conf=0.25 parametresi, modelin yalnızca %25 ve üzeri güven oranına sahip olan tahminleri sonuç listesine eklemesini sağlar. Bu eşik değerini (threshold) projenizin hassasiyetine göre artırabilir veya azaltabilirsiniz.

Adım 3: Analiz Sonuçlarını Görselleştirme ve Sınırlayıcı Kutuları Çizme

Modelin ürettiği ham veriler (koordinatlar ve sınıf indeksleri) doğrudan kullanıcıya sunulmak için uygun değildir. Bu verileri görselleştirerek, tespit edilen nesnelerin etrafına sınırlayıcı kutular çizmek, sınıf isimlerini ve güven skorlarını yazmak gerekir. Bu işlem, analizin doğruluğunu insan gözüyle doğrulamak için kritik bir adımdır.

Aşağıdaki örnek kod, modelden dönen koordinat bilgilerini alarak OpenCV yardımıyla görsel üzerine dinamik olarak kutu ve etiket ekleme işlemini gerçekleştirmektedir:

import cv2
from ultralytics import YOLO

def sonuclari_gorsellestir(gorsel_yolu, cikis_yolu):
    # Modeli ve görseli yükle
    model = YOLO("yolov8n.pt")
    gorsel = cv2.imread(gorsel_yolu)
    sonuclar = model(gorsel_yolu)
    
    # Sonuçlar listesindeki ilk sonucu al (Tek bir görsel gönderdiğimiz için)
    sonuc = sonuclar[0]
    
    # Tespit edilen her bir nesne kutusu için döngü oluştur
    for kutu in sonuc.boxes:
        # Koordinatları al (x1, y1, x2, y2) - float değerleri tamsayıya çevir
        x1, y1, x2, y2 = map(int, kutu.xyxy[0])
        
        # Güven skorunu ve sınıf indeksini al
        guven_skoru = float(kutu.conf[0])
        sinif_id = int(kutu.cls[0])
        sinif_adi = model.names[sinif_id]
        
        # Görsel üzerine sınırlayıcı kutuyu çiz (Yeşil renk, 2px kalınlık)
        cv2.rectangle(gorsel, (x1, y1), (x2, y2), (0, 255, 0), 2)
        
        # Etiket metnini hazırla
        etiket = f"{sinif_adi}: {guven_skoru:.2f}"
        
        # Etiket arka planı için metin boyutunu hesapla
        (metin_genisligi, metin_yuksekligi), taban_izgisi = cv2.getTextSize(
            etiket, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1
        )
        
        # Metin arka planı dikdörtgenini çiz
        cv2.rectangle(
            gorsel, 
            (x1, y1 - metin_yuksekligi - 10), 
            (x1 + metin_genisligi, y1), 
            (0, 255, 0), 
            -1
        )
        
        # Metni görsel üzerine yaz (Siyah renk)
        cv2.putText(
            gorsel, 
            etiket, 
            (x1, y1 - 5), 
            cv2.FONT_HERSHEY_SIMPLEX, 
            0.5, 
            (0, 0, 0), 
            1, 
            cv2.LINE_AA
        )
    
    # Sonucu diske kaydet
    cv2.imwrite(cikis_yolu, gorsel)
    print(f"Analiz sonucu başarıyla kaydedildi: {cikis_yolu}")

# Çalıştırma
if __name__ == "__main__":
    sonuclari_gorsellestir("ornek_gorsel.jpg", "analiz_sonucu.jpg")

Yukarıdaki kodda, modelin boxes özniteliği üzerinden her bir tespit edilen nesnenin koordinatlarına (xyxy), güven skoruna (conf) ve sınıf kimliğine (cls) eriştik. OpenCV'nin cv2.rectangle fonksiyonu ile nesnelerin etrafına kutular çizdik ve cv2.putText ile bu kutuların üzerine sınıf adı ile güven skorunu dinamik olarak yazdırdık. Sonuç görselini cv2.imwrite ile diske kaydettik.

Adım 4: Gerçek Zamanlı Video Akışı Üzerinde Nesne Analizi

Statik görseller üzerinde yapılan analizlerin yanı sıra, güvenlik kameraları veya canlı video akışları üzerinde gerçek zamanlı nesne tanıma analizleri yapmak endüstride en çok talep edilen uygulamalardan biridir. Video analizi, videonun her bir karesini (frame) sırayla okuyup, her kareyi birer görsel gibi işleyerek gerçekleştirilir.

Aşağıdaki örnek kod, bilgisayarınızın varsayılan kamerasını (webcam) açarak gerçek zamanlı nesne tanıma analizi yapar ve saniye başına işlenen kare sayısını (FPS) ekranda gösterir:

import cv2
import time
from ultralytics import YOLO

def canli_video_analizi():
    # Modeli yükle
    model = YOLO("yolov8n.pt")
    
    # Kamera akışını başlat (0 varsayılan dahili kameradır)
    kamera = cv2.VideoCapture(0)
    
    if not kamera.isOpened():
        print("Hata: Kamera akışı başlatılamadı.")
        return

    print("Canlı analiz başlatıldı. Çıkmak için 'q' tuşuna basın.")
    
    onceki_zaman = 0
    
    while True:
        # Kameradan bir kare oku
        ret, kare = kamera.read()
        if not ret:
            print("Kare okunamadı. Akış sonlandırılıyor.")
            break
            
        # Mevcut kare üzerinde analiz yap (verbose=False ile terminal çıktısını temiz tutuyoruz)
        sonuclar = model(kare, verbose=False)
        
        # Sonuçları kare üzerine otomatik olarak çiz (YOLO'nun dahili plot fonksiyonu)
        gorsellestirilmis_kare = sonuclar[0].plot()
        
        # FPS Hesaplama
        simdiki_zaman = time.time()
        fps = 1 / (simdiki_zaman - onceki_zaman)
        onceki_zaman = simdiki_zaman
        
        # FPS değerini ekrana yazdır
        cv2.putText(
            gorsellestirilmis_kare, 
            f"FPS: {int(fps)}", 
            (20, 50), 
            cv2.FONT_HERSHEY_SIMPLEX, 
            1, 
            (0, 0, 255), 
            2
        )
        
        # Sonucu pencerede göster
        cv2.imshow("Gerçek Zamanlı Nesne Analizi", gorsellestirilmis_kare)
        
        # 'q' tuşuna basılırsa döngüden çık
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
            
    # Kaynakları serbest bırak ve pencereleri kapat
    kamera.release()
    cv2.destroyAllWindows()

if __name__ == "__main__":
    canli_video_analizi()

Bu kod bloğunda, video akışını yönetmek için cv2.VideoCapture kullandık. Sonsuz bir while döngüsü içinde her bir kareyi okuyup YOLO modeline gönderdik. YOLO'nun kendi içinde barındırdığı plot() metodunu kullanarak sınırlayıcı kutuların çizim işlemini tek satırda gerçekleştirdik. time modülü ile iki kare arasındaki süreyi ölçerek anlık FPS değerini hesapladık ve ekrana yazdırdık. Kullanıcı 'q' tuşuna bastığında kamera bağlantısı güvenli bir şekilde kapatılır.

Adım 5: Belirli Nesneleri Filtreleme ve Özel Analiz Senaryoları

Gerçek dünya senaryolarında, modelin tespit ettiği tüm nesneleri analiz etmek istemeyebiliriz. Örneğin, bir otopark yönetim sistem