Computer Vision Bootcamp

Bilgisayarlı Görü kurs içeriğinde CV olarak kısaltılacaktır.

Kurs CV'nin kapsamını, görüntülerin dijital olarak nasıl temsil edildiğini anlayın ve klasik teknikler kullanarak temel görüntü işleme ve özellik çıkarımı gerçekleştirin.

Bilgisayarlı görü (CV) Nedir?

• Tanım, Hedefler (Anlama, Yeniden Yapılandırma, Manipülasyon)
• Tarihsel Bağlam (Kısa: Marr'ın çerçevesinden Deep Learning'e)
• Anahtar Uygulama Alanları (Otonom Sürüş, Tıbbi Görüntüleme, AR/VR, Güvenlik, Robotik)

Dijital Görüntü Temsili:

• Yapı Taşları Olarak Pixels
• Görüntü Çözünürlüğü & En Boy Oranı
• Renk Uzayları: Grayscale, RGB, HSV, BGR (OpenCV varsayılanı)
• Görüntü Dosya Formatları (JPG, PNG, BMP, TIFF) - Sıkıştırma kavramları

Temel Görüntü Manipülasyonu:

• Pixel Erişimi ve Değiştirme
• Görüntü Kırpma, Yeniden Boyutlandırma (Interpolasyon yöntemleri: Nearest, Bilinear, Bicubic)
• Geometrik Dönüşümler: Öteleme (Translation), Döndürme (Rotation), Ölçekleme (Scaling), Affine, Perspective

Görüntü Filtreleme & İyileştirme:

• Kernels/Filters Kavramı
• Doğrusal Filtreleme: Bulanıklaştırma (Blurring - Ortalama, Gaussian), Keskinleştirme (Sharpening - Laplacian)
• Doğrusal Olmayan Filtreleme: Median Filter (Gürültü Azaltma)
• Histogram Eşitleme (Kontrast İyileştirme)

Özellik Çıkarımı (Klasik):

