mirror of
https://github.com/kuhyx/praca_magisterska.git
synced 2026-07-04 12:03:01 +02:00
21 KiB
21 KiB
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
- Klasyczne: HOG+SVM, Viola-Jones (Haar cascades)
- Two-stage: R-CNN → Fast → Faster (RPN)
- One-stage: YOLO, SSD (szybsze, real-time)
- NMS: Eliminacja overlapping detekcji
- Metryka: mAP@[.5:.95]
📖 Źródła
- Girshick et al. - "R-CNN" (2014), "Fast R-CNN" (2015)
- Ren et al. - "Faster R-CNN" (2016)
- Redmon et al. - "YOLO" series (2016-2018)
- Liu et al. - "SSD" (2016)
- Carion et al. - "DETR" (2020)