YOLO Nedir?

• You Only Look Once: Tek bakışta nesne tespiti
• Gerçek zamanlı nesne tespit algoritması
• 2016 yılında Joseph Redmon tarafından geliştirildi
• Tek sinir ağı geçişi ile hem sınıflandırma hem de lokalizasyon

Nesne Tespiti Nedir?

Görüntü içerisindeki nesnelerin hem sınıfını (ne olduğunu) hem de konumunu (nerede olduğunu) belirleme işlemidir.

• Sınıflandırma: "Bu bir kedi."
• Lokalizasyon: "Kedi bu koordinatlarda."

Ağ Yapısı

• 24 Konvolüsyonel Katman: Özellik çıkarma
• 2 Fully Connected Katman: Tahmin oluşturma
• Leaky ReLU Aktivasyon: Doğrusal olmayan öğrenme
• Dropout: Aşırı öğrenmeyi önleme

Tek Aşamada Tespit Nasıl Çalışır?

YOLO görüntüyü bir kez ağdan geçirir ve aynı anda hem nesne varlığını hem de sınıfını hem de bounding box koordinatlarını tahmin eder. Bu sayede çok hızlı çalışır.

Izgara Sistemi Çalışma Prensibi

• 7×7 Grid: Görüntü 49 hücreye bölünür
• Her Hücre: 2 bounding box tahmin eder
• Güven Skoru: Nesne varlık olasılığı
• Sınıf Olasılıkları: 20 farklı nesne sınıfı

Çıktı Tensor Yapısı: 7×7×30

• 5×2 = 10: İki bounding box (x, y, w, h, confidence)
• 20: Sınıf olasılıkları
• Toplam: Her hücre için 30 değer

Multi-Scale Detection Çalışma Prensibi

• 3 Farklı Ölçek: Küçük, orta ve büyük nesneler için
• Feature Pyramid Network (FPN): Hiyerarşik özellik birleştirme
• Anchor Boxes: Her ölçekte 3'er önceden tanımlı kutu
• Darknet-53 Backbone: 53 katmanlı daha derin ağ

Çıktı Tensor Yapısı: 3 Farklı Boyut

• 13×13×255: Büyük nesneler için (3 anchor × 85)
• 26×26×255: Orta boyut nesneler için (3 anchor × 85)
• 52×52×255: Küçük nesneler için (3 anchor × 85)
• 85 = 4 (bbox) + 1 (confidence) + 80 (classes)

Multi-Part Loss Function

Loss = λ_coord × L_coord + L_conf + λ_noobj × L_noobj + L_class

L_coord = Σ[i=0 to S²]Σ[j=0 to B] 𝟙ᵢⱼᵒᵇʲ [(xᵢ - x̂ᵢ)² + (yᵢ - ŷᵢ)²]
        + Σ[i=0 to S²]Σ[j=0 to B] 𝟙ᵢⱼᵒᵇʲ [(√wᵢ - √ŵᵢ)² + (√hᵢ - √ĥᵢ)²]

L_conf = Σ[i=0 to S²]Σ[j=0 to B] 𝟙ᵢⱼᵒᵇʲ (Cᵢ - Ĉᵢ)²
       + λ_noobj × Σ[i=0 to S²]Σ[j=0 to B] 𝟙ᵢⱼⁿᵒᵒᵇʲ (Cᵢ - Ĉᵢ)²

L_class = Σ[i=0 to S²] 𝟙ᵢᵒᵇʲ Σ[c∈classes] (pᵢ(c) - p̂ᵢ(c))²

Loss Bileşenleri

• L_coord: Bounding box koordinat hatası (λ_coord = 5)
• L_conf: Confidence score hatası
• L_class: Sınıflandırma hatası
• λ_noobj: No-object penalty (genellikle 0.5)

Training Stratejisi

• Pre-training: ImageNet'te sınıflandırma
• Fine-tuning: Tespit verileri ile 135 epoch
• Learning Rate: 0.001 → 0.0001 (75 epoch sonra)
• Data Augmentation: Random scaling, translation

Anchor Box Stratejisi (YOLOv2+)