• Görüntü Özellikleri Kavramı (Kenarlar - Edges, Köşeler - Corners, Lekeler - Blobs)
• Kenar Tespiti: Sobel, Canny algoritmaları (Gradyan büyüklüğü/yönü, Non-maximum suppression, Hysteresis eşikleme)
• (Köşe Tespiti (Harris), Özellik Tanımlayıcılar (Feature Descriptors - SIFT, SURF - sadece kavram)
• Görüntüleri Yükleme, Gösterme, Kaydetme (OpenCV imread, imshow, imwrite, Matplotlib pyplot)
• Renk Uzaylarını Dönüştürme (OpenCV cvtColor)
• Pixel Değerlerine Erişme, Görüntüler Üzerinde Temel Aritmetik (NumPy)
• Dönüşümleri Uygulama (OpenCV resize, warpAffine, warpPerspective)
• Filtreleri Uygulama (OpenCV filter2D, GaussianBlur, medianBlur)
• Canny Kenar Detektörünü Uygulama (OpenCV Canny)

Görüntü İşleme Araç Seti (Lab 1)

• Hedef: Görüntüleri yüklemek, işlemek ve temel özellikleri çıkarmak için bir dizi fonksiyon uygulamak.
• Görevler:
  1. Bir görüntüyü yükleyin ve RGB, Grayscale ve HSV arasında dönüştürün. Sonuçları görüntüleyin.
  2. Farklı interpolasyon yöntemleriyle döndürme ve yeniden boyutlandırma için fonksiyonlar uygulayın. Çıktıları görsel olarak karşılaştırın.
  3. Değişen kernel boyutlarıyla Gaussian blur uygulayın ve yumuşatma etkisini gözlemleyin.
  4. Canny kenar tespitini uygulayın ve eşik parametreleriyle deney yapın.
  5. Birden fazla işlemi birleştirin (örneğin, yeniden boyutlandırma, bulanıklaştırma, ardından kenar tespiti).
• Teslim Edilecekler: Fonksiyonları ve görselleştirilmiş çıktıları içeren Python script/notebook.
• Araçlar: Python, OpenCV, NumPy, Matplotlib
• Veri Seti: Standart test görüntüleri (örneğin, Lena, Baboon) veya özel görüntüler.

Neural networks'ün temel kavramlarını, gradient descent yoluyla nasıl öğrendiklerini kavrayın ve PyTorch kullanarak temel bir eğitim pipeline'ı uygulayın.

Geleneksel ML'den Deep Learning'e:

• El ile Hazırlanmış Özelliklerin (Hand-crafted Features) Sınırlılıkları
• Temsil Öğrenme (Representation Learning)

Yapay Sinir Ağları (Artificial Neural Networks - ANNs):

• Neuron Modeli (Girdiler - Inputs, Ağırlıklar - Weights, Bias, Aktivasyon - Activation)
• Aktivasyon Fonksiyonları: Sigmoid, Tanh, ReLU (Özellikler, Artıları/Eksileri), GELU (Transformers'da kullanılır)
• İleri Beslemeli Ağlar (Feed-Forward Networks) (Katmanlar: Giriş - Input, Gizli - Hidden, Çıkış - Output)

Neural Networks Eğitimi:

• Kayıp Fonksiyonları (Loss Functions): Regresyon için Mean Squared Error (MSE), Sınıflandırma için Cross-Entropy Loss
• Optimizasyon Problemi: Optimal Ağırlıkları Bulma
• Gradient Descent: Kavram, Öğrenme Oranı (Learning Rate)
• Backpropagation: Gradyanların Verimli Bir Şekilde Nasıl Hesaplandığı
• Stochastic Gradient Descent (SGD) ve Mini-batches
• Optimize Ediciler (Optimizers): Momentum, RMSprop, Adam, AdamW (Uyarlanabilir Öğrenme Oranları - Adaptive Learning Rates)

Aşırı Öğrenme (Overfitting) ve Düzenlileştirme (Regularization):

• Bias-Varyans Dengesi (Bias-Variance Tradeoff)
• Overfitting Tespiti (Eğitim vs. Doğrulama Kaybı - Train vs. Validation Loss)
• Düzenlileştirme Teknikleri (Regularization Techniques): L1/L2 Weight Decay, Dropout
• Erken Durdurma (Early Stopping)

PyTorch'a Giriş:

• Tensors: Temel Veri Yapısı
• Otomatik Türev Alma (Automatic Differentiation - Autograd)
• Network Katmanlarını ve Modellerini Tanımlama (torch.nn.Module)
• Yaygın Katmanlar (torch.nn.Linear)
• PyTorch Tensors Oluşturma ve Manipüle Etme
• Gradyanları Hesaplamak için Autograd Kullanımı (tensor.backward())
• nn.Module ve nn.Linear kullanarak Basit bir FFN Model Yapısı Tanımlama
• Loss Functions (torch.nn.CrossEntropyLoss, torch.nn.MSELoss) ve Optimizers (torch.optim modülü: Adam, SGD, AdamW) Tanımlama
• Temel bir Eğitim Döngüsü (Training Loop) Uygulama (İleri geçiş - Forward pass, Kayıp hesaplama - Loss calculation, Gradyanları sıfırlama - Zero gradients, Geri geçiş - Backward pass (loss.backward()), Optimizer adımı (optimizer.step()))
• Eğitimi Print İfadeleri veya Temel Çizimlerle İzleme

İlk Neural Network'ünüz (Non-Vision) (Lab 2)

• Hedef: PyTorch kullanarak tablosal veya standart bir ML veri kümesinde sınıflandırma için basit bir FFN oluşturmak ve eğitmek.
• Görevler:
  1. Bir veri kümesi yükleyin (örneğin, Iris, Wine veya düzleştirilmiş MNIST). Gerekirse ön işleme yapın.
  2. PyTorch'un nn.Module'ünü kullanarak bir FFN mimarisi tanımlayın.
  3. Uygun loss function (torch.nn) ve optimizer (torch.optim) seçin.
  4. İleri/geri geçişleri ve ağırlık güncellemelerini içeren eğitim döngüsünü uygulayın.
  5. Veriyi eğitim ve doğrulama kümelerine ayırın.
  6. Modeli birkaç epoch boyunca eğitin, eğitim ve doğrulama kaybını/doğruluğunu izleyin.
  7. Son modeli ayrılmış bir test kümesinde değerlendirin.
• Teslim Edilecekler: Eğitilmiş modeli, eğitim grafiklerini ve değerlendirme sonuçlarını içeren Python script/notebook.
• Araçlar: Python, PyTorch, NumPy, Scikit-learn (veri ayırma/metrikler için)
• Veri Seti: MNIST, Iris, Wine veya benzeri görüntü olmayan veri kümesi.

CNN'lerin motivasyonunu ve mekanizmalarını anlayın, standart CNN mimarileri oluşturun ve bunları PyTorch kullanarak veri artırma (data augmentation) dahil ederek görüntü sınıflandırmaya uygulayın.

Neden Görüntü İşleme için CNN'ler?

• Parametre Paylaşımı & Bağlantıların Seyrekliği (Sparsity)
• Öteleme Eşvaryansı (Translation Equivariance) (ve Pooling yoluyla Değişmezlik - Invariance)
• Yüksek Boyutlu Görüntü Verilerini İşleme

Temel CNN Katmanları:

• Convolution Katmanı: Kernels/Filters, Feature Maps, Stride, Padding ('valid' vs 'same')
• Pooling Katmanı: Max Pooling, Average Pooling (Downsampling, Invariance)
• CNN'lerde Aktivasyon Fonksiyonları (ReLU yaygındır)

CNN Mimarileri Oluşturma:

• Tipik Yapı: CONV -> ACT -> POOL yığınları
• Alıcı Alan Boyutu (Receptive Field Size) Kavramı
• Mimarilerin Evrimi (Kısa): LeNet-5, AlexNet (Daha Derin, ReLU, Dropout)
• VGGNet (Daha küçük filtreler, Daha derin yığınlar)

Modern CNN Yenilikleri:

• Residual Networks (ResNet): Skip Connections, Identity Mapping, Kaybolan Gradyanları (Vanishing Gradients) Çözme
• ResNet'teki Bottleneck Blokları
• Batch Normalization: Eğitimi Stabilize Etme, Düzenlileştirme Etkisi
• (Kısa Bahsetme) Inception Networks (GoogLeNet), DenseNet

Görüntüler için Veri Artırma (Data Augmentation):

• Genelleme ve Veri Kıtlığı için Önemi
• Yaygın Teknikler: Döndürme (Yatay/Dikey), Rotasyon, Ölçekleme, Kırpma (Rastgele/Merkez), Öteleme (Kaydırma), Renk Değişimi (Parlaklık, Kontrast, Doygunluk, Ton), Gaussian Gürültüsü
• Gelişmiş Teknikler: Mixup, Cutmix, Random Erasing
• PyTorch'ta Convolution (nn.Conv2d) ve Pooling (nn.MaxPool2d, nn.AvgPool2d) Katmanlarını Uygulama
• Sıralı bir CNN Modeli Oluşturma (nn.Sequential)
• Skip Connections ile ResNet tarzı bir Model Oluşturma (nn.Module alt sınıflandırması)
• Data Augmentation için torchvision.transforms Kullanımı
• Bir torch.utils.data.Dataset ve torch.utils.data.DataLoader Kurulumu
• Standart PyTorch eğitim döngüsünü kullanarak Görüntü Sınıflandırma için bir CNN Eğitimi
• Metrikleri ve görüntüleri loglamak için Deney Takibi (Experiment Tracking - W&B/TensorBoard) Kullanımı

Görüntü Sınıflandırma için CNN (Lab 3)

• Hedef: PyTorch kullanarak standart bir benchmark veri kümesinden görüntüleri sınıflandırmak için bir CNN oluşturmak, eğitmek ve değerlendirmek.
• Görevler:
  1. torchvision.datasets kullanarak bir görüntü veri kümesini (örneğin, CIFAR-10, CIFAR-100, Fashion-MNIST) yükleyin ve ön işleyin.
  2. torchvision.transforms kullanarak sağlam bir data augmentation pipeline'ı uygulayın.
  3. PyTorch nn.Module kullanarak bir CNN mimarisi (örneğin, basitleştirilmiş bir ResNet veya VGG) oluşturun.
  4. Loss, optimizer ve DataLoader'lar ile eğitim döngüsünü kurun.
  5. Metrikleri, parametreleri ve örnek tahminleri loglamak için W&B veya TensorBoard'u entegre edin.
  6. Overfitting'i önlemek için doğrulama kümesindeki performansı izleyerek modeli eğitin (gerekirse early stopping kullanın).
  7. Son modeli test kümesinde değerlendirin, confusion matrix'i analiz edin.
• Teslim Edilecekler: Python script/notebook, eğitilmiş model ağırlıkları, W&B/TensorBoard panosuna bağlantı, değerlendirme raporu.
• Araçlar: Python, PyTorch, NumPy, Matplotlib, Scikit-learn, W&B/TensorBoard, torchvision.
• Veri Seti: CIFAR-10/100, Fashion-MNIST veya Imagenette/Imagewoof (torchvision.datasets veya Hugging Face datasets kullanarak).

Görüntü işlemede Transformer'lara yönelik paradigma kaymasını, ViT'lerin ve Swin Transformer'ların mimarisini ve ConvNeXt gibi modernize edilmiş CNN'lerin nasıl rekabet ettiğini anlayın. PyTorch kullanarak bu modelleri backbone olarak kullanmayı öğrenin.

CNN'lerin Sınırlılıkları Yeniden Değerlendirme:

• Sabit, Yerel Alıcı Alanlar (Receptive Fields)
• Uzun Menzilli Bağımlılıkları Modelleme Zorluğu

Transformer Mimarisi (Tekrar & Görüntü Odaklı):

• Self-Attention Mekanizması (Query, Key, Value, Scaled Dot-Product Attention)
• Multi-Head Self-Attention (MHSA)
• Transformer Encoder Bloğu (MHSA + Feed-Forward Network + Add & Norm)

Vision Transformer (ViT):

• Temel Kavram: Görüntüleri Patch Dizileri Olarak Görmek
• Patch Embedding (Linear Projection)
• Konumsal Kodlamalar (Positional Encodings - Öğrenilebilir vs. Sabit)
• Sınıflandırma için [CLS] Token
• Endüktif Yanlılık (Inductive Bias) vs. Veri İştahı (Büyük Ön Eğitim İhtiyacı)
• SOTA Performans Ölçeklemesi (ViT-G, ViT-H)
• Anahtar Varyantlar: DeiT (Veri-verimli eğitim, Distillation Token)

Hiyerarşik Vision Transformer'lar:

• Motivasyon: Çok Ölçekli Özelliklere İhtiyaç (Detection, Segmentation)
• Swin Transformer: Hiyerarşik Yapı (Patch Merging), Kaydırılmış Pencere MHSA (Shifted Window MHSA - Verimlilik, Pencereler Arası Bağlantı), Göreceli Konumsal Biaslar (Relative Positional Biases)
• Diğer Hiyerarşik Varyantlar (PVT - Pyramid Vision Transformer - kısa)

Modernize Edilmiş Convolutional Network'ler (ConvNeXt):

• Motivasyon: CNN'ler modern tasarımlar/eğitimlerle ViT'lerle eşleşebilir mi?
• ConvNeXt V1: ResNet'i Modernleştirme (Eğitim teknikleri, Swin'den ilham alan Makro/Mikro tasarım değişiklikleri - daha büyük kerneller, ters çevrilmiş bottleneck'ler, LN, GELU, daha az aktivasyon/norm)
• ConvNeXt V2: Self-Supervision ile Ortak Tasarım (FCMAE, Feature Collapse Problemi, GRN Katmanı)
• Performans & Karakteristikler (ViT'lerle rekabetçi, potansiyel verimlilik kazanımları)

Hibrit CNN-Transformer Modelleri:

• Gerekçe: Yerel Gücü (CNN) Küresel Bağlamla (Transformer) Birleştirme
• Entegrasyon Taksonomisi (Kısa genel bakış: Erken, Yanal, Sıralı, Paralel, Blok Entegrasyonu)
• Örnekler (Verimlilik için MobileViT, CMT, MaxViT)

Önceden Eğitilmiş Backbones Kullanımı:

• Foundational Models / Backbones Kavramı
• Model Hub'ları (timm (PyTorch Image Models), Hugging Face transformers)
• Önceden eğitilmiş ViT, Swin, ConvNeXt modellerini yükleme (timm, PyTorch için Hugging Face transformers)
• PyTorch'ta bu modellerle Inference yapma
• PyTorch'ta model mimarilerini (katmanlar, parametreler) inceleme
• PyTorch hooks kullanarak farklı katmanlardan/aşamadan ara özellikler çıkarma
• ViT'deki Attention Map'lerini görselleştirme (hooks veya PyTorch uyumlu kütüphaneler kullanarak)

SOTA Backbones ile Özellik Çıkarımı (Lab 4)

• Hedef: Önceden eğitilmiş SOTA modellerini (PyTorch versiyonları) kullanarak görüntülerden anlamlı özellikler çıkarmak ve temsil güçlerini karşılaştırmak.
• Görevler:
  1. Çeşitli bir görüntü seti seçin (örneğin, farklı nesneler, sahneler, stiller).
  2. ViT, Swin Transformer ve ConvNeXt için önceden eğitilmiş ağırlıkları yükleyin (PyTorch modelleri timm veya HF'den).
  3. Görüntüleri her modelden geçirin (evaluation modunda - model.eval()) ve son özellik vektörünü (örneğin, sınıflandırma başlığından önce) veya havuzlanmış çıktıyı çıkarın.
  4. Her backbone'dan gelen özellikleri kullanarak tüm görüntüler için özellik vektörleri arasındaki ikili cosine similarity'yi hesaplayın.
  5. Benzerlik matrislerini (heatmaps) görselleştirin.
  6. Analiz: Benzer görüntülerin benzerlik skorları daha mı yüksek? Backbonelar arasında farklılıklar var mı?
  7. (İsteğe bağlı) PyTorch hooks kullanarak ara katmanlardan özellikler çıkarın ve karşılaştırın.
• Teslim Edilecekler: Python script/notebook, benzerlik matrisleri görselleştirmeleri, sonuçların analizi.
• Araçlar: Python, PyTorch, timm, Hugging Face transformers, NumPy, Matplotlib/Seaborn.
• Veri Seti: Özel çeşitli görüntüler seti veya küçük etiketli bir veri kümesi.

Büyük önceden eğitilmiş PyTorch modellerini belirli sınıflandırma görevlerine uyarlamak için fine-tuning tekniklerinde ustalaşın, gelişmiş eğitim stratejilerini anlayın ve performansı titizlikle değerlendirin.

Transfer Learning Stratejileri:

• Motivasyon: Büyük veri kümelerinden (ImageNet, JFT) elde edilen bilgiden yararlanma
• Feature Extraction: Backbone'u sabit bir özellik çıkarıcı olarak kullanma, yeni bir sınıflandırıcı başlığı (classifier head) eğitme.
• Fine-tuning: Bazı/tüm backbone katmanlarını çözme (unfreeze) ve daha küçük bir learning rate ile uçtan uca (end-to-end) eğitme.
• Katman Bazında Öğrenme Oranı Azaltma (Layer-wise Learning Rate Decay)

Fine-tuning En İyi Uygulamaları:

• Doğru Backbone Seçimi
• Veri Kümesi Boyutu Hususları
• Learning Rate Seçimi (Backbone için daha düşük LR, başlık için daha yüksek)
• Learning Rate Schedulers (Cosine Annealing, Warmup)
• Optimizer Seçimi (Transformer'lar/modern eğitim için genellikle AdamW tercih edilir)
• Fine-tuning Sırasında Regularization

Gelişmiş Eğitim Teknikleri Tekrarı & Uygulaması:

• Fine-tuning bağlamında Mixup, Cutmix yeniden ziyaret
• Label Smoothing
• Stochastic Depth (ConvNeXt/Swin'de kullanılır)

Değerlendirme Metrikleri Derinlemesine Bakış:

• Accuracy sınırlamaları (Dengesiz veri kümeleri)
• Confusion Matrix Analizi
• Precision, Recall, F1-Score (Sınıf başına ve macro/micro/weighted ortalamalar)
• ROC Curve ve AUC (Area Under Curve)

Ön Eğitim için Self-Supervised Learning'e (SSL) Giriş:

• Kavram: Etiketlenmemiş verilerden pretext task'lar aracılığıyla öğrenme
• Contrastive Learning (SimCLR, MoCo - kısa fikir)
• Masked Image Modeling (MAE, BEiT - kısa fikir)
• Etki: SSL ön eğitiminin (örneğin, MAE ön eğitimli ViT, FCMAE ConvNeXt V2) fine-tuning için nasıl güçlü başlangıç noktaları sağladığı.
• Önceden eğitilmiş bir SOTA backbone'u (timm/HF for PyTorch) yükleme ve sınıflandırma başlığını değiştirme.
• Farklı fine-tuning stratejileri uygulama (katmanları dondurma/çözme - param.requires_grad = False/True ayarlayarak).
• Backbone ve başlık için farklı learning rate'ler ayarlama (optimizer parametre gruplarını kullanarak).
• Learning rate schedulers kullanma (torch.optim.lr_scheduler).
• Gelişmiş augmentation'ları ve label smoothing'i uygulama.
• Kapsamlı değerlendirme için scikit-learn veya torchmetrics kullanma.
• Detaylı metrikleri ve confusion matrix'leri W&B/TensorBoard'a loglama.

Özel Sınıflandırma için SOTA Modellerin Fine-tuning'i (Lab 5)

• Hedef: Belirli bir alt sınıflandırma görevinde bir SOTA önceden eğitilmiş PyTorch modelini (ViT, Swin, ConvNeXt) fine-tune etmek ve yüksek performans elde etmek.
• Görevler:
  1. İlgili bir görüntü sınıflandırma veri kümesi seçin (örneğin, Oxford Pets, Food-101, EuroSAT, tıbbi veri kümesi alt kümesi, alana özgü veri kümesi).
  2. Veri kümesini hazırlayın (train/val/test ayırmaları, Dataset/DataLoader).
  3. Önceden eğitilmiş bir PyTorch backbone seçin ve bir transfer learning stratejisi uygulayın (başlığı fine-tune etmekle başlayın, sonra daha fazla katmanı çözün).
  4. Uygun data augmentation, learning rate scheduling ve potansiyel olarak label smoothing uygulayın.
  5. Takip için W&B/TensorBoard kullanarak modeli eğitin. Hiperparametrelerle (LR, batch size, epochs, optimizer) deney yapın.
  6. torchmetrics veya scikit-learn kullanarak test kümesinde accuracy, precision, recall, F1-score ve confusion matrix ile titizlikle değerlendirin.
  7. Zaman kalırsa farklı fine-tuning stratejilerinden veya backbonelardan elde edilen sonuçları karşılaştırın.
• Teslim Edilecekler: Python script/notebook, fine-tune edilmiş model ağırlıkları, W&B/TensorBoard bağlantısı, stratejileri/sonuçları karşılaştıran detaylı değerlendirme raporu.
• Araçlar: Python, PyTorch, timm/HF transformers, NumPy, Scikit-learn/torchmetrics, W&B/TensorBoard, torchvision/HF datasets.
• Veri Seti: Belirli alt sınıflandırma veri kümesi (CIFAR'dan daha karmaşık).

Object detection görevini anlayın, baskın mimariler (tek aşamalı, iki aşamalı, Transformer tabanlı) hakkında bilgi edinin ve PyTorch kullanarak YOLOv8 ve DETR varyantları gibi SOTA detector'ları eğitme ve değerlendirme konusunda uygulamalı deneyim kazanın.

Görev Tanımı:

• Sınıflandırma + Konumlandırma (Bounding Boxes)
• Girdi/Çıktı Formatı (Görüntü -> [Kutu Koordinatları, Sınıf Etiketi, Güven Skoru] Listesi)

Temel Kavramlar & Metrikler:

• Bounding Box Temsilleri (xyxy, xywh)
• Intersection over Union (IoU)
• Değerlendirme Metrikleri: Average Precision (AP), mean Average Precision (mAP) - hesaplama inceliklerini açıklama (IoU eşikleri, PR eğrisi).

Object Detector'ların Evrimi:

• İki Aşamalı Detector'lar: R-CNN ailesi (R-CNN, Fast R-CNN, Faster R-CNN - Region Proposal Network - RPN)
• Tek Aşamalı Detector'lar: YOLO (You Only Look Once - Grid sistemi, doğrudan tahmin), SSD (Single Shot MultiBox Detector - Çok ölçekli özellikler), RetinaNet (Sınıf dengesizliği için Focal Loss)
• Anchor Boxes: Kavram, rol, sınırlamalar.

Transformer tabanlı Detector'lar (DETR & Varyantları):

• DETR: Doğrudan küme tahmini olarak Detection, Uçtan Uca (End-to-End - NMS/Anchors yok), CNN Backbone + Transformer Encoder-Decoder, Object Queries, Bipartite Matching Loss (Hungarian Algorithm)
• Zorluklar: Yavaş yakınsama, karmaşıklık.
• İyileştirmeler: Deformable DETR (Verimli attention), DINO (Geliştirilmiş denoising anchor boxes, daha iyi performans), Co-DETR (İşbirlikçi eğitim, daha zengin denetim için yardımcı başlıklar), RT-DETR (Gerçek zamanlı performans odaklı)

SOTA Modellerine Genel Bakış:

• YOLO Ailesi (YOLOv5, YOLOv7, YOLOv8 - hız/doğruluk dengesi için pratik SOTA, PyTorch tabanlı)
• DETR Varyantları (DINO, Co-DETR - genellikle doğruluk için lider tablolarda, tipik olarak PyTorch)
• EfficientDet (Ölçeklenebilir CNN tabanlı)

Open-Vocabulary Detection (OVD):

• Kavram: Eğitim sırasında görülmeyen sınıflardan nesneleri metin istemleri (text prompts) kullanarak tespit etme.
• Yöntemler (Kısa): Grounding DINO, OWL-ViT (CLIP gibi VLM'lerden yararlanma).
• YOLOv8 için ultralytics kütüphanesini kullanma (PyTorch backend): Kurulum, görüntüler/videolar üzerinde inference, komut satırı ve Python API ile eğitim/fine-tuning.
• PyTorch için Hugging Face transformers kullanarak DETR/RT-DETR: Modelleri yükleme, görüntüleri ön işleme, inference yapma, tahminleri çözme (kutular, etiketler).
• Bounding box'ları ve güven skorlarını görselleştirme (OpenCV).
• Veri kümesi formatlarını anlama (COCO JSON, YOLO TXT).
• Standart kütüphaneler/araçlar kullanarak model performansını değerlendirme (örneğin, pycocotools).

Bir Object Detector Eğitme ve Değerlendirme (Lab 6)

• Hedef: Özel bir veri kümesinde bir SOTA PyTorch object detector'ı (YOLOv8 veya RT-DETR) fine-tune etmek ve performansını değerlendirmek.
• Görevler:
  1. Bir object detection veri kümesi seçin (örneğin, COCO'nun bir alt kümesi, Pascal VOC veya termal görüntüleme, perakende ürünleri gibi özel bir veri kümesi). Doğru formatta olduğundan emin olun (veya dönüştürün).
  2. Bir detector modeli seçin (kullanım kolaylığı için YOLOv8 önerilir, Transformer tabanlıları keşfetmek için HF aracılığıyla RT-DETR).
  3. Seçilen kütüphaneyi (ultralytics veya HF transformers + accelerate, hepsi PyTorch tabanlı) kullanarak eğitim ortamını kurun.
  4. Önceden eğitilmiş modeli özel veri kümesinde fine-tune edin. Eğitimi W&B/TensorBoard ile izleyin.
  5. Eğitim parametreleriyle (epochs, batch size, learning rate, augmentation seviyeleri) deney yapın.
  6. Eğitilmiş modeli doğrulama/test kümesinde standart mAP metriği kullanarak değerlendirin.
  7. Örnek görüntüler/videolar üzerinde inference çalıştırın ve tespit edilen bounding box'ları görselleştirin.
• Teslim Edilecekler: Eğitim script'leri, fine-tune edilmiş model ağırlıkları, W&B/TensorBoard bağlantısı, değerlendirme sonuçları (mAP skorları), örnek inference görselleştirmeleri.
• Araçlar: Python, ultralytics veya Hugging Face (transformers, datasets), OpenCV, W&B/TensorBoard, PyTorch.
• Veri Seti: COCO alt kümesi, Pascal VOC, Global Wheat Detection, özel veri kümesi.

Farklı segmentation görevlerini anlayın, temel mimariler (FCN, U-Net, Mask R-CNN, Transformer tabanlı) hakkında bilgi edinin ve PyTorch kullanarak Segment Anything Model (SAM) dahil SOTA modelleri kullanın.

Görev Tanımları & Uygulamaları:

• Semantic Segmentation: Piksel seviyesinde sınıflandırma (Arka plan vs. Ön plan, yol, gökyüzü, araba gibi Çoklu Sınıflar).
• Instance Segmentation: Piksel seviyesinde sınıflandırma + örnekleri ayırt etme (Kişi 1 maskesi vs. Kişi 2 maskesi).
• Panoptic Segmentation: Birleşik görev - "eşyalar" (stuff - gökyüzü, yol) için semantic + "nesneler" (things - araba 1, kişi 2) için instance.

Değerlendirme Metrikleri:

• Semantic: Pixel Accuracy, Mean Intersection over Union (mIoU).
• Instance: Mask Average Precision (Mask AP - detection AP'ye benzer ancak maskeler üzerinde).
• Panoptic: Panoptic Quality (PQ = SQ * RQ).

Mimari Evrimi:

• Fully Convolutional Networks (FCNs): Piksel çıktısı için FC katmanlarını Conv'larla değiştirme. Upsampling stratejileri (Transpose Conv - nn.ConvTranspose2d, Bilinear Upsampling - nn.functional.interpolate).
• U-Net: Encoder-Decoder yapısı, Skip Connections (detay koruması için kritik), tıbbi görüntülemede baskın.
• DeepLab Ailesi: Atrous (Dilated) Convolutions (downsampling olmadan daha büyük receptive field), Atrous Spatial Pyramid Pooling (ASPP - çok ölçekli bağlam).
• Instance Segmentation: Mask R-CNN (Faster R-CNN'i bir maske tahmin başlığı ile genişletir).

Transformer tabanlı Segmentation:

• Motivasyon: Küresel bağlamdan yararlanma.
• Mask Classification Paradigması: MaskFormer (Bir dizi maske + sınıf tahmini), Mask2Former (Masked attention ile geliştirilmiş).
• Birleşik Çerçeveler: Mask DINO (DINO detector'ını maske başlığı ile genişletir, SOTA birleşik performans). ONE-PEACE, BEiT-3. (Genellikle PyTorch implementasyonları)

Segmentation için Foundation Modeller:

• Segment Anything Model (SAM): Mimariye genel bakış (ViT Encoder, Prompt Encoder, Mask Decoder), SA-1B veri kümesinde eğitim, Promptable Segmentation (Noktalar, Kutular, Metin), Zero-Shot Genelleme. (PyTorch implementasyonu)
• SAM Kullanımı: Güçlü ve zayıf yönleri (örneğin, sınıf-agnostik, detay seviyesi). SAM'i Fine-tune etme (MedSAM).

Open-Vocabulary Segmentation:

• Kavram: Rastgele metin açıklamalarına dayalı segmentasyon.
• Yöntemler (Kısa): ODISE (Diffusion + CLIP kullanarak), SAM'i VLM'lerle birleştirme.
• Önceden eğitilmiş semantic segmentation modellerini kullanma (örneğin, torchvision.models.segmentation'dan DeepLabv3, U-Net).
• Önceden eğitilmiş instance segmentation modellerini kullanma (örneğin, torchvision.models.detection'dan Mask R-CNN).
• Hugging Face transformers for PyTorch veya Detectron2 (PyTorch tabanlı) aracılığıyla Mask2Former/Mask DINO kullanma.
• Resmi PyTorch kodu veya HF implementasyonu kullanarak Segment Anything Model (SAM) ile etkileşim: Modelleri yükleme, prompt'lar oluşturma (noktalar, kutular), maskeler oluşturma.
• Segmentation maskelerini görselleştirme (görüntülerin üzerine bindirme).
• Kütüphaneler kullanarak mIoU hesaplama (örneğin, torchmetrics).

Semantic & Promptable Segmentation (Lab 7)

• Hedef: Semantic segmentation için önceden eğitilmiş PyTorch modellerini uygulamak ve Segment Anything Model'in (SAM) yeteneklerini denemek.
• Görevler:
  1. Önceden eğitilmiş bir semantic segmentation modeli yükleyin (örneğin, torchvision'dan DeepLabv3+). Örnek görüntülerde (örneğin, Cityscapes demo, ADE20K demo veya özel) inference çalıştırın ve tahmin edilen sınıf maskelerini görselleştirin.
  2. (İsteğe bağlı) Semantic segmentation modelini küçük bir doğrulama kümesinde mIoU metriğini (torchmetrics) kullanarak değerlendirin.
  3. PyTorch implementasyonunu kullanarak Segment Anything Model'i (SAM) kurun.
  4. Farklı görüntüler üzerinde çeşitli prompt'larla SAM'i kullanın:
     • Tek nokta prompt'ları.
     • Çoklu nokta prompt'ları (ön plan/arka plan).
     • Bounding box prompt'ları.
     • (Metin-prompt varyantı kullanılıyorsa) Metin prompt'ları.
     • Otomatik maske oluşturma (prompt yok).
  5. Farklı prompt'lar için SAM tarafından oluşturulan maskeleri görselleştirin ve etkinliğini ve sınırlamalarını analiz edin (örneğin, nesne sınırları, çoklu nesneler, belirsizlik).
  6. (Bonus) Küçük bir özel veri kümesinde bir semantic segmentation modelini PyTorch kullanarak fine-tune etmeyi deneyin.
• Teslim Edilecekler: Inference sonuçları ile Python script/notebook, semantic maskelerin ve çeşitli prompt'lar için SAM tarafından oluşturulan maskelerin görselleştirmeleri, SAM'in davranışının analizi.
• Araçlar: Python, PyTorch, torchvision/HF transformers/Detectron2, segment-anything kütüphanesi, OpenCV, Matplotlib, torchmetrics.
• Veri Seti: Standart veri kümelerinden demo görüntüler (Cityscapes, ADE20K, COCO) veya özel görüntüler. İsteğe bağlı olarak, fine-tuning için küçük etiketli bir semantic segmentation veri kümesi.

Mini Proje 1: Entegre Görüntü İşleme Sistemi (Hafta 8-9)

• Hedef: PyTorch modellerini kullanarak detection ve segmentation/classification becerilerini birleştirmek.
• Örnek Görev: Bir görüntüdeki nesneleri tespit eden (örneğin, YOLOv8 kullanarak arabalar, yayalar) ve ardından bir özelliği sınıflandıran (örneğin, fine-tune edilmiş bir classifier kullanarak araba rengi) veya tespit edilen nesneyi SAM veya fine-tune edilmiş bir segmentation modeli kullanarak hassas bir şekilde segmente eden bir sistem oluşturun.
• Odak: Pipeline oluşturma, model entegrasyonu, bir aşamanın çıktılarının bir PyTorch ekosistemi içinde bir sonraki aşamaya girdi olarak işlenmesi.

Video verilerinin zorluklarını anlayın ve action recognition, object tracking ve temporal reasoning için SOTA tekniklerini, öncelikle PyTorch çerçevelerini kullanarak öğrenin.

Video Verilerinin Zorlukları:

• Zamansal Boyut, Hareket Bilgisi
• Hesaplama Maliyeti (Frame'leri İşleme)
• Veri Hacmi

Action Recognition / Classification:

• Görev Tanımı: Kırpılmış video kliplerindeki eylemleri sınıflandırma.
• Evrim: 2D CNN'ler (frame pooling), 3D CNN'ler (C3D, I3D - spatio-temporal kerneller), SlowFast Networks (mekansal/zamansal için iki yol), Video Transformers (ViViT, TimeSformer - faktörlenmiş attention), VideoMAE (SSL ön eğitimi). (Çoğu SOTA PyTorch'tur)
• Temporal Action Localization (TAL): Başlangıç/bitiş zamanlarını bulma (ActionFormer).
• Benchmarklar (Kinetics, Something-Something, EPIC-Kitchens, Ego4D).

Video Object Tracking:

• Görev Tanımı: Nesneleri zaman içinde takip etme (Single Object Tracking - SOT, Multi-Object Tracking - MOT).
• Klasik Yaklaşımlar (Kısa): Correlation Filters.
• Deep Learning Yaklaşımları: Siamese Networks (SiamRPN, SiamMask), Transformer tabanlı tracker'lar (TransT). (Genellikle PyTorch)
• SOTA Eğilimleri: Video Seviyesi Bağlamını Birleştirme (MCITrack - Mamba), Çok Modlu Takip (RGB+Derinlik/Termal/Olaylar - Un-Track, SUTrack - birleşik çerçeveler).
• Benchmarklar (LaSOT, GOT-10k, TrackingNet, MOTChallenge).

Videolarda Temporal Reasoning:

• Daha Yüksek Seviyeli Anlama (Sıra, Süre, Nedensellik).
• Görevler: Video Question Answering (VideoQA), Video Grounding (Metinden-An'a), Özetleme.
• Baskın Yaklaşım: Video Large Language Models (Vid-LLMs) - Video Encoder'ları LLM'lerle entegre etme. (Çoğu açık model PyTorch kullanır)
• Teknikler: Dynamic Prompting (TSADP), Zamansal Tutarlılığı Modelleme (T3T), Yapıyı Entegre Etme (Video-of-Thought - VoT), Tercih Öğrenimi (Preference Learning - TEMPLE).
• Benchmarklar (TemporalVQA, NExTQA, REXTINE).
• Önceden eğitilmiş Action Recognition modellerini kullanma (örneğin, PyTorchVideo, PyTorch için HF transformers, MMAction2 (PyTorch) aracılığıyla VideoMAE, SlowFast). Video klipler üzerinde inference yapma.
• Önceden eğitilmiş SOT tracker'larını kullanma (örneğin, pysot kütüphanesinden, Stark, TransT implementasyonları - PyTorch versiyonlarını kontrol edin). Bir sekans üzerinde tracking çalıştırma.
• (Kavramsal) Bir Vid-LLM'nin VideoQA için nasıl kullanılabileceğine genel bakış (Video-LLaVA (PyTorch) gibi kütüphaneler kullanarak veya API çağrılarını göstererek).
• Video yükleme ve işleme için kütüphaneler (decord, OpenCV VideoCapture, PyTorchVideo).

Action Recognition & Tracking Temelleri (Lab 8)

• Hedef: Video kliplerinde eylem sınıflandırması yapmak ve video sekanslarında nesneleri takip etmek için önceden eğitilmiş PyTorch modellerini kullanmak.
• Görevler:
  1. Önceden eğitilmiş bir action recognition modeli yükleyin (örneğin, HF/PyTorchVideo'dan VideoMAE veya TimeSformer - PyTorch tabanlı).
  2. Farklı eylemleri temsil eden örnek video klipler indirin (örneğin, Kinetics veri kümesi örneklerinden).
  3. Video kliplerini PyTorch modelinin gerektirdiği şekilde ön işleyin (frame'leri örnekleme, normalizasyon).
  4. Inference yapın ve kliplerdeki eylemleri sınıflandırın.
  5. Önceden eğitilmiş bir Single Object Tracker yükleyin (standart bir kütüphaneden veya GitHub reposundan bir PyTorch implementasyonu bulun).
  6. Takip edilecek net bir nesnesi olan bir video sekansı seçin. İlk frame'de hedef nesne için başlangıç bounding box'ını tanımlayın.
  7. Tracker'ı sekans üzerinde çalıştırın ve takip edilen bounding box'ı video frame'lerinin üzerine bindirilmiş olarak görselleştirin.
  8. Tracking'i niteliksel olarak değerlendirin: Nesneyi doğru takip ediyor mu? Ne zaman başarısız oluyor?
• Teslim Edilecekler: Action classification ve tracking için Python script/notebook, tracking sonuçlarının görselleştirilmesi.
• Araçlar: Python, PyTorch, Hugging Face/PyTorchVideo/MMAction2, OpenCV, decord, Tracking kütüphanesi (PyTorch uyumlu).
• Veri Seti: Örnek eylem klipleri (Kinetics, UCF101 örnekleri), standart tracking sekansları (örneğin, VOT benchmark web sitesinden).

Farklı 3D veri temsillerini anlayın, 3D reconstruction, point cloud analizi ve novel view synthesis (NeRF/Gaussian Splatting) için SOTA tekniklerini, PyTorch implementasyonlarına odaklanarak öğrenin.

3D Vision'a Giriş:

• Önem (Robotik, AV, VR/AR, Tıbbi)
• Zorluklar (Veri Toplama, Temsil Çeşitliliği, Hesaplama Maliyeti)

3D Temsilleri:

• Meshes (Vertices, Faces), Voxels (Gridler), Point Clouds (Sırasız Kümeler), Implicit Functions (SDF, Occupancy), Radiance Fields.

3D Reconstruction:

• Hedef: Sensör verilerinden (Görüntüler, Derinlik) 3D modeller oluşturma.
• Klasik Yöntemler (Kısa: Structure from Motion - SfM, Multi-View Stereo - MVS).
• Neural Implicit Surfaces: DeepSDF, VolSDF, NeuS (Implicit function'ları görüntü tabanlı recon için volume rendering ile birleştirme). Instant-NGP, Neuralangelo (Daha Hızlı/Yüksek Kalite). (Genellikle PyTorch)
• Gaussian Splatting (3DGS): Açık temsil (3D Gaussians), Hızlı eğitim/rendering, SOTA kalitesi. (Resmi olan PyTorch)
• 3D Recon için Diffusion Modelleri (CDM - Conditional Diffusion).

Point Cloud Analizi:

• Point Cloud Özellikleri (Sırasız, Değişken Yoğunluk).
• Öncü Mimariler: PointNet (Permütasyon Değişmezliği için Simetrik Fonksiyonlar kullanarak), PointNet++ (Hiyerarşik özellik öğrenme).
• Gelişmiş Mimariler: Graph CNNs, Point Transformers (Point-BERT, Point-MAE), Mamba3D. (Çoğu araştırma PyTorch kullanır)
• Görevler: Sınıflandırma (ModelNet), Parça/Semantic Segmentation (ShapeNetPart, S3DIS, ScanNet), Detection.
• Point Cloud'lar için SSL: Contrastive (PointContrast), Masked Reconstruction (Point-MAE), Geometrik Kısayol Problemi (Geometric Shortcut Problem - Sonata).

Novel View Synthesis (NeRF Odaklı):

• Neural Radiance Fields (NeRF): Temel Kavram (5D koordinatları yoğunluk/renge eşleyen MLP), Volume Rendering Denklemi, Positional Encoding. (Birçok PyTorch implementasyonu)
• Gelişmeler: Verimlilik (Instant-NGP, Plenoxels), Gerçekçilik (Mip-NeRF, Ref-NeRF), Dinamik Sahneler (D-NeRF), Büyük Sahneler (Block-NeRF), NeRF'leri Düzenleme.
• Karşılaştırma: NeRF vs. Gaussian Splatting (Implicit vs. Explicit, Hız vs. Bellek).

3D Sahne Anlama:

• Hedef: Bütünsel Yorumlama (Nesneler, İlişkiler, Semantik).
• Görevler: 3D Semantic/Instance Segmentation, 3D Object Detection, 3D Scene Question Answering (3D SQA - ScanQA), Visual Grounding.
• Point cloud'ları yükleme ve görselleştirme (Open3D kütüphanesi, PyTorch tensor'ları ile çalışır).
• Sınıflandırma veya segmentation için önceden eğitilmiş bir PointNet/PointNet++ modeli kullanma (örneğin, PyTorch Geometric veya model zoo'ları aracılığıyla).
• (Kavramsal) Mevcut kütüphaneleri kullanarak basit bir NeRF veya Gaussian Splatting eğitimini kurma ve çalıştırma (örneğin, nerfstudio (PyTorch), resmi 3DGS repo (PyTorch)) - kullanıma odaklanma.
• Novel view'lar renderlamak için önceden eğitilmiş bir NeRF/3DGS modeli ile inference yapma.
• Temel point cloud işleme için Open3D kullanma (downsampling, registration - kısa).

Point Cloud Classification & Novel View Synthesis (Lab 9)

• Hedef: PyTorch modellerini kullanarak point cloud olarak temsil edilen 3D nesneleri sınıflandırmak ve önceden eğitilmiş bir NeRF veya 3DGS modelinden (PyTorch tabanlı) novel view'lar renderlamak.
• Görevler:
  1. Standart bir veri kümesinden (örneğin, ModelNet10/40) point cloud verilerini yükleyin.
  2. Open3D kullanarak örnek point cloud'ları görselleştirin.
  3. Önceden eğitilmiş bir point cloud sınıflandırma modeli yükleyin (örneğin, PyTorch Geometric'te implemente edilmiş PointNet++).
  4. Point cloud verilerini PyTorch modelinin gerektirdiği şekilde ön işleyin.
  5. Point cloud nesnelerini sınıflandırmak için inference yapın. Test kümesinde accuracy'yi değerlendirin.
  6. Örnek bir sahne için önceden eğitilmiş NeRF veya Gaussian Splatting verilerini indirin (örneğin, nerfstudio demolarından veya 3DGS örneklerinden).
  7. Önceden eğitilmiş modeli yüklemek için ilgili kütüphaneyi/görüntüleyiciyi (muhtemelen PyTorch tabanlı) kullanın.
  8. Sanal kamera pozunu interaktif olarak değiştirerek veya bir kamera yörüngesi tanımlayarak sahnenin novel view'larını renderlayın.
  9. Sentezlenen görüntülerin kalitesini ve gerçekçiliğini gözlemleyin.
• Teslim Edilecekler: Point cloud sınıflandırması için Python script/notebook, değerlendirme sonuçları, NeRF/3DGS'den renderlanmış novel view'ların ekran görüntüleri/videosu.
• Araçlar: Python, PyTorch, Open3D, PyTorch Geometric (isteğe bağlı), NeRF/3DGS kütüphanesi (nerfstudio, gaussian-splatting - PyTorch tabanlı).
• Veri Seti: ModelNet10/40, Önceden eğitilmiş NeRF/3DGS sahne verileri.

Diffusion Modelleri ve GAN'ların ardındaki prensipleri anlayın ve PyTorch kütüphanelerini kullanarak text-to-image generation ve temel image editing için SOTA modelleri kullanma deneyimi kazanın.

Generative Modeling Hedefleri: Veri dağılımlarını öğrenme, yeni örnekler sentezleme.

Generative Adversarial Networks (GANs):

• Temel Kavram: Generator vs. Discriminator min-max oyunu.
• Eğitim Dinamikleri & Zorluklar (Mode Collapse, Stabilite).
• Gelişmiş Mimariler (Kısa): StyleGAN (Style-based generator, ADA - Resmi olan PyTorch), Conditional GANs (cGAN).
• Artıları/Eksileri: Hızlı örnekleme, belirli alanlar (yüzler) için iyi, genellikle diffusion'dan daha zor eğitilir/kontrol edilir.

Diffusion Probabilistic Modeller:

• Temel Kavram: İleri Süreç (gürültü ekleme), Ters Süreç (gürültüyü gidermeyi öğrenme).
• Anahtar Formülasyonlar: DDPM, Score-Based Models (SGM/SDE).
• Denoising Network Mimarisi: U-Net (yaygın), Diffusion Transformers (DiTs - Sora, SD3 - ölçeklenebilirlik).
• Koşullandırma (Conditioning): Metin (CLIP/T5 embeddings), Sınıf Etiketleri, Görüntüler.
• Guidance: Classifier-Free Guidance (CFG - örnek kalitesini/bağlılığını iyileştirme), Model-guidance (MG).
• Latent Diffusion Models (LDMs - Stable Diffusion): Sıkıştırılmış latent uzayda (VAE) Diffusion. (Stable Diffusion PyTorch kullanır)

Anahtar Uygulamalar & SOTA Modeller:

• Text-to-Image (T2I): Stable Diffusion, DALL-E 3, Midjourney, Imagen, SD3, PixArt. (Birçok açık model/kütüphane PyTorch'tur)
• Video Generation: Sora, Latte, DDT (DiT'leri kullanarak).
• Image Editing/Translation: Inpainting (RePaint), Talimat tabanlı düzenleme (InstructPix2Pix), Style Transfer, Diffusion kullanarak Super-Resolution. ControlNet (mekansal kontrol ekleme). (PyTorch implementasyonları mevcut).

Verimlilik Zorlukları & Çözümleri:

• Yavaş Örnekleme (Çok adım): Daha hızlı çözücüler (DDIM), Distillation (Progressive Distillation), Latent Space.
• Eğitim Maliyeti.
• Hugging Face diffusers kütüphanesini kullanma (PyTorch öncelikli):
  • Önceden eğitilmiş Diffusion pipeline'larını yükleme (Stable Diffusion).
  • Metin prompt'larından görüntüler üretme (T2I).
  • Parametreleri keşfetme (guidance scale, steps, negative prompts).
  • Temel image editing görevlerini gerçekleştirme (örneğin, bir prompt kullanarak image-to-image, bir maske ile inpainting).
  • Conditioning input'ları ile ControlNet pipeline'larını kullanma (örneğin, Canny kenarları, poz).
• (İsteğe bağlı) Temel GAN kullanımı (resmi PyTorch reposundan veya diğer kütüphanelerden önceden eğitilmiş StyleGAN yükleme). Örnekler üretme, latent space interpolasyonunu keşfetme.

Text-to-Image Generation & Kontrol (Lab 10)

• Hedef: Metin prompt'larından görüntüler üretmek için Stable Diffusion'ı (diffusers aracılığıyla PyTorch tabanlı) kullanmak ve ControlNet kullanarak generation üzerinde kontrol sağlamak.
• Görevler:
  1. Hugging Face diffusers kütüphanesini kurun.
  2. Bir Stable Diffusion pipeline'ı yükleyin (örneğin, SD 1.5, SD 2.1, SDXL).
  3. Çeşitli metin prompt'ları kullanarak görüntüler üretin. Prompt engineering ile deney yapın (detaylar, stil anahtar kelimeleri).
  4. guidance_scale ve num_inference_steps etkisini keşfedin. Negative prompt'lar kullanın.
  5. Bir görüntü ve karşılık gelen bir conditioning map seçin (örneğin, Canny edge map, insan pozu iskeleti).
  6. Seçilen Stable Diffusion temel modeli ve conditioning tipi ile uyumlu bir ControlNet pipeline'ı yükleyin (PyTorch ağırlıkları).
  7. ControlNet pipeline'ını kullanarak, metin prompt'unu ve conditioning map'i sağlayarak görüntüler üretin. Çıktının kontrol sinyaline nasıl uyduğunu gözlemleyin.
  8. (Bonus) Birden fazla ControlNet aktifken görüntüler üretmeyi deneyin.
• Teslim Edilecekler: Python script/notebook, üretilen görüntüler (T2I ve ControlNet'ten), kontrol ile/olmadan çıktıların karşılaştırılması, parametre etkilerinin analizi.
• Araçlar: Python, Hugging Face diffusers, transformers, accelerate, OpenCV (conditioning map'leri oluşturmak için), PyTorch.
• Veri Seti: Yok (generative görev). Conditioning map'leri örnek görüntülerden üretilebilir.

Self-Supervised Learning (SSL), Contrastive Learning, Multimodal Learning (Vision-Language Models) ve Few/Zero-Shot Learning'in ardındaki motivasyonu ve mekanizmaları, PyTorch araçlarına ve kütüphanelerine odaklanarak anlayın.

Self-Supervised Learning (SSL) Yeniden Değerlendirme:

• Motivasyon: Etiket bağımlılığını azaltma, etiketlenmemiş verilerden yararlanma, genel temsiller öğrenme.
• Taksonomi İncelemesi: Contrastive, Masked Modeling, Non-Contrastive, Clustering.
• SOTA Modellerinin Ön Eğitimine Etkisi.

Contrastive Learning Derinlemesine Bakış:

• Temel Fikir: Embedding uzayında pozitifleri birbirine yaklaştırma, negatifleri birbirinden uzaklaştırma.
• Bileşenler: Anchor/Positive/Negative örnekleri, Encoder, Projection Head, Contrastive Loss (InfoNCE), Data Augmentation.
• Öncü Yöntemler: SimCLR, MoCo (Momentum Encoder, Queue), BYOL (Negatif yok, asimetrik mimari), SwAV (Online Clustering). (Birçok PyTorch implementasyonu)
• Metric Learning ile İlişkisi.

Multimodal Learning (Vision-Language Odaklı):

• Motivasyon: Modaliteleri birleştirerek daha zengin anlama.
• Anahtar Yaklaşımlar:
  • Contrastive Ön Eğitim: CLIP, ALIGN (Ortak embedding uzayı, Zero-shot yetenekleri). (OpenCLIP PyTorch'tur)
  • Fusion Encoders (Kısa bahsetme).
  • Vision Encoders + LLMs (Baskın Eğilim): LLaVA, MiniGPT-4, BLIP-2, Flamingo, GPT-4V, Gemini. Mimari (Vision Encoder -> Adapter -> LLM). Eğitim (Alignment Ön Eğitimi + Instruction Tuning). (Çoğu açık kaynak VLM PyTorch'tur)
• Uygulamalar: VQA, Captioning, Retrieval, Reasoning, Embodied AI (VLA).
• Zorluklar: Alignment, Hallucination, Değerlendirme, Veri.

Few-Shot Learning (FSL):

• Motivasyon: Çok az etiketli örnekten öğrenme (K-shot, N-way).
• Episodic Training Çerçevesi (Support set, Query set).
• Yaklaşımlar: Metric Learning (Prototypical Networks), Optimizasyon Tabanlı (MAML), Generative Yaklaşımlar. (FSL için PyTorch kütüphaneleri mevcuttur).

Zero-Shot Learning (ZSL):

• Motivasyon: Etiketli örneği olmayan sınıfları tanıma.
• Klasik Yaklaşımlar (Öznitelik tabanlı, Word embeddings).
• VLM Destekli ZSL: Görüntü ve metin sınıf açıklamaları için CLIP/ALIGN embedding'lerini kullanma. Prompt Engineering/Tuning (TPT). VLM özellikleri üzerinde Reasoning (CHBR).
• Uygulamalar: Open-Vocabulary Detection/Segmentation.
• CLIP Kullanımı (PyTorch için Hugging Face transformers veya OpenCLIP): Model yükleme, görüntü ve metin embedding'lerini alma, zero-shot sınıflandırma için benzerlik hesaplama.
• Önceden eğitilmiş bir VLM kullanma (örneğin, HF transformers for PyTorch veya özel PyTorch kütüphaneleri aracılığıyla LLaVA, BLIP): Visual Question Answering (VQA) ve Image Captioning yapma.
• (Kavramsal) Prototypical Networks'ün PyTorch kullanarak Few-Shot Learning için nasıl çalıştığı.
• (Kavramsal) lightly veya PyTorch Lightning Bolts gibi PyTorch kütüphanelerini kullanarak bir contrastive learning pipeline'ı kurma (bileşenlere odaklanma).

Zero-Shot Classification & VQA ile VLM'ler (Lab 11)

• Hedef: Zero-shot görüntü sınıflandırması için CLIP (PyTorch versiyonu) uygulamak ve VQA için bir Large Vision-Language Model (LVLM) (PyTorch tabanlı) kullanmak.
• Görevler:
  1. Sınıfların metinsel olarak tanımlanabildiği bir sınıflandırma veri kümesi seçin (örneğin, CIFAR-10/100, Caltech-101).
  2. Önceden eğitilmiş bir CLIP modeli yükleyin (HF veya OpenCLIP aracılığıyla PyTorch versiyonu).
  3. Test kümesinden bir görüntü alt kümesi için:
     • Görüntü embedding'ini alın.
     • Tüm olası sınıflar için metin prompt'ları oluşturun (örneğin, "a photo of a [sınıf adı]").
     • Tüm sınıf prompt'ları için metin embedding'lerini alın.
     • Görüntü embedding'i ile tüm metin embedding'leri arasındaki cosine similarity'yi hesaplayın.
     • En yüksek benzerliğe sahip sınıfı tahmin edin.
  4. Zero-shot sınıflandırma accuracy'sini hesaplayın. Rastgele şansla karşılaştırın.
  5. VQA yapabilen önceden eğitilmiş bir LVLM yükleyin (örneğin, HF for PyTorch aracılığıyla BLIP-2, LLaVA).
  6. Birkaç farklı görüntü seçin.
  7. Her görüntü için 3-5 farklı soru sorun (örneğin, "Merkezde hangi nesne var?", "Kaç kişi var?", "Arabanın rengi ne?").
  8. Görüntüyü ve soruyu LVLM'ye verin ve üretilen cevabı kaydedin.
  9. VQA performansını niteliksel olarak değerlendirin: Cevaplar ilgili, doğru, detaylı mı? Hallucination'ları not edin.
• Teslim Edilecekler: Python script/notebook, zero-shot accuracy sonuçları, VQA görüntü/soru/cevap çiftleri, VQA performansının niteliksel analizi.
• Araçlar: Python, PyTorch, Hugging Face transformers, datasets, OpenCLIP (isteğe bağlı).
• Veri Seti: Standart sınıflandırma veri kümesi (CIFAR, Caltech-101), VQA için çeşitli görüntüler seti.

Mini Proje 2: Yaratıcı veya Analitik Görev (Hafta 12-13)

• Hedef: Generative modellerden veya multimodal learning'den PyTorch araçlarını kullanarak beceriler uygulamak.
• Örnek Görevler:
  • Yaratıcı: Yönlendirilmiş görüntü oluşturma için Stable Diffusion (diffusers - PyTorch) + ControlNet kullanarak bir Gradio uygulaması oluşturun (örneğin, eskizleri fotoğraflara dönüştürme).
  • Analitik: Metin sorgularına dayalı görüntü retrieval yapmak veya bir veri kümesinde görsel olarak benzer görüntüleri bulmak için CLIP embedding'lerini (PyTorch) kullanın.
  • VLM: Bir görüntü alan ve otomatik olarak detaylı bir açıklama üreten ve bunun hakkında önceden tanımlanmış soruları bir PyTorch VLM kullanarak yanıtlayan basit bir araç oluşturun.

Eğitilmiş PyTorch modellerini daha küçük, daha hızlı ve çeşitli platformlarda gerçek dünya dağıtımı için uygun hale getirme tekniklerini öğrenin.

Verimlilik İhtiyacı: Gecikme (Latency), Verim (Throughput), Bellek kısıtlamaları (Edge/Mobil), Güç Tüketimi, Maliyet.

Model Sıkıştırma Teknikleri:

• Quantization: Sayısal hassasiyeti azaltma (FP32 -> FP16/INT8/INT4). PyTorch yerleşik araçları (PTQ, QAT), ONNX Runtime quantization. Donanım desteği (CPU, GPU, TPU'lar, NPU'lar).
• Pruning: Gereksiz ağırlıkları/nöronları/kanalları/katmanları kaldırma. PyTorch torch.nn.utils.prune. Yapılandırılmamış (Unstructured) vs. Yapılandırılmış (Structured) Pruning. Magnitude Pruning, Lottery Ticket Hypothesis kavramı.
• Knowledge Distillation: Daha küçük bir "öğrenci" (student) modelini, daha büyük bir "öğretmen" (teacher) modelinin çıktılarını (logits/features) PyTorch içinde taklit etmek üzere eğitme.
• Neural Architecture Search (NAS): Verimli mimari tasarımını otomatikleştirme (Kısa: MobileNetV3, EfficientNet). Low-Rank Factorization.

Optimize Edilmiş Inference:

• Inference Engines/Runtimes: ONNX Runtime, TensorRT (NVIDIA), OpenVINO (Intel), PyTorch Mobile, Core ML (Apple).
• Graf Optimizasyonları: Layer Fusion, Constant Folding (genellikle runtimelar/export tarafından yapılır).
• Batching & Caching.

Dağıtım Stratejileri:

• Bulut Dağıtımı (Serverless fonksiyonlar, GPU'lu VM'ler, Yönetilen ML Servisleri - SageMaker, Vertex AI). API tasarımı (REST).
• Edge Dağıtımı (Mobil cihazlar, Gömülü sistemler - Raspberry Pi, Jetson Nano). Dikkat Edilmesi Gerekenler: Güç, bağlantı, model boyutu. ONNX Runtime veya PyTorch Mobile kullanın.
• Web Dağıtımı (ONNX.js, WebAssembly kullanarak).
• Konteynerleştirme (Docker): Modelleri ve bağımlılıkları paketleme.
• Üretimde İzleme ve Bakım.
• Bir PyTorch modelini ONNX formatına dönüştürme (torch.onnx.export).
• Python'da ONNX Runtime kullanarak inference yapma.
• PyTorch'un yerleşik araçlarını veya ONNX Runtime'ı kullanarak temel Post-Training Quantization uygulama. Hızı/boyutu karşılaştırma.
• (Kavramsal) TensorRT/OpenVINO optimizasyon sürecine genel bakış (genellikle ONNX'ten başlar).
• Eğitilmiş bir CV modeli için hızlıca bir web demo arayüzü oluşturmak üzere Gradio kütüphanesini kullanma (PyTorch veya ONNX yükleyebilir).
• Bir CV model API'si için basit bir Docker konteyneri oluşturma (PyTorch veya ONNX modelini sunmak için Flask/FastAPI kullanarak).

Bir Modeli Optimize Etme ve Dağıtma (Lab 12)

• Hedef: Eğitilmiş bir PyTorch CV modelini (örneğin, Lab 5 veya 6'dan) quantization kullanarak optimize etmek ve basit bir web servisi veya demo olarak dağıtmak.
• Görevler:
  1. Önceki bir labdan eğitilmiş bir PyTorch sınıflandırma veya detection modeli seçin.
  2. PyTorch modelini ONNX formatına dönüştürün. Dönüşümü doğrulayın.
  3. Orijinal PyTorch modelinin (belki torch.profiler kullanarak) ve ONNX Runtime kullanarak ONNX modelinin inference hızını benchmark yapın ve model boyutunu ölçün.
  4. ONNX Runtime araçlarını kullanarak ONNX modeline Post-Training Dynamic Quantization (INT8) uygulayın (veya PyTorch PTQ deneyip tekrar export edin).
  5. Quantize edilmiş ONNX modelinin inference hızını benchmark yapın ve model boyutunu ölçün. Quantization öncesi ve sonrası accuracy'yi (küçük bir örneklem üzerinde) karşılaştırın.
  6. (Seçenek A) Optimize edilmiş ONNX modelini kullanarak bir görüntü alan (yükleme veya URL) ve modelin tahminini döndüren Flask/FastAPI kullanarak basit bir web API oluşturun. Uygulamayı Dockerize edin.
  7. (Seçenek B) Kullanıcıların bir görüntü yüklemesine ve modelin tahminlerini görmesine olanak tanıyan Gradio kullanarak interaktif bir web demosu oluşturun (optimize edilmiş ONNX modelini kullanarak veya yeterince verimliyse PyTorch modelini doğrudan yükleyerek).
• Teslim Edilecekler: Optimize edilmiş ONNX modeli (orijinal ve quantize edilmiş), benchmarking script'i/sonuçları, Dockerfile ve ilişkili dosyalar (Seçenek A) VEYA Gradio uygulama script'i (Seçenek B).
• Araçlar: Python, PyTorch, ONNX, ONNX Runtime, Docker (isteğe bağlı), Flask/FastAPI (isteğe bağlı), Gradio (isteğe bağlı).

Bitirme Projesi - Teklif & Planlama

SOTA tekniklerini (PyTorch kullanarak) uygulayan zorlu ve anlamlı bir computer vision projesi tanımlayın, planı, veri kümesini, metodolojiyi ve değerlendirme stratejisini ana hatlarıyla belirtin.

• Proje fikirleri üzerinde beyin fırtınası (katılımcı ilgi alanları ve bootcamp kapsamı ile uyumlu).
• Uygulanabilirlik ve kapsam konusunda eğitmen rehberliği ve geri bildirimi.
• Proje Teklif Belgesi:
  • Problem Tanımı & Motivasyon
  • Veri Kümesi Belirleme & Edinme Planı
  • Önerilen Metodoloji (Modeller - PyTorch, Teknikler)
  • Değerlendirme Metrikleri & Planı
  • Potansiyel Zorluklar & Azaltma Stratejileri
  • Zaman Çizelgesi & Kilometre Taşları
• Tekliflerin akran değerlendirmesi (Peer review).

Bitirme Projesi - Uygulama & Geliştirme

Bitirme projesi planını yürütün, çözümü PyTorch kullanarak uygulayın, modelleri eğitin/fine-tune edin, sonuçlara göre iterate edin ve ilerlemeyi belgeleyin.

• Veri toplama ve ön işleme (torchvision, özel Dataset'ler).
• PyTorch'ta model implementasyonu ve eğitim/fine-tuning.
• Deney takibi (W&B/TensorBoard).
• PyTorch kodunda hata ayıklama (Debugging) ve sorun giderme (troubleshooting).
• Eğitmenler/mentorlarla düzenli kontrol toplantıları.
• Ara ilerleme sunumları/demoları.

Bitirme Projesi - Sunum & Kapanış

Bitirme projesi bulgularını sunun, çalışan PyTorch tabanlı çözümü gösterin, zorlukları ve öğrenimleri tartışın ve bootcamp anahtar çıkarımlarını gözden geçirin.

• Proje implementasyonunu ve dokümantasyonunu tamamlama.
• Final sunumu hazırlama (Problem, Veri, Metot (PyTorch detayları), Sonuçlar, Demo, Sonuç, Gelecek Çalışmalar).
• Proje demoları.
• Akranlardan ve eğitmenlerden Soru-Cevap ve geri bildirim.
• Bootcamp değerlendirmesi ve anahtar öğrenimlerin özeti.
• CV'de kariyer rehberliği ve sonraki adımlar.

Değerlendirme:

• Lab Teslimleri (Doğruluk, Kod Kalitesi (PyTorch özgüllükleri), Analiz)
• Mini Proje Performansı
• Teorik Kavramlar Üzerine Quizler/Değerlendirmeler
• Bitirme Projesi (Teklif, Uygulama (PyTorch), Sunum, Sonuçlar)
• Katılım ve Etkileşim

Ortam Kurulumu:

• Bootcamp öncesinde Python, Conda ortamları, gerekli IDE'ler (VS Code), PyTorch kurulumu (CPU/GPU versiyonları) ve GPU kaynaklarına erişim (Google Colab kurulum kılavuzu) hakkında detaylı talimatlar sağlanacaktır.
• Tutarlılık için standartlaştırılmış ortam dosyaları (environment.yml veya requirements.txt) sağlanacaktır.

İleri Konular (Zamana/ilgiye göre eklenebilir/değiştirilebilir):

• Görüntü İşleme Görevleri için Reinforcement Learning
• Görüntü İşlemede Graph Neural Networks (PyTorch Geometric)
• İleri Video Anlama (Dense Captioning, Karmaşık Olay Tanıma)
• Computer Vision için Explainable AI (XAI) (Captum (PyTorch XAI kütüphanesi), Grad-CAM)
• Görüntü İşleme için Federated Learning (Flower framework'ü PyTorch'u destekler)
• CV'de Etik Hususlar (Bias, Fairness, Privacy)