# Pytanie 40: Detekcja obiektów w obrazach ## Pytanie **"Opisać problem detekcji obiektów w obrazach. Przedstawić podstawowe strategie i algorytmy detekcji przy użyciu metod klasycznych oraz sieci neuronowych. Jak skonstruować detektor obiektów dysponując istniejącym klasyfikatorem tych obiektów?"** Przedmiot: TWM (Techniki Wizji Maszynowej) --- ## 📚 Odpowiedź główna ### 1. Definicja problemu detekcji ``` ┌─────────────────────────────────────────────────────────────────┐ │ DETEKCJA OBIEKTÓW │ ├─────────────────────────────────────────────────────────────────┤ │ │ │ Obraz wejściowy: Wynik detekcji: │ │ ┌────────────────┐ ┌────────────────┐ │ │ │ 🚗 🚶 │ │ ┌──┐ ┌──┐ │ │ │ │ 🚗 │ → │ │🚗│ │🚶│ │ │ │ │ 🚶 │ │ └──┘ └──┘ ┌──┐ │ │ │ │ │ │ ┌──┐│🚗│ │ │ │ └────────────────┘ │ ┌──┤🚶│└──┘ │ │ │ │ └──┴──┘ │ │ │ └────────────────┘ │ │ │ │ Wynik: lista (class, bounding_box, confidence) │ │ [(car, [x1,y1,x2,y2], 0.95), (person, [...], 0.87)] │ │ │ │ Różnica od klasyfikacji: │ │ • Klasyfikacja: Co jest na obrazie? │ │ • Detekcja: Co i GDZIE jest na obrazie? │ └─────────────────────────────────────────────────────────────────┘ ``` --- ### 2. Metody klasyczne #### 2.1 Sliding Window + HOG/SIFT ``` ┌─────────────────────────────────────────────────────────────────┐ │ SLIDING WINDOW │ ├─────────────────────────────────────────────────────────────────┤ │ │ │ 1. Przesuwaj okno po obrazie (różne skale, pozycje) │ │ │ │ ┌──┐ │ │ │░░│→→→→→→→→ │ │ └──┘ │ │ ↓ ↓ ↓ ↓ ↓ ↓ ↓ │ │ │ │ 2. Dla każdego okna: wyekstrahuj features (HOG, SIFT) │ │ 3. Klasyfikuj (SVM, Random Forest) │ │ 4. Non-Maximum Suppression (NMS) │ │ │ │ Problem: O(scales × positions × classifier) → WOLNE! │ └─────────────────────────────────────────────────────────────────┘ ``` #### 2.2 HOG (Histogram of Oriented Gradients) ``` HOG descriptor: 1. Oblicz gradienty (Gx, Gy) 2. Magnitude: √(Gx² + Gy²) 3. Orientacja: arctan(Gy/Gx) 4. Podziel na cells (8×8 pikseli) 5. Histogram orientacji (9 bins) 6. Normalizacja w blokach ┌───┬───┬───┬───┐ │ │ │ │ │ ├───┼───┼───┼───┤ │ │▓▓▓│▓▓▓│ │ ← histogram dla każdej cell ├───┼───┼───┼───┤ │ │▓▓▓│▓▓▓│ │ └───┴───┴───┴───┘ Użycie: HOG + linear SVM → pedestrian detection (Dalal & Triggs) ``` #### 2.3 Viola-Jones (Haar Cascades) ``` ┌─────────────────────────────────────────────────────────────────┐ │ VIOLA-JONES (2001) - real-time face detection │ ├─────────────────────────────────────────────────────────────────┤ │ │ │ Haar-like features: │ │ ┌───┬───┐ ┌───────┐ ┌─┬─┐ │ │ │░░░│███│ │░░░░░░░│ │░│█│ │ │ │░░░│███│ │███████│ │█│░│ │ │ └───┴───┘ └───────┘ └─┴─┘ │ │ │ │ Feature = Σ(white) - Σ(black) │ │ Integral image: O(1) dla każdej feature! │ │ │ │ AdaBoost cascade: │ │ Stage1 → Stage2 → Stage3 → ... → Face! │ │ ↓ ↓ ↓ │ │ Reject Reject Reject (szybko odrzuca nie-twarze) │ │ │ │ Bardzo szybkie! (30fps w 2001) │ └─────────────────────────────────────────────────────────────────┘ ``` --- ### 3. Metody Deep Learning #### 3.1 Two-Stage Detectors (R-CNN family) ``` ┌─────────────────────────────────────────────────────────────────┐ │ R-CNN (2014) │ ├─────────────────────────────────────────────────────────────────┤ │ │ │ 1. Selective Search → ~2000 region proposals │ │ 2. Dla każdego regionu: │ │ - Resize do 224×224 │ │ - CNN (AlexNet) → features │ │ - SVM classifier │ │ 3. Bounding box regression │ │ 4. NMS │ │ │ │ Problem: 2000 × CNN forward pass → ~50 sec/image! │ └─────────────────────────────────────────────────────────────────┘ ┌─────────────────────────────────────────────────────────────────┐ │ Fast R-CNN (2015) │ ├─────────────────────────────────────────────────────────────────┤ │ │ │ Image → CNN → Feature map │ │ ↓ │ │ ROI Pooling (region proposals) │ │ ↓ │ │ FC layers │ │ ↓ ↓ │ │ class bbox │ │ │ │ CNN tylko raz! ROI pooling wycina regiony z feature map │ │ ~2 sec/image (25× szybciej) │ └─────────────────────────────────────────────────────────────────┘ ┌─────────────────────────────────────────────────────────────────┐ │ Faster R-CNN (2016) │ ├─────────────────────────────────────────────────────────────────┤ │ │ │ Image → CNN → Feature map → RPN (Region Proposal Network) │ │ │ ↓ │ │ └──────→ ROI Pooling │ │ ↓ │ │ Detection head │ │ ↓ ↓ │ │ class bbox │ │ │ │ RPN: mała sieć generująca proposals (zamiast Selective Search) │ │ End-to-end training! │ │ ~0.2 sec/image (~5 fps) │ └─────────────────────────────────────────────────────────────────┘ ``` #### 3.2 One-Stage Detectors (YOLO, SSD) ``` ┌─────────────────────────────────────────────────────────────────┐ │ YOLO (You Only Look Once) - 2016 │ ├─────────────────────────────────────────────────────────────────┤ │ │ │ Image → CNN → S×S×(B×5 + C) tensor │ │ │ │ Dzieli obraz na S×S grid: │ │ ┌───┬───┬───┬───┬───┬───┬───┐ │ │ │ │ │ │ │ │ │ │ │ │ ├───┼───┼───┼───┼───┼───┼───┤ │ │ │ │ │ ● │ │ │ │ │ ← cell odpowiada za obiekt │ │ ├───┼───┼───┼───┼───┼───┼───┤ którego centrum tu jest │ │ │ │ │ │ │ │ │ │ │ │ └───┴───┴───┴───┴───┴───┴───┘ │ │ │ │ Każda cell predykuje: │ │ • B bounding boxes: (x, y, w, h, confidence) │ │ • C class probabilities │ │ │ │ Zaleta: Bardzo szybki! 45-155 fps │ │ Wada: Gorszy dla małych obiektów, obiektów blisko siebie │ └─────────────────────────────────────────────────────────────────┘ ┌─────────────────────────────────────────────────────────────────┐ │ SSD (Single Shot Detector) - 2016 │ ├─────────────────────────────────────────────────────────────────┤ │ │ │ Multi-scale feature maps: │ │ │ │ ┌────────────┐ │ │ │ 38×38×512 │ ← detect small objects │ │ └─────┬──────┘ │ │ ↓ │ │ ┌──────┐ │ │ │19×19 │ ← detect medium objects │ │ └──┬───┘ │ │ ↓ │ │ ┌────┐ │ │ │10×10│ ← detect large objects │ │ └────┘ │ │ │ │ Default boxes (anchors) o różnych aspect ratios │ │ Łączy zalety YOLO (szybkość) i Faster R-CNN (multi-scale) │ └─────────────────────────────────────────────────────────────────┘ ``` #### 3.3 Nowoczesne architektury ``` YOLOv8 (2023): • Anchor-free detection • Decoupled head (cls/box separate) • C2f module (CSP + bottleneck) • ~80 mAP na COCO, real-time DETR (2020): • Transformer-based • Bipartite matching loss (Hungarian) • No anchors, no NMS • End-to-end set prediction RT-DETR (2023): • Real-time DETR • Efficient hybrid encoder • IoU-aware query selection ``` --- ### 4. Konstrukcja detektora z klasyfikatora ``` ┌─────────────────────────────────────────────────────────────────┐ │ JAK ZROBIĆ DETEKTOR MAJĄC KLASYFIKATOR? │ ├─────────────────────────────────────────────────────────────────┤ │ │ │ Metoda 1: SLIDING WINDOW │ │ ───────────────────────── │ │ for scale in scales: │ │ for (x, y) in positions: │ │ crop = image[y:y+h, x:x+w] │ │ if classifier(crop) > threshold: │ │ detections.append((x, y, w, h, class)) │ │ return NMS(detections) │ │ │ │ Problem: Bardzo wolne (wiele przesunięć × skale) │ │ │ │ │ │ Metoda 2: REGION PROPOSALS + CLASSIFIER │ │ ───────────────────────────────────────── │ │ 1. Selective Search / EdgeBoxes → candidate regions │ │ 2. Dla każdego regionu: │ │ resize + classifier → class, confidence │ │ 3. NMS │ │ │ │ Szybsze niż sliding window (mniej regionów) │ │ │ │ │ │ Metoda 3: FINE-TUNE na DETECTION │ │ ───────────────────────────────── │ │ 1. Użyj pretrained classifier jako backbone │ │ 2. Dodaj detection head (bbox regression + cls) │ │ 3. Fine-tune na detection dataset │ │ │ │ Najlepsza jakość! │ └─────────────────────────────────────────────────────────────────┘ ``` --- ### 5. Non-Maximum Suppression (NMS) ``` Problem: Wiele overlapping detections ┌─────────┐ │ ┌──────┼──┐ │ │ 🚗 │ │ ← 3 nakładające się bbox │ │ │ │ └──┼──────┘ │ └─────────┘ NMS Algorithm: 1. Sortuj detekcje wg confidence 2. Weź najlepszą, dodaj do wyników 3. Usuń wszystkie z IoU > threshold 4. Powtarzaj dla pozostałych Soft-NMS: Nie usuwa, tylko obniża confidence score = score × f(IoU) gdzie f maleje z IoU ``` --- ### 6. Metryki | Metryka | Opis | |---------|------| | **IoU** | Intersection over Union bbox | | **Precision** | TP / (TP + FP) | | **Recall** | TP / (TP + FN) | | **AP** | Area under Precision-Recall curve | | **mAP** | Mean AP across classes | | **mAP@0.5** | mAP przy IoU threshold = 0.5 | | **mAP@[.5:.95]** | mAP average across IoU thresholds | --- ## 🧠 Mnemoniki ### "YOLO = You Only Look Once": Jednokrotne przejście przez sieć ### "R-CNN → Fast → Faster": Ewolucja: 50s → 2s → 0.2s ### "Two-stage = proposals + classify": Faster R-CNN: RPN + detection head ### "One-stage = direct": YOLO, SSD: bezpośrednia predykcja --- ## ❓ Pytania dodatkowe ### Q1: "YOLO vs Faster R-CNN?" **Odpowiedź:** YOLO: szybszy (real-time), gorszy dla małych obiektów. Faster R-CNN: dokładniejszy, wolniejszy, two-stage (RPN + detection). Trade-off speed vs accuracy. ### Q2: "Co to są anchor boxes?" **Odpowiedź:** Predefiniowane boxy o różnych rozmiarach i aspect ratios. Sieć predykuje offset od anchora, nie absolutne koordynaty. Ułatwia uczenie (mniejsza przestrzeń wyjściowa). ### Q3: "Jak działają anchor-free detektory?" **Odpowiedź:** Predykują bezpośrednio: punkt centralny + rozmiar (FCOS, CenterNet) lub keypoints (CornerNet). Prostsze, mniej hiperparametrów, konkurencyjne wyniki. --- ## 🎯 Kluczowe punkty 1. **Klasyczne:** HOG+SVM, Viola-Jones (Haar cascades) 2. **Two-stage:** R-CNN → Fast → Faster (RPN) 3. **One-stage:** YOLO, SSD (szybsze, real-time) 4. **NMS:** Eliminacja overlapping detekcji 5. **Metryka:** mAP@[.5:.95] --- ## 📖 Źródła 1. Girshick et al. - "R-CNN" (2014), "Fast R-CNN" (2015) 2. Ren et al. - "Faster R-CNN" (2016) 3. Redmon et al. - "YOLO" series (2016-2018) 4. Liu et al. - "SSD" (2016) 5. Carion et al. - "DETR" (2020)