• K-means Clustering: Optimal anchor boyutlarını belirleme
• Dimension Clusters: Veri setindeki bounding box'ları analiz
• 5 Anchor Box: YOLOv2'de en iyi performans

# Anchor Box Generation (Pseudo-code)
def generate_anchors(dataset_boxes):
    # K-means clustering on box dimensions
    widths_heights = [(box.w, box.h) for box in dataset_boxes]
    anchors = kmeans(widths_heights, k=5)
    
    # Optimize for average IoU
    avg_iou = calculate_avg_iou(anchors, dataset_boxes)
    return anchors

# Non-Maximum Suppression
def nms(boxes, scores, threshold=0.5):
    sorted_indices = np.argsort(scores)[::-1]
    keep = []
    
    while len(sorted_indices) > 0:
        keep.append(sorted_indices[0])
        ious = calculate_iou(boxes[sorted_indices[0]],
                           boxes[sorted_indices[1:]])
        sorted_indices = sorted_indices[1:][ious < threshold]
    
    return keep

NMS (Non-Maximum Suppression)

• Problem: Çoklu tespit problemi
• Çözüm: IoU threshold ile filtreleme
• Threshold: Genellikle 0.5-0.7 arası

Mosaic Augmentation (YOLOv4)

• 4 Görüntü Birleştirme: Tek eğitim örneği için
• Batch Normalization: Daha büyük mini-batch etkisi
• Küçük Nesne Tespiti: Gelişmiş performans

# Pseudo-code
def mosaic_augmentation(images):
    # 4 görüntüyü birleştir
    mosaic = combine_four_images(images)
    # Bounding box'ları dönüştür
    boxes = transform_boxes(boxes, mosaic)
    return mosaic, boxes

# Pseudo-code
def cutmix(img1, img2, labels1, labels2):
    # Rastgele patch seç
    bbox = random_bbox()
    # İkinci görüntüden patch kes
    img1[bbox] = img2[bbox]
    # Label'ları birleştir
    return img1, mix_labels

Diğer Augmentation Teknikleri

• MixUp: Görüntü ve label interpolasyonu
• Random Erasing: Rastgele bölge silme
• GridMask: Düzenli grid pattern maskeleme
• AutoAugment: Policy tabanlı otomatik augmentation

YOLOv5+ Self-Adaptive Anchor

• Genetik Algoritma: Optimal anchor boyutları
• Cross-Stage Partial: CSP ağ yapısı ile optimizasyon

Darknet-53 Backbone (YOLOv3)

Neck ve Head Mimarisi

• PANet (Path Aggregation): Bottom-up path augmentation
• FPN (Feature Pyramid): Multi-scale feature fusion
• YOLO Head: Class + Objectness + BBox regression

# YOLOv5 Model Configuration
model:
  backbone:
    - [Focus, [64, 3]]  # P1/2
    - [Conv, [128, 3, 2]]  # P2/4
    - [C3, [128]]
    - [Conv, [256, 3, 2]]  # P3/8
  
  neck:
    - [Conv, [512, 1, 1]]
    - [nn.Upsample, [None, 2, 'nearest']]
    - [Concat, [1]]  # cat backbone P4
  
  head:
    - [Detect, [nc, anchors]]  # Detect(P3, P4, P5)

Object Detection Metrics

IoU = Area of Overlap / Area of Union
IoU = |A ∩ B| / |A ∪ B|

# Pseudo-code
def calculate_iou(box1, box2):
    x1 = max(box1[0], box2[0])
    y1 = max(box1[1], box2[1])
    x2 = min(box1[2], box2[2])
    y2 = min(box1[3], box2[3])
    
    intersection = max(0, x2-x1) * max(0, y2-y1)
    union = box1_area + box2_area - intersection
    return intersection / union

AP = ∫₀¹ P(R) dR

mAP@0.5 = Average AP at IoU=0.5
mAP@0.5:0.95 = Average AP from IoU=0.5 to 0.95

# COCO Evaluation
for each_class:
    AP = calculate_AP(precision, recall)
mAP = mean(all_class_APs)

YOLO Specific Metrics

