Object detection from scratch: Faster R-CNN + YOLO comparison

box_utils.py

@@ -0,0 +1,163 @@
+"""
+Faster R-CNN 밑바닥 구현 — [2/5] 박스 연산 유틸
+==================================================
+객체탐지의 수학적 핵심이 모두 여기에 있다.
+
+  1) 앵커(anchor) 생성      : 격자마다 여러 크기·비율의 기준 박스를 깐다
+  2) IoU                    : 두 박스가 얼마나 겹치는가
+  3) 박스 인코딩/디코딩     : (박스 → 회귀 타깃) / (예측값 → 박스)
+  4) NMS                    : 겹치는 중복 예측을 제거
+
+이 파일만 이해하면 Faster R-CNN의 절반을 이해한 것이다.
+"""
+
+import torch
+
+
+# ---------------------------------------------------------------
+# 1) 앵커 생성
+# ---------------------------------------------------------------
+def generate_anchors(base_size=16, ratios=(0.5, 1.0, 2.0),
+                     scales=(8, 16, 32)):
+    """
+    한 격자점(cell)에 놓을 기준 앵커들을 만든다.
+    ratios(가로세로비) × scales(크기) 조합 → 보통 9개 앵커.
+
+    반환: [num_anchors, 4] 형태의 (x1,y1,x2,y2), 중심이 원점 기준.
+    """
+    anchors = []
+    for scale in scales:
+        area = (base_size * scale) ** 2
+        for ratio in ratios:
+            # 넓이는 유지하고 가로세로비만 바꾼다
+            w = round((area / ratio) ** 0.5)
+            h = round(w * ratio)
+            anchors.append([-w / 2, -h / 2, w / 2, h / 2])
+    return torch.tensor(anchors, dtype=torch.float32)
+
+
+def shift_anchors(base_anchors, feat_h, feat_w, stride):
+    """
+    기준 앵커를 특징맵 전체 격자에 복제·이동시켜
+    모든 위치의 앵커를 만든다.
+
+    feat_h, feat_w : 특징맵 크기
+    stride         : 원본 이미지 대비 특징맵 축소 배율(예: 16)
+    반환: [feat_h*feat_w*num_anchors, 4] (원본 이미지 좌표계)
+    """
+    # 각 격자점의 이미지상 중심 좌표
+    shift_x = (torch.arange(feat_w) + 0.5) * stride
+    shift_y = (torch.arange(feat_h) + 0.5) * stride
+    sy, sx = torch.meshgrid(shift_y, shift_x, indexing="ij")
+    shifts = torch.stack([sx.reshape(-1), sy.reshape(-1),
+                          sx.reshape(-1), sy.reshape(-1)], dim=1)  # [K,4]
+
+    # [K,1,4] + [1,A,4] → [K,A,4] → [K*A,4]
+    anchors = shifts[:, None, :] + base_anchors[None, :, :]
+    return anchors.reshape(-1, 4)
+
+
+# ---------------------------------------------------------------
+# 2) IoU (Intersection over Union)
+# ---------------------------------------------------------------
+def box_iou(boxes1, boxes2):
+    """
+    [N,4], [M,4] → [N,M] IoU 행렬.
+    IoU = 교집합 넓이 / 합집합 넓이. 0(안 겹침)~1(완전 일치).
+    """
+    area1 = (boxes1[:, 2] - boxes1[:, 0]) * (boxes1[:, 3] - boxes1[:, 1])
+    area2 = (boxes2[:, 2] - boxes2[:, 0]) * (boxes2[:, 3] - boxes2[:, 1])
+
+    lt = torch.max(boxes1[:, None, :2], boxes2[None, :, :2])  # 교집합 좌상단
+    rb = torch.min(boxes1[:, None, 2:], boxes2[None, :, 2:])  # 교집합 우하단
+    wh = (rb - lt).clamp(min=0)
+    inter = wh[:, :, 0] * wh[:, :, 1]
+
+    union = area1[:, None] + area2[None, :] - inter
+    return inter / union.clamp(min=1e-6)
+
+
+# ---------------------------------------------------------------
+# 3) 박스 인코딩 / 디코딩
+# ---------------------------------------------------------------
+def encode_boxes(gt, anchors):
+    """
+    정답 박스(gt)를 앵커 기준 회귀 타깃 (dx,dy,dw,dh)으로 변환.
+    네트워크는 절대 좌표가 아니라 "앵커로부터의 상대 변형"을 배운다.
+    """
+    aw = anchors[:, 2] - anchors[:, 0]
+    ah = anchors[:, 3] - anchors[:, 1]
+    ax = anchors[:, 0] + 0.5 * aw
+    ay = anchors[:, 1] + 0.5 * ah
+
+    gw = gt[:, 2] - gt[:, 0]
+    gh = gt[:, 3] - gt[:, 1]
+    gx = gt[:, 0] + 0.5 * gw
+    gy = gt[:, 1] + 0.5 * gh
+
+    dx = (gx - ax) / aw
+    dy = (gy - ay) / ah
+    dw = torch.log(gw / aw)
+    dh = torch.log(gh / ah)
+    return torch.stack([dx, dy, dw, dh], dim=1)
+
+
+def decode_boxes(deltas, anchors):
+    """
+    네트워크가 예측한 (dx,dy,dw,dh)를 실제 박스 좌표로 복원.
+    encode_boxes의 역연산.
+    """
+    aw = anchors[:, 2] - anchors[:, 0]
+    ah = anchors[:, 3] - anchors[:, 1]
+    ax = anchors[:, 0] + 0.5 * aw
+    ay = anchors[:, 1] + 0.5 * ah
+
+    dx, dy, dw, dh = deltas[:, 0], deltas[:, 1], deltas[:, 2], deltas[:, 3]
+    # dw,dh 폭주 방지 클램프
+    dw = torch.clamp(dw, max=4.135)
+    dh = torch.clamp(dh, max=4.135)
+
+    px = dx * aw + ax
+    py = dy * ah + ay
+    pw = torch.exp(dw) * aw
+    ph = torch.exp(dh) * ah
+
+    x1 = px - 0.5 * pw
+    y1 = py - 0.5 * ph
+    x2 = px + 0.5 * pw
+    y2 = py + 0.5 * ph
+    return torch.stack([x1, y1, x2, y2], dim=1)
+
+
+def clip_boxes(boxes, img_h, img_w):
+    """박스를 이미지 경계 안으로 자른다."""
+    boxes[:, 0].clamp_(min=0, max=img_w)
+    boxes[:, 1].clamp_(min=0, max=img_h)
+    boxes[:, 2].clamp_(min=0, max=img_w)
+    boxes[:, 3].clamp_(min=0, max=img_h)
+    return boxes
+
+
+# ---------------------------------------------------------------
+# 4) NMS (Non-Maximum Suppression)
+# ---------------------------------------------------------------
+def nms(boxes, scores, iou_thresh=0.7):
+    """
+    점수 높은 박스부터 남기고, 그와 많이 겹치는 박스는 제거.
+    torchvision.ops.nms 를 써도 되지만, 원리 학습용으로 직접 구현.
+    반환: 남길 인덱스.
+    """
+    if boxes.numel() == 0:
+        return torch.empty((0,), dtype=torch.int64)
+
+    order = scores.argsort(descending=True)
+    keep = []
+    while order.numel() > 0:
+        i = order[0].item()
+        keep.append(i)
+        if order.numel() == 1:
+            break
+        ious = box_iou(boxes[i].unsqueeze(0), boxes[order[1:]]).squeeze(0)
+        # 임계값 이하만 남긴다
+        order = order[1:][ious <= iou_thresh]
+    return torch.tensor(keep, dtype=torch.int64)

