실습 5 — 나쁜 조건 만들고 전처리로 되살리기

import os
from pathlib import Path
os.environ["YOLO_VERBOSE"] = "False"
from ultralytics import YOLO
import cv2
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

plt.rcParams["font.family"] = "Malgun Gothic"
plt.rcParams["axes.unicode_minus"] = False

root = Path("out_ch17_yolo")

def read_labels(label_path, w, h):
    """YOLO 라벨을 [(클래스번호, (x1, y1, x2, y2)), ...] 픽셀 상자로 읽는다."""
    boxes = []
    for line in label_path.read_text(encoding="utf-8").split("\n"):
        if line.strip():
            c, xc, yc, bw, bh = line.split()
            xc, yc, bw, bh = float(xc), float(yc), float(bw), float(bh)
            boxes.append((int(c), ((xc - bw / 2) * w, (yc - bh / 2) * h, (xc + bw / 2) * w, (yc + bh / 2) * h)))
    return boxes

# 검증용 사진과 정답을 한 번에 읽어 둔다: [(이름, 그림, 정답), ...]
val = []
for p in sorted((root / "images" / "val").glob("*.png")):
    img = cv2.imread(str(p))
    val.append((p.name, img, read_labels(root / "labels" / "val" / (p.stem + ".txt"), img.shape[1], img.shape[0])))

def darken(img):
    """밝기를 0.3 배로 낮춘다(노출이 모자란 사진)."""
    return np.clip(img.astype(np.float64) * 0.3, 0, 255).astype(np.uint8)

def add_noise(img, rng, sigma=20):
    """6차시의 꼴로 표준편차 sigma 의 잡음을 더한다."""
    return np.clip(img.astype(np.float64) + rng.normal(0, sigma, img.shape), 0, 255).astype(np.uint8)

rng = np.random.default_rng(1801)                    # 씨앗을 고정해 잡음이 늘 같게
sets = {"원본": [img for _, img, _ in val],
        "어둡게": [darken(img) for _, img, _ in val],
        "잡음": [add_noise(img, rng) for _, img, _ in val]}

def mean_gray(images):
    return round(float(np.mean([cv2.cvtColor(im, cv2.COLOR_BGR2GRAY).mean() for im in images])), 1)

for name, images in sets.items():
    print(f"{name:4} 사진 {len(images)}장 · 평균 밝기 {mean_gray(images)}")

model = YOLO("out_ch18_runs/parts/weights/best.pt")

def iou(a, b):
    w = min(a[2], b[2]) - max(a[0], b[0])
    h = min(a[3], b[3]) - max(a[1], b[1])
    inter = max(0, w) * max(0, h)
    union = (a[2] - a[0]) * (a[3] - a[1]) + (b[2] - b[0]) * (b[3] - b[1]) - inter
    return inter / union if union > 0 else 0.0

def match(preds, gts, thr=0.5):
    """실습 4와 같다: (맞힌 것, 헛것, 놓친 것)."""
    used, tp = set(), 0
    for c, conf, box in sorted(preds, key=lambda x: -x[1]):
        best, best_j = 0.0, None
        for j, (gc, gbox) in enumerate(gts):
            if j not in used and gc == c and iou(box, gbox) > best:
                best, best_j = iou(box, gbox), j
        if best >= thr:
            used.add(best_j)
            tp += 1
    return tp, len(preds) - tp, len(gts) - tp

def score(images):
    """그림 목록을 모델에 넣고 정답과 견줘 정밀도, 재현율, F1 을 돌려준다."""
    TP = FP = FN = 0
    for img, (_, _, gts) in zip(images, val):
        r = model.predict(img, imgsz=320, conf=0.25, device="cpu", verbose=False)[0]
        preds = [(int(c), float(p), tuple(float(v) for v in b))
                 for b, p, c in zip(r.boxes.xyxy.cpu().numpy(), r.boxes.conf.cpu().numpy(),
                                    r.boxes.cls.cpu().numpy().astype(int))]
        tp, fp, fn = match(preds, gts)
        TP, FP, FN = TP + tp, FP + fp, FN + fn
    P = TP / (TP + FP) if TP + FP else 0.0
    R = TP / (TP + FN)
    F1 = 2 * P * R / (P + R) if P + R else 0.0
    return {"정밀도": round(P, 3), "재현율": round(R, 3), "F1": round(F1, 3), "맞힘": TP, "헛것": FP}

for name, images in sets.items():
    print(f"{name:4}", score(images))

lut = np.array([((i / 255) ** 0.5) * 255 for i in range(256)]).round().astype(np.uint8)
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))

def fix_gamma(img):
    """감마 0.5 로 어두운 쪽을 올린다(5차시)."""
    return cv2.LUT(img, lut)

def fix_clahe(img):
    """밝기 채널(Y)에만 CLAHE 를 건다(5차시)."""
    ycc = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)
    ycc[:, :, 0] = clahe.apply(ycc[:, :, 0])
    return cv2.cvtColor(ycc, cv2.COLOR_YCrCb2BGR)

# (나쁜 조건, 손질 이름, 손질 함수) 를 차례로 시험한다
trials = [("어둡게", "감마 0.5", fix_gamma),
          ("어둡게", "CLAHE", fix_clahe),
          ("잡음", "Gaussian 5x5", lambda im: cv2.GaussianBlur(im, (5, 5), 0)),
          ("잡음", "Median 5", lambda im: cv2.medianBlur(im, 5)),
          ("잡음", "Gaussian 15x15", lambda im: cv2.GaussianBlur(im, (15, 15), 0))]   # 일부러 지나치게 센 블러

rows = [{"조건": name, "손질": "그대로", **score(images)} for name, images in sets.items()]
for cond, fix_name, fix in trials:
    fixed = [fix(im) for im in sets[cond]]
    rows.append({"조건": cond, "손질": fix_name, **score(fixed)})
    print(f"{cond:4} + {fix_name:15} 평균 밝기 {mean_gray(fixed):5}  →", rows[-1]["재현율"])

result = pd.DataFrame(rows)
print(result.to_string(index=False))

labels = [f"{r['조건']}\n{r['손질']}" for r in rows]
fig, ax = plt.subplots(figsize=(11, 4.2), layout="constrained")
x = np.arange(len(rows))
ax.bar(x - 0.2, result["재현율"], width=0.4, label="재현율")
ax.bar(x + 0.2, result["정밀도"], width=0.4, label="정밀도")
ax.set_xticks(x, labels=labels, fontsize=9)
ax.set_ylim(0, 1.15)
ax.set_title("조건과 손질에 따른 학습한 모델의 점수 (검증용 11장, IoU 0.5, conf 0.25)")
ax.legend(loc="upper center", ncol=2)
plt.show()