• Confidence Threshold: Nesne varlık eşik değeri (0.25-0.5)
• NMS Threshold: Çoklu tespit eliminasyonu (0.45-0.7)
• FPS (Frames Per Second): Gerçek zamanlı performans
• Model Size: MB cinsinden depolama gereksinimi

Benchmark Sonuçları (COCO Dataset)

• YOLOv3: 31.0% mAP@0.5:0.95, 22ms inference
• YOLOv4: 43.5% mAP@0.5:0.95, 23ms inference
• YOLOv5s: 37.4% mAP@0.5:0.95, 6.4ms inference
• YOLOv8n: 37.3% mAP@0.5:0.95, 8.7ms inference

YOLO'nun Matematiksel Formülasyonu

P(Object) = σ(t₀)
bₓ = σ(tₓ) + cₓ
b_y = σ(t_y) + c_y
bw = pw * exp(tw)
bh = ph * exp(th)

# Objectness Score
confidence = P(Object) * IoU(pred_box, ground_truth)

# Class Probability
P(Class_i | Object) = softmax(class_scores_i)

Sigmoid ve Exponential Functions

• σ(x) = 1/(1 + e^(-x)): Bounding box center normalizasyonu
• exp(tw), exp(th): Width/height tahminleri için logaritmik alan
• Anchor Priors: pw, ph önceden tanımlı anchor boyutları

# Posterior Probability
P(class|box) ∝ P(box|class) * P(class)

# Maximum Likelihood Estimation
θ* = argmax Σ log P(y_i|x_i, θ)

# Regularization Term
L_total = L_data + λ * L_regularization

# Chain Rule Application
∂L/∂w = ∂L/∂y * ∂y/∂w

# Gradient Clipping
g = clip(g, -max_norm, max_norm)

# Momentum Update
v_t = β*v_{t-1} + (1-β)*g_t
w_t = w_{t-1} - α*v_t

Information Theory Perspective

• Cross-Entropy Loss: -Σ y_i * log(ŷ_i) bilgi teorisi temeli
• KL Divergence: Model ve gerçek dağılım arasındaki fark
• Mutual Information: Feature ve label arasındaki bağımlılık

Karşılaştırmalı Analiz

YOLO'nun Avantajları

• Unified Architecture: End-to-end tek model
• Real-time Performance: Video işleme için ideal
• Global Context: Tüm görüntü bilgisini kullanır
• Simple Pipeline: Kolay implementasyon

Trade-offs ve Limitasyonlar

• Small Objects: Küçük nesnelerde zorlanma
• Aspect Ratio: Unusual ratios için problem
• Localization: Fine-grained lokalizasyon hatası

# Performance Comparison (COCO Dataset)
Method          | mAP@0.5:0.95 | FPS   | Model Size
----------------|--------------|-------|------------
Faster R-CNN    | 42.7%        | 7     | 522 MB
SSD512         | 28.8%        | 22    | 91 MB
RetinaNet      | 39.1%        | 13    | 145 MB
YOLOv3         | 31.0%        | 35    | 248 MB
YOLOv5s        | 37.4%        | 140   | 14 MB
YOLOv8n        | 37.3%        | 80    | 6.2 MB

Güncel Zorluklar

Edge Computing Challenges

• Memory Constraints: Mobil cihazlarda RAM limitasyonu
• Power Consumption: Battery life optimizasyonu
• Latency Requirements: Real-time inference gereksinimleri
• Model Compression: Quantization ve pruning ihtiyacı

# Gelecek Araştırma Yönelimler
1. Few-shot Learning: Az veriyle öğrenme
2. Neural Architecture Search (NAS): Otomatik model tasarımı
3. Continual Learning: Sürekli öğrenme sistemleri
4. Federated Learning: Dağıtık öğrenme modelleri
5. Multi-modal Fusion: Görüntü + Metin + Audio
6. 3D Object Detection: LiDAR + Camera integration
7. Video Understanding: Temporal consistency
8. Edge-Cloud Hybrid: Dynamic model deployment

Model Optimizasyon Teknikleri

Hardware-specific Optimization