dataset.py

@@ -0,0 +1,139 @@
+"""
+Faster R-CNN 밑바닥 구현 — [1/5] 데이터셋 (Pascal VOC)
+=========================================================
+Pascal VOC 2007/2012 데이터를 읽어 (이미지, 박스, 라벨)을 반환한다.
+
+VOC 어노테이션은 XML 형식이며, 각 객체마다 다음을 담는다:
+  - name       : 클래스 이름 (예: 'person', 'car')
+  - bndbox     : xmin, ymin, xmax, ymax (좌상단·우하단 픽셀 좌표)
+  - difficult  : 판별 어려운 객체 표시(학습 시 보통 제외)
+
+핵심 개념:
+  - 박스 좌표는 [x1, y1, x2, y2] 절대 픽셀 좌표로 통일한다.
+  - 이미지를 리사이즈하면 박스도 같은 비율로 스케일해야 한다.
+"""
+
+import os
+import xml.etree.ElementTree as ET
+
+import torch
+from torch.utils.data import Dataset
+from PIL import Image
+import torchvision.transforms.functional as F
+
+
+# Pascal VOC 20개 클래스 (인덱스 0은 배경으로 예약 → 클래스는 1부터)
+VOC_CLASSES = [
+    "aeroplane", "bicycle", "bird", "boat", "bottle",
+    "bus", "car", "cat", "chair", "cow",
+    "diningtable", "dog", "horse", "motorbike", "person",
+    "pottedplant", "sheep", "sofa", "train", "tvmonitor",
+]
+# 이름 → 인덱스 (배경=0 이므로 +1)
+CLASS_TO_IDX = {name: i + 1 for i, name in enumerate(VOC_CLASSES)}
+NUM_CLASSES = len(VOC_CLASSES) + 1  # +1 = 배경(background)
+
+
+class VOCDataset(Dataset):
+    """
+    Pascal VOC 객체탐지 데이터셋.
+
+    Args:
+        root:        VOCdevkit/VOC2007 (또는 VOC2012) 경로
+        split:       'train' | 'val' | 'trainval' | 'test'
+        min_size:    리사이즈 시 이미지 짧은 변의 목표 길이
+        max_size:    긴 변의 최대 길이(비율 유지하며 상한 적용)
+        keep_difficult: difficult=1 객체를 포함할지 여부(학습 시 False 권장)
+    """
+
+    def __init__(self, root, split="trainval", min_size=600, max_size=1000,
+                 keep_difficult=False):
+        self.root = root
+        self.min_size = min_size
+        self.max_size = max_size
+        self.keep_difficult = keep_difficult
+
+        # ImageSets/Main/<split>.txt 에 이미지 ID 목록이 있다.
+        split_file = os.path.join(root, "ImageSets", "Main", f"{split}.txt")
+        with open(split_file) as f:
+            self.ids = [line.strip() for line in f if line.strip()]
+
+    def __len__(self):
+        return len(self.ids)
+
+    def _load_annotation(self, img_id):
+        """XML을 파싱해 박스와 라벨을 뽑는다."""
+        ann_path = os.path.join(self.root, "Annotations", f"{img_id}.xml")
+        tree = ET.parse(ann_path)
+        boxes, labels = [], []
+
+        for obj in tree.findall("object"):
+            difficult = int(obj.findtext("difficult", "0"))
+            if difficult and not self.keep_difficult:
+                continue
+
+            name = obj.findtext("name").strip().lower()
+            if name not in CLASS_TO_IDX:
+                continue
+
+            bnd = obj.find("bndbox")
+            # VOC 좌표는 1부터 시작 → 0-기반으로 보정(-1)
+            x1 = float(bnd.findtext("xmin")) - 1
+            y1 = float(bnd.findtext("ymin")) - 1
+            x2 = float(bnd.findtext("xmax")) - 1
+            y2 = float(bnd.findtext("ymax")) - 1
+            boxes.append([x1, y1, x2, y2])
+            labels.append(CLASS_TO_IDX[name])
+
+        boxes = torch.as_tensor(boxes, dtype=torch.float32).reshape(-1, 4)
+        labels = torch.as_tensor(labels, dtype=torch.int64)
+        return boxes, labels
+
+    def _resize(self, img, boxes):
+        """
+        짧은 변을 min_size로 맞추되, 긴 변이 max_size를 넘지 않도록 스케일.
+        박스도 같은 비율로 조정한다. (Faster R-CNN 원논문 방식)
+        """
+        w, h = img.size
+        short, long = min(w, h), max(w, h)
+        scale = self.min_size / short
+        if long * scale > self.max_size:
+            scale = self.max_size / long
+
+        new_w, new_h = int(round(w * scale)), int(round(h * scale))
+        img = img.resize((new_w, new_h), Image.BILINEAR)
+        if boxes.numel() > 0:
+            boxes = boxes * scale  # 박스도 동일 배율 적용
+        return img, boxes, scale
+
+    def __getitem__(self, idx):
+        img_id = self.ids[idx]
+        img_path = os.path.join(self.root, "JPEGImages", f"{img_id}.jpg")
+        img = Image.open(img_path).convert("RGB")
+
+        boxes, labels = self._load_annotation(img_id)
+        img, boxes, scale = self._resize(img, boxes)
+
+        # 텐서 변환 + ImageNet 정규화(백본이 ImageNet 사전학습이므로)
+        img = F.to_tensor(img)
+        img = F.normalize(img,
+                          mean=[0.485, 0.456, 0.406],
+                          std=[0.229, 0.224, 0.225])
+
+        target = {
+            "boxes": boxes,          # [N,4] 절대 픽셀 (리사이즈 후)
+            "labels": labels,        # [N]   1..20 (0=배경)
+            "image_id": img_id,
+            "scale": scale,          # 평가 시 원본 좌표로 되돌릴 때 사용
+        }
+        return img, target
+
+
+def collate_fn(batch):
+    """
+    이미지마다 크기가 달라 기본 collate로 못 묶는다.
+    리스트 형태로 그대로 넘기고, 모델 내부에서 처리한다.
+    (간단화를 위해 batch_size=1 사용을 권장)
+    """
+    imgs, targets = list(zip(*batch))
+    return list(imgs), list(targets)

infer.py

@@ -0,0 +1,149 @@
+"""
+Faster R-CNN 밑바닥 구현 — 추론(inference) 스크립트
+=====================================================
+학습된 frcnn.pth 로 임의의 이미지에서 객체를 탐지하고,
+박스 + 클래스명 + 점수를 그려서 저장한다.
+
+실행 예:
+  # 이미지 한 장
+  python infer.py --ckpt frcnn.pth --image test.jpg
+
+  # 폴더 안 모든 이미지
+  python infer.py --ckpt frcnn.pth --image_dir ./samples --out_dir ./results
+
+  # 점수 임계값 조정(기본 0.5)
+  python infer.py --ckpt frcnn.pth --image test.jpg --score_thresh 0.7
+
+주의:
+  - train.py, model.py 등과 같은 폴더에서 실행할 것.
+  - 학습과 동일한 리사이즈/정규화를 적용해야 결과가 정상.
+"""
+
+import os
+import argparse
+
+import torch
+from PIL import Image, ImageDraw, ImageFont
+import torchvision.transforms.functional as F
+
+from model import FasterRCNN
+from dataset import NUM_CLASSES, VOC_CLASSES
+
+
+# 클래스별 색상(20개) — 시각적으로 구분되도록 HSV 분할
+def _class_colors():
+    import colorsys
+    colors = []
+    for i in range(len(VOC_CLASSES)):
+        h = i / len(VOC_CLASSES)
+        r, g, b = colorsys.hsv_to_rgb(h, 0.75, 0.95)
+        colors.append((int(r * 255), int(g * 255), int(b * 255)))
+    return colors
+
+CLASS_COLORS = _class_colors()
+
+
+def preprocess(pil_img, min_size=600, max_size=1000):
+    """학습과 동일한 리사이즈 + 정규화. 원본 복원용 scale도 반환."""
+    w, h = pil_img.size
+    short, long = min(w, h), max(w, h)
+    scale = min_size / short
+    if long * scale > max_size:
+        scale = max_size / long
+    new_w, new_h = int(round(w * scale)), int(round(h * scale))
+
+    resized = pil_img.resize((new_w, new_h), Image.BILINEAR)
+    t = F.to_tensor(resized)
+    t = F.normalize(t, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+    return t, scale
+
+
+def draw_detections(pil_img, boxes, labels, scores, scale):
+    """탐지 결과를 원본 이미지 좌표로 되돌려 박스와 라벨을 그린다."""
+    draw = ImageDraw.Draw(pil_img)
+    try:
+        font = ImageFont.truetype("arial.ttf", 16)
+    except Exception:
+        font = ImageFont.load_default()
+
+    for box, label, score in zip(boxes, labels, scores):
+        # 모델은 리사이즈된 좌표를 출력 → 원본 크기로 되돌림(÷scale)
+        x1, y1, x2, y2 = (box / scale).tolist()
+        cls_idx = int(label) - 1  # 0=배경 제외
+        if cls_idx < 0 or cls_idx >= len(VOC_CLASSES):
+            continue
+        name = VOC_CLASSES[cls_idx]
+        color = CLASS_COLORS[cls_idx]
+
+        # 박스
+        draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
+
+        # 라벨 배경 + 텍스트
+        text = f"{name} {score:.2f}"
+        tb = draw.textbbox((x1, y1), text, font=font)
+        draw.rectangle([tb[0], tb[1], tb[2], tb[3]], fill=color)
+        draw.text((x1, y1), text, fill="white", font=font)
+
+    return pil_img
+
+
+@torch.no_grad()
+def infer_image(model, img_path, device, score_thresh):
+    pil = Image.open(img_path).convert("RGB")
+    tensor, scale = preprocess(pil)
+    tensor = tensor.to(device).unsqueeze(0)
+
+    det = model(tensor)  # eval 모드 → {boxes, labels, scores}
+    keep = det["scores"] >= score_thresh
+    boxes = det["boxes"][keep].cpu()
+    labels = det["labels"][keep].cpu()
+    scores = det["scores"][keep].cpu()
+
+    result = draw_detections(pil, boxes, labels, scores, scale)
+    return result, len(boxes)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--ckpt", required=True, help="학습된 가중치 (frcnn.pth)")
+    ap.add_argument("--image", help="단일 이미지 경로")
+    ap.add_argument("--image_dir", help="이미지 폴더 경로")
+    ap.add_argument("--out_dir", default="./results", help="결과 저장 폴더")
+    ap.add_argument("--score_thresh", type=float, default=0.5,
+                    help="이 점수 이상만 표시")
+    args = ap.parse_args()
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print("device:", device)
+
+    model = FasterRCNN(NUM_CLASSES).to(device)
+    model.load_state_dict(torch.load(args.ckpt, map_location=device))
+    model.eval()
+    print(f"모델 로드 완료: {args.ckpt}")
+
+    os.makedirs(args.out_dir, exist_ok=True)
+
+    # 처리할 이미지 목록 구성
+    targets = []
+    if args.image:
+        targets.append(args.image)
+    if args.image_dir:
+        for fn in os.listdir(args.image_dir):
+            if fn.lower().endswith((".jpg", ".jpeg", ".png", ".bmp")):
+                targets.append(os.path.join(args.image_dir, fn))
+
+    if not targets:
+        print("이미지를 지정하세요: --image 또는 --image_dir")
+        return
+
+    for path in targets:
+        result, n = infer_image(model, path, device, args.score_thresh)
+        out_path = os.path.join(args.out_dir, "det_" + os.path.basename(path))
+        result.save(out_path)
+        print(f"  {os.path.basename(path)}: {n}개 탐지 → {out_path}")
+
+    print(f"완료. 결과는 {args.out_dir} 폴더에 저장됨.")
+
+
+if __name__ == "__main__":
+    main()

losses.py

@@ -0,0 +1,145 @@
+"""
+Faster R-CNN 밑바닥 구현 — [4/5] 손실 계산
+=============================================
+Faster R-CNN은 두 곳에서 손실이 발생한다.
+
+  RPN 손실 : 앵커가 객체인가(분류) + 앵커→정답 박스 보정(회귀)
+  RoI 손실 : 후보영역의 클래스(분류) + 클래스별 박스 보정(회귀)
+
+핵심은 "타깃 할당(target assignment)":
+  - 각 앵커/후보영역이 어떤 정답 박스를 담당하는지 IoU로 정한다.
+  - IoU 높으면 positive(객체), 낮으면 negative(배경), 애매하면 무시.
+  - 그 다음 positive에만 회귀 손실, pos+neg에 분류 손실을 건다.
+"""
+
+import torch
+import torch.nn.functional as F
+
+from box_utils import box_iou, encode_boxes, decode_boxes, clip_boxes
+
+
+def _sample(pos_idx, neg_idx, num, pos_frac):
+    """pos/neg를 정해진 개수·비율로 무작위 샘플링(클래스 불균형 방지)."""
+    num_pos = min(int(num * pos_frac), pos_idx.numel())
+    num_neg = min(num - num_pos, neg_idx.numel())
+    pos = pos_idx[torch.randperm(pos_idx.numel())[:num_pos]]
+    neg = neg_idx[torch.randperm(neg_idx.numel())[:num_neg]]
+    return pos, neg
+
+
+# ---------------------------------------------------------------
+# RPN 손실
+# ---------------------------------------------------------------
+def rpn_loss(rpn_logits, rpn_deltas, anchors, gt_boxes, img_hw,
+             pos_iou=0.7, neg_iou=0.3, num_samples=256, pos_frac=0.5):
+    device = rpn_logits.device
+
+    # 이미지 밖으로 나간 앵커는 학습에서 제외
+    inside = ((anchors[:, 0] >= 0) & (anchors[:, 1] >= 0) &
+              (anchors[:, 2] <= img_hw[1]) & (anchors[:, 3] <= img_hw[0]))
+    idx_inside = torch.where(inside)[0]
+    anc = anchors[idx_inside]
+
+    labels = torch.full((anc.shape[0],), -1, dtype=torch.float32, device=device)  # -1=무시
+
+    if gt_boxes.numel() > 0:
+        ious = box_iou(anc, gt_boxes)          # [A, G]
+        max_iou, argmax = ious.max(dim=1)       # 각 앵커의 최고 IoU 정답
+        labels[max_iou < neg_iou] = 0           # 배경
+        labels[max_iou >= pos_iou] = 1          # 객체
+        # 각 정답 박스에 대해 IoU 최대인 앵커도 강제로 positive
+        gt_best = ious.argmax(dim=0)
+        labels[gt_best] = 1
+        matched_gt = gt_boxes[argmax]
+    else:
+        labels[:] = 0
+        matched_gt = torch.zeros_like(anc)
+
+    pos = torch.where(labels == 1)[0]
+    neg = torch.where(labels == 0)[0]
+    pos, neg = _sample(pos, neg, num_samples, pos_frac)
+    samp = torch.cat([pos, neg])
+
+    # --- 분류 손실 (객체/배경) ---
+    logits_inside = rpn_logits[idx_inside]
+    cls_loss = F.binary_cross_entropy_with_logits(
+        logits_inside[samp], labels[samp])
+
+    # --- 회귀 손실 (positive 앵커만) ---
+    if pos.numel() > 0:
+        deltas_inside = rpn_deltas[idx_inside]
+        reg_targets = encode_boxes(matched_gt[pos], anc[pos])
+        reg_loss = F.smooth_l1_loss(deltas_inside[pos], reg_targets,
+                                    beta=1.0 / 9.0)
+    else:
+        reg_loss = torch.tensor(0.0, device=device)
+
+    return cls_loss + reg_loss
+
+
+# ---------------------------------------------------------------
+# RoI 타깃 할당 (후보영역 → 학습 샘플)
+# ---------------------------------------------------------------
+def assign_roi_targets(proposals, gt_boxes, gt_labels,
+                       pos_iou=0.5, neg_iou_hi=0.5, neg_iou_lo=0.0,
+                       num_samples=128, pos_frac=0.25):
+    """후보영역에 클래스 라벨과 회귀 타깃을 붙이고 샘플링."""
+    device = proposals.device
+    # 정답 박스도 후보에 추가(학습 초기 안정화)
+    if gt_boxes.numel() > 0:
+        proposals = torch.cat([proposals, gt_boxes], dim=0)
+
+    if gt_boxes.numel() == 0:
+        # 정답이 없으면 전부 배경
+        n = min(num_samples, proposals.shape[0])
+        sel = proposals[:n]
+        labels = torch.zeros((n,), dtype=torch.int64, device=device)
+        reg_t = torch.zeros((n, 4), device=device)
+        return sel, labels, reg_t, torch.zeros((n,), dtype=torch.bool, device=device)
+
+    ious = box_iou(proposals, gt_boxes)
+    max_iou, argmax = ious.max(dim=1)
+    gt_for_prop = gt_labels[argmax]
+    matched_gt = gt_boxes[argmax]
+
+    labels = torch.zeros_like(gt_for_prop)          # 0=배경 기본
+    pos_mask = max_iou >= pos_iou
+    labels[pos_mask] = gt_for_prop[pos_mask]         # 객체 클래스 부여
+
+    pos = torch.where(pos_mask)[0]
+    neg = torch.where((max_iou < neg_iou_hi) & (max_iou >= neg_iou_lo))[0]
+    pos, neg = _sample(pos, neg, num_samples, pos_frac)
+    samp = torch.cat([pos, neg])
+
+    sel_prop = proposals[samp]
+    sel_labels = labels[samp]
+    reg_targets = encode_boxes(matched_gt[samp], sel_prop)
+    is_pos = torch.zeros((samp.numel(),), dtype=torch.bool, device=device)
+    is_pos[:pos.numel()] = True
+    return sel_prop, sel_labels, reg_targets, is_pos
+
+
+# ---------------------------------------------------------------
+# RoI 손실
+# ---------------------------------------------------------------
+def roi_loss(head, feat, stride, proposals, gt_boxes, gt_labels):
+    sel_prop, labels, reg_targets, is_pos = assign_roi_targets(
+        proposals, gt_boxes, gt_labels)
+
+    cls_logits, reg = head(feat, sel_prop, stride)  # [S,C], [S,C*4]
+
+    # --- 분류 손실 (전체 샘플) ---
+    cls_loss = F.cross_entropy(cls_logits, labels)
+
+    # --- 회귀 손실 (positive만, 해당 클래스의 4개 좌표만) ---
+    if is_pos.sum() > 0:
+        S = reg.shape[0]
+        reg = reg.reshape(S, -1, 4)
+        pos_idx = torch.where(is_pos)[0]
+        pos_labels = labels[pos_idx]
+        reg_pos = reg[pos_idx, pos_labels]           # 해당 클래스 좌표
+        reg_loss = F.smooth_l1_loss(reg_pos, reg_targets[pos_idx], beta=1.0)
+    else:
+        reg_loss = torch.tensor(0.0, device=feat.device)
+
+    return cls_loss + reg_loss

model.py

@@ -0,0 +1,230 @@
+"""
+Faster R-CNN 밑바닥 구현 — [3/5] 모델
+==========================================
+전체 구조:
+
+  이미지
+    │  [백본: ResNet50 (ImageNet 사전학습)]
+    ▼
+  특징맵 (stride 16)
+    │
+    ├─▶ [RPN] ── 앵커마다 (객체 여부, 박스 보정) 예측 ── 후보영역(proposal) 생성
+    │
+    ▼
+  [RoI Align] ── 각 후보영역을 고정 크기(7x7) 특징으로 추출
+    │
+    ▼
+  [RoI Head] ── (클래스 분류, 클래스별 박스 보정) 최종 예측
+
+2-stage 탐지기의 정석 구조. RPN이 "어디에 뭔가 있다"를,
+RoI Head가 "그게 무엇이고 정확한 위치는 어디"를 담당한다.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision
+from torchvision.ops import roi_align
+
+from box_utils import (generate_anchors, shift_anchors, box_iou,
+                       encode_boxes, decode_boxes, clip_boxes, nms)
+
+
+# ---------------------------------------------------------------
+# 백본: ResNet50의 conv1~layer3까지 (stride 16 특징맵)
+# ---------------------------------------------------------------
+class Backbone(nn.Module):
+    def __init__(self):
+        super().__init__()
+        resnet = torchvision.models.resnet50(weights="IMAGENET1K_V1")
+        # layer4는 RoI Head에서 쓰고, 여기선 layer3까지 → stride 16
+        self.body = nn.Sequential(
+            resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool,
+            resnet.layer1, resnet.layer2, resnet.layer3,
+        )
+        self.out_channels = 1024  # layer3 출력 채널
+        self.stride = 16
+
+        # 초기 레이어는 동결(작은 데이터셋 과적합·불안정 방지)
+        for p in self.body[:5].parameters():
+            p.requires_grad = False
+
+    def forward(self, x):
+        return self.body(x)
+
+
+# ---------------------------------------------------------------
+# RPN (Region Proposal Network)
+# ---------------------------------------------------------------
+class RPN(nn.Module):
+    def __init__(self, in_channels=1024, num_anchors=9):
+        super().__init__()
+        self.conv = nn.Conv2d(in_channels, 512, 3, padding=1)
+        # 앵커마다: 객체/배경 2점수 → 여기선 objectness 1개(logit)로 단순화
+        self.cls = nn.Conv2d(512, num_anchors, 1)          # objectness
+        self.reg = nn.Conv2d(512, num_anchors * 4, 1)       # 박스 보정
+        self.num_anchors = num_anchors
+
+        for layer in [self.conv, self.cls, self.reg]:
+            nn.init.normal_(layer.weight, std=0.01)
+            nn.init.constant_(layer.bias, 0)
+
+    def forward(self, feat):
+        t = F.relu(self.conv(feat))
+        logits = self.cls(t)   # [B, A, H, W]
+        deltas = self.reg(t)   # [B, A*4, H, W]
+
+        B, _, H, W = logits.shape
+        # [B, H*W*A] 형태로 정리
+        logits = logits.permute(0, 2, 3, 1).reshape(B, -1)
+        deltas = deltas.permute(0, 2, 3, 1).reshape(B, -1, 4)
+        return logits, deltas, (H, W)
+
+
+# ---------------------------------------------------------------
+# RoI Head (분류 + 박스 회귀)
+# ---------------------------------------------------------------
+class RoIHead(nn.Module):
+    def __init__(self, num_classes, in_channels=1024, roi_size=7):
+        super().__init__()
+        # layer4 대신 간단한 FC 헤드로 구성(학습 가벼움)
+        self.roi_size = roi_size
+        flat = in_channels * roi_size * roi_size
+        self.fc = nn.Sequential(
+            nn.Linear(flat, 1024), nn.ReLU(inplace=True),
+            nn.Linear(1024, 1024), nn.ReLU(inplace=True),
+        )
+        self.cls = nn.Linear(1024, num_classes)             # 클래스 분류
+        self.reg = nn.Linear(1024, num_classes * 4)          # 클래스별 박스 보정
+        self.num_classes = num_classes
+
+        nn.init.normal_(self.cls.weight, std=0.01)
+        nn.init.normal_(self.reg.weight, std=0.001)
+        nn.init.constant_(self.cls.bias, 0)
+        nn.init.constant_(self.reg.bias, 0)
+
+    def forward(self, feat, rois, stride):
+        """
+        feat  : 백본 특징맵 [B,C,H,W]
+        rois  : 후보영역 [N,4] (이미지 좌표)
+        """
+        # roi_align: 각 후보영역을 7x7 고정 크기 특징으로 추출
+        # batch index 0 (batch_size=1 가정) 를 앞에 붙인다
+        batch_idx = torch.zeros((rois.shape[0], 1), device=rois.device)
+        rois_b = torch.cat([batch_idx, rois], dim=1)  # [N,5]
+        pooled = roi_align(feat, rois_b,
+                           output_size=(self.roi_size, self.roi_size),
+                           spatial_scale=1.0 / stride,
+                           sampling_ratio=2)
+        x = pooled.flatten(1)
+        x = self.fc(x)
+        return self.cls(x), self.reg(x)
+
+
+# ---------------------------------------------------------------
+# 전체 모델
+# ---------------------------------------------------------------
+class FasterRCNN(nn.Module):
+    def __init__(self, num_classes):
+        super().__init__()
+        self.backbone = Backbone()
+        self.rpn = RPN(self.backbone.out_channels)
+        self.head = RoIHead(num_classes, self.backbone.out_channels)
+        self.num_classes = num_classes
+
+        self.base_anchors = generate_anchors()  # 9개
+        self.stride = self.backbone.stride
+
+        # 학습/추론 하이퍼파라미터
+        self.rpn_pre_nms = 12000
+        self.rpn_post_nms_train = 2000
+        self.rpn_post_nms_test = 300
+        self.rpn_nms_thresh = 0.7
+
+    def _anchors_for(self, feat_h, feat_w, device):
+        a = shift_anchors(self.base_anchors, feat_h, feat_w, self.stride)
+        return a.to(device)
+
+    def _proposals(self, rpn_logits, rpn_deltas, anchors, img_hw, training):
+        """RPN 출력 → NMS 거친 후보영역(proposal) 생성."""
+        scores = torch.sigmoid(rpn_logits[0])         # [K]
+        deltas = rpn_deltas[0]                          # [K,4]
+        proposals = decode_boxes(deltas, anchors)
+        proposals = clip_boxes(proposals, img_hw[0], img_hw[1])
+
+        # 점수 상위만 추린 뒤 NMS
+        n_pre = min(self.rpn_pre_nms, scores.numel())
+        top = scores.topk(n_pre).indices
+        proposals, scores = proposals[top], scores[top]
+
+        keep = nms(proposals, scores, self.rpn_nms_thresh)
+        n_post = self.rpn_post_nms_train if training else self.rpn_post_nms_test
+        keep = keep[:n_post]
+        return proposals[keep], scores[keep]
+
+    def forward(self, image, target=None):
+        """
+        image  : [1,3,H,W] 단일 이미지(batch_size=1)
+        target : 학습 시 {'boxes','labels'}, 추론 시 None
+        """
+        device = image.device
+        img_h, img_w = image.shape[-2:]
+        feat = self.backbone(image)
+        _, _, fh, fw = feat.shape
+
+        anchors = self._anchors_for(fh, fw, device)
+        rpn_logits, rpn_deltas, _ = self.rpn(feat)
+
+        proposals, _ = self._proposals(
+            rpn_logits, rpn_deltas, anchors, (img_h, img_w),
+            training=self.training)
+
+        if self.training:
+            # 학습 경로: 손실 계산 (train.py 의 헬퍼가 담당)
+            return {
+                "feat": feat, "anchors": anchors,
+                "rpn_logits": rpn_logits[0], "rpn_deltas": rpn_deltas[0],
+                "proposals": proposals, "stride": self.stride,
+            }
+        else:
+            # 추론 경로: 최종 탐지 결과
+            cls_logits, reg = self.head(feat, proposals, self.stride)
+            return self._postprocess(cls_logits, reg, proposals, (img_h, img_w))
+
+    @torch.no_grad()
+    def _postprocess(self, cls_logits, reg, proposals, img_hw,
+                     score_thresh=0.05, nms_thresh=0.3, max_det=100):
+        """RoI Head 출력 → 클래스별 NMS → 최종 박스/라벨/점수."""
+        probs = F.softmax(cls_logits, dim=1)       # [N, C]
+        N, C = probs.shape
+        reg = reg.reshape(N, C, 4)
+
+        all_boxes, all_scores, all_labels = [], [], []
+        for c in range(1, C):  # 0=배경 제외
+            scores_c = probs[:, c]
+            mask = scores_c > score_thresh
+            if mask.sum() == 0:
+                continue
+            boxes_c = decode_boxes(reg[mask, c], proposals[mask])
+            boxes_c = clip_boxes(boxes_c, img_hw[0], img_hw[1])
+            scores_c = scores_c[mask]
+
+            keep = nms(boxes_c, scores_c, nms_thresh)
+            all_boxes.append(boxes_c[keep])
+            all_scores.append(scores_c[keep])
+            all_labels.append(torch.full((keep.numel(),), c,
+                                         dtype=torch.int64, device=boxes_c.device))
+
+        if not all_boxes:
+            return {"boxes": torch.empty((0, 4)), "labels": torch.empty((0,), dtype=torch.int64),
+                    "scores": torch.empty((0,))}
+
+        boxes = torch.cat(all_boxes)
+        scores = torch.cat(all_scores)
+        labels = torch.cat(all_labels)
+
+        # 전체에서 점수 상위 max_det개만
+        if scores.numel() > max_det:
+            top = scores.topk(max_det).indices
+            boxes, scores, labels = boxes[top], scores[top], labels[top]
+        return {"boxes": boxes, "labels": labels, "scores": scores}

train.py

@@ -0,0 +1,182 @@
+"""
+Faster R-CNN 밑바닥 구현 — [5/5] 학습 + 평가
+================================================
+전체 파이프라인:
+  학습:  이미지 → 모델(train) → RPN 손실 + RoI 손실 → 역전파
+  평가:  이미지 → 모델(eval) → 탐지 결과 → mAP@0.5 계산
+
+실행 예:
+  python train.py --voc_root /path/VOCdevkit/VOC2007 --epochs 12
+  python train.py --voc_root /path/VOCdevkit/VOC2007 --eval_only --ckpt frcnn.pth
+
+주의:
+  - batch_size=1 로 설계(이미지 크기가 제각각이라 단순화).
+  - GPU 권장. CPU로도 돌지만 매우 느리다.
+"""
+
+import argparse
+import torch
+from torch.utils.data import DataLoader
+
+from dataset import VOCDataset, collate_fn, NUM_CLASSES, VOC_CLASSES
+from model import FasterRCNN
+from losses import rpn_loss, roi_loss
+from box_utils import box_iou
+
+
+# ---------------------------------------------------------------
+# 학습 한 에폭
+# ---------------------------------------------------------------
+def train_one_epoch(model, loader, optimizer, device, epoch):
+    model.train()
+    running = 0.0
+    for i, (imgs, targets) in enumerate(loader):
+        img = imgs[0].to(device).unsqueeze(0)          # [1,3,H,W]
+        gt_boxes = targets[0]["boxes"].to(device)
+        gt_labels = targets[0]["labels"].to(device)
+        if gt_boxes.numel() == 0:
+            continue
+
+        out = model(img)  # training=True → 중간 산출물 반환
+        img_hw = img.shape[-2:]
+
+        l_rpn = rpn_loss(out["rpn_logits"], out["rpn_deltas"],
+                         out["anchors"], gt_boxes, img_hw)
+        l_roi = roi_loss(model.head, out["feat"], out["stride"],
+                         out["proposals"], gt_boxes, gt_labels)
+        loss = l_rpn + l_roi
+
+        optimizer.zero_grad()
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), 10.0)  # 폭주 방지
+        optimizer.step()
+
+        running += loss.item()
+        if (i + 1) % 100 == 0:
+            print(f"[epoch {epoch}] iter {i+1}/{len(loader)} "
+                  f"loss {running/(i+1):.4f} (rpn {l_rpn.item():.3f} roi {l_roi.item():.3f})")
+    return running / max(1, len(loader))
+
+
+# ---------------------------------------------------------------
+# 평가: VOC 스타일 mAP@0.5
+# ---------------------------------------------------------------
+@torch.no_grad()
+def evaluate(model, loader, device, iou_thresh=0.5):
+    model.eval()
+    # 클래스별 (점수, 맞음여부) 수집 + 정답 개수
+    preds = {c: [] for c in range(1, NUM_CLASSES)}
+    n_gt = {c: 0 for c in range(1, NUM_CLASSES)}
+
+    for imgs, targets in loader:
+        img = imgs[0].to(device).unsqueeze(0)
+        det = model(img)  # eval → {boxes, labels, scores}
+        gt_boxes = targets[0]["boxes"].to(device)
+        gt_labels = targets[0]["labels"].to(device)
+
+        for c in range(1, NUM_CLASSES):
+            gmask = gt_labels == c
+            gboxes = gt_boxes[gmask]
+            n_gt[c] += gboxes.shape[0]
+
+            pmask = det["labels"] == c
+            pboxes = det["boxes"][pmask]
+            pscores = det["scores"][pmask]
+            if pboxes.numel() == 0:
+                continue
+
+            order = pscores.argsort(descending=True)
+            pboxes, pscores = pboxes[order], pscores[order]
+
+            matched = torch.zeros(gboxes.shape[0], dtype=torch.bool)
+            for k in range(pboxes.shape[0]):
+                if gboxes.numel() == 0:
+                    preds[c].append((pscores[k].item(), 0))
+                    continue
+                ious = box_iou(pboxes[k:k+1], gboxes).squeeze(0)
+                best_iou, best_j = ious.max(0)
+                if best_iou >= iou_thresh and not matched[best_j]:
+                    preds[c].append((pscores[k].item(), 1))  # TP
+                    matched[best_j] = True
+                else:
+                    preds[c].append((pscores[k].item(), 0))  # FP
+
+    # 클래스별 AP → mAP
+    aps = []
+    for c in range(1, NUM_CLASSES):
+        ap = _voc_ap(preds[c], n_gt[c])
+        aps.append(ap)
+        print(f"  {VOC_CLASSES[c-1]:12s} AP = {ap:.4f}")
+    mAP = sum(aps) / len(aps)
+    print(f"  {'mAP@0.5':12s} = {mAP:.4f}")
+    return mAP
+
+
+def _voc_ap(pred_list, n_gt):
+    """(점수, TP여부) 목록으로 precision-recall 곡선 아래 넓이(AP) 계산."""
+    if n_gt == 0 or len(pred_list) == 0:
+        return 0.0
+    pred_list.sort(key=lambda x: x[0], reverse=True)
+    tp = torch.tensor([p[1] for p in pred_list], dtype=torch.float32)
+    fp = 1 - tp
+    tp_cum = torch.cumsum(tp, 0)
+    fp_cum = torch.cumsum(fp, 0)
+    recall = tp_cum / n_gt
+    precision = tp_cum / (tp_cum + fp_cum).clamp(min=1e-6)
+
+    # 11-point 보간 (VOC2007 방식)
+    ap = 0.0
+    for t in torch.linspace(0, 1, 11):
+        mask = recall >= t
+        p = precision[mask].max().item() if mask.any() else 0.0
+        ap += p / 11.0
+    return ap
+
+
+# ---------------------------------------------------------------
+# 메인
+# ---------------------------------------------------------------
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--voc_root", required=True, help="VOCdevkit/VOC2007 경로")
+    ap.add_argument("--epochs", type=int, default=12)
+    ap.add_argument("--lr", type=float, default=1e-3)
+    ap.add_argument("--ckpt", default="frcnn.pth")
+    ap.add_argument("--eval_only", action="store_true")
+    args = ap.parse_args()
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print("device:", device)
+
+    model = FasterRCNN(NUM_CLASSES).to(device)
+
+    if args.eval_only:
+        model.load_state_dict(torch.load(args.ckpt, map_location=device))
+        test_ds = VOCDataset(args.voc_root, split="test")
+        test_loader = DataLoader(test_ds, batch_size=1, shuffle=False,
+                                 collate_fn=collate_fn, num_workers=4)
+        evaluate(model, test_loader, device)
+        return
+
+    # 학습
+    train_ds = VOCDataset(args.voc_root, split="trainval")
+    train_loader = DataLoader(train_ds, batch_size=1, shuffle=True,
+                              collate_fn=collate_fn, num_workers=4)
+
+    params = [p for p in model.parameters() if p.requires_grad]
+    optimizer = torch.optim.SGD(params, lr=args.lr, momentum=0.9,
+                                weight_decay=5e-4)
+    scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=8, gamma=0.1)
+
+    for epoch in range(1, args.epochs + 1):
+        avg = train_one_epoch(model, train_loader, optimizer, device, epoch)
+        scheduler.step()
+        print(f"[epoch {epoch}] avg loss = {avg:.4f}")
+        torch.save(model.state_dict(), args.ckpt)
+        print(f"  checkpoint saved → {args.ckpt}")
+
+    print("학습 완료. 평가하려면 --eval_only 로 실행하세요.")
+
+
+if __name__ == "__main__":
+    main()

yolo_infer.py

@@ -0,0 +1,88 @@
+"""
+YOLOv8 추론 스크립트 (Ultralytics)
+=====================================
+COCO 사전학습 YOLOv8로 이미지에서 객체를 탐지하고 결과를 저장한다.
+앞서 만든 밑바닥 Faster R-CNN(infer.py)과 같은 이미지로 비교해보기 좋다.
+
+설치:
+  pip install ultralytics
+
+실행 예:
+  # 이미지 한 장
+  python yolo_infer.py --image test.jpg
+
+  # 폴더 전체
+  python yolo_infer.py --image_dir ./samples --out_dir ./yolo_results
+
+  # 모델 크기 변경 (n < s < m < l < x, 뒤로 갈수록 정확·무거움)
+  python yolo_infer.py --image test.jpg --model yolov8s.pt
+
+  # 점수 임계값 조정 (기본 0.25)
+  python yolo_infer.py --image test.jpg --conf 0.4
+
+메모:
+  - 처음 실행 시 모델 가중치(yolov8n.pt 등)가 자동 다운로드된다.
+  - Faster R-CNN(20 VOC 클래스)과 달리 YOLOv8은 COCO 80 클래스를 탐지한다.
+  - 라이선스: Ultralytics YOLO는 AGPL-3.0. 상업적 폐쇄소스 사용 시 상용 라이선스 필요.
+"""
+
+import os
+import argparse
+from ultralytics import YOLO
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", default="yolov8n.pt",
+                    help="yolov8n/s/m/l/x.pt (없으면 자동 다운로드)")
+    ap.add_argument("--image", help="단일 이미지 경로")
+    ap.add_argument("--image_dir", help="이미지 폴더 경로")
+    ap.add_argument("--out_dir", default="./yolo_results", help="결과 저장 폴더")
+    ap.add_argument("--conf", type=float, default=0.25,
+                    help="이 신뢰도 이상만 표시 (기본 0.25)")
+    args = ap.parse_args()
+
+    # 모델 로드 (COCO 사전학습, 첫 실행 시 자동 다운로드)
+    print(f"모델 로드: {args.model}")
+    model = YOLO(args.model)
+
+    # 처리할 이미지 목록 구성
+    targets = []
+    if args.image:
+        targets.append(args.image)
+    if args.image_dir:
+        for fn in os.listdir(args.image_dir):
+            if fn.lower().endswith((".jpg", ".jpeg", ".png", ".bmp")):
+                targets.append(os.path.join(args.image_dir, fn))
+
+    if not targets:
+        print("이미지를 지정하세요: --image 또는 --image_dir")
+        return
+
+    os.makedirs(args.out_dir, exist_ok=True)
+
+    for path in targets:
+        # 추론 실행
+        results = model(path, conf=args.conf, verbose=False)
+        r = results[0]
+
+        # 탐지 개수와 클래스별 요약
+        n = len(r.boxes)
+        names = r.names  # 클래스 인덱스 → 이름
+        detected = {}
+        for cls_id in r.boxes.cls.tolist():
+            name = names[int(cls_id)]
+            detected[name] = detected.get(name, 0) + 1
+
+        # 박스 그려서 저장
+        out_path = os.path.join(args.out_dir, "yolo_" + os.path.basename(path))
+        r.save(filename=out_path)
+
+        summary = ", ".join(f"{k}×{v}" for k, v in detected.items()) or "없음"
+        print(f"  {os.path.basename(path)}: {n}개 탐지 ({summary}) → {out_path}")
+
+    print(f"완료. 결과는 {args.out_dir} 폴더에 저장됨.")
+
+
+if __name__ == "__main__":
+    main()