• TensorRT (NVIDIA): GPU inference optimizasyonu
• OpenVINO (Intel): CPU/VPU deployment
• Core ML (Apple): iOS deployment framework
• TensorFlow Lite: Mobile/IoT devices

# Edge Deployment Pipeline
# 1. Model Training
model = YOLOv8('yolov8n.pt')
model.train(data='coco.yaml', epochs=100)

# 2. Model Export
model.export(format='onnx')  # ONNX format
model.export(format='trt')   # TensorRT
model.export(format='coreml') # Core ML

# 3. Quantization
from ultralytics import YOLO
model = YOLO('yolov8n.pt')
model.export(format='onnx', int8=True)  # INT8 quantization

# 4. Benchmark Testing
results = model.benchmark(device='0')  # GPU benchmark

Performance Metrics

• Latency: Inference süresi (ms)
• Throughput: Saniye başına işlenen frame
• Memory Usage: RAM kullanımı (MB)
• Power Consumption: Enerji tüketimi (W)

Ultralytics YOLOv8 ile Nesne Tespiti

Güncel kütüphanelerle YOLO'yu kullanmak oldukça basitleştirilmiştir. İşte ultralytics kütüphanesi ile bir örnek:

# Gerekli kütüphaneyi yükleyin: pip install ultralytics
 from ultralytics import YOLO
 from PIL import Image
 
 # Önceden eğitilmiş YOLOv8 modelini yükle
 model = YOLO('yolov8n.pt') # 'n' nano model, en hızlısı
 
 # Bir görüntü üzerinde tahmin yap
 results = model('path/to/your/image.jpg')
 
 # Sonuçları işle ve göster
 for r in results:
     im_array = r.plot()  # Tespitleri içeren BGR numpy array'i
     im = Image.fromarray(im_array[..., ::-1])  # RGB'ye dönüştür
     im.show()  # Görüntüyü göster
     im.save('results.jpg')  # Sonucu kaydet
 

Kodun Açıklaması

• Model Yükleme: Tek satır kod ile önceden eğitilmiş bir modeli (yolov8n.pt) yüklüyoruz.
• Tahmin: Modeli bir görüntü ile çağırmak, tespiti gerçekleştirmek için yeterlidir.
• Görselleştirme: .plot() metodu, tespit sonuçlarını orijinal görüntü üzerine kolayca çizmemizi sağlar.

Temel YOLO Makaleleri

• Redmon, J., et al. (2016). "You Only Look Once: Unified, Real-Time Object Detection." CVPR 2016.
• Redmon, J., Farhadi, A. (2017). "YOLO9000: Better, Faster, Stronger." CVPR 2017.
• Redmon, J., Farhadi, A. (2018). "YOLOv3: An Incremental Improvement." arXiv preprint.
• Bochkovskiy, A., et al. (2020). "YOLOv4: Optimal Speed and Accuracy of Object Detection." CVPR 2020.

Güncel Gelişmeler

• Wang, C.Y., et al. (2022). "YOLOv7: Trainable bag-of-freebies sets new state-of-the-art." CVPR 2022.
• Ultralytics (2023). "YOLOv8: A new state-of-the-art YOLO model." Technical Report.
• Wang, A., et al. (2024). "YOLOv9: Learning What You Want to Learn Using Programmable Gradient Information." arXiv preprint.
• Wang, A., et al. (2024). "YOLOv10: Real-Time End-to-End Object Detection." arXiv preprint.

İlgili Araştırma Alanları

• Lin, T.Y., et al. (2017). "Focal Loss for Dense Object Detection." ICCV 2017. (RetinaNet)
• Liu, W., et al. (2016). "SSD: Single Shot MultiBox Detector." ECCV 2016.
• Ren, S., et al. (2015). "Faster R-CNN: Towards Real-Time Object Detection." NIPS 2015.

Veri Setleri ve Benchmark

• Lin, T.Y., et al. (2014). "Microsoft COCO: Common Objects in Context." ECCV 2014.
• Everingham, M., et al. (2010). "The Pascal Visual Object Classes (VOC) Challenge." IJCV 2010.