프로젝트 1 — 전처리 전후 YOLO 성능 비교 보고서

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

weights = Path("out_ch18_runs/parts/weights/best.pt")
if not weights.exists():
    raise SystemExit("best.pt 가 없습니다. 18차시 실습 2를 먼저 실행하세요")
model = YOLO("out_ch18_runs/parts/weights/best.pt")
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

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):
    """신뢰도 높은 것부터 같은 클래스의 정답과 짝짓고 (맞힌 것, 헛것, 놓친 것) 을 돌려준다."""
    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 detect(img):
    """추론 결과를 [(클래스번호, 신뢰도, (x1, y1, x2, y2)), ...] 로 돌려준다."""
    r = model.predict(img, imgsz=320, conf=0.25, device="cpu", verbose=False)[0]
    return [(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))]

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])))
print("검증용 사진", len(val), "장 · 정답 물체", sum(len(g) for _, _, g in val), "개")
print("모델의 클래스:", model.names)

def darken(img):
    return np.clip(img.astype(np.float64) * 0.3, 0, 255).astype(np.uint8)

def add_noise(img, rng, sigma=20):
    return np.clip(img.astype(np.float64) + rng.normal(0, sigma, img.shape), 0, 255).astype(np.uint8)

def make_condition(name):
    """조건 이름에 맞게 검증용 사진 11장을 바꾼 목록을 돌려준다."""
    rng = np.random.default_rng(1802)                 # 조건마다 새로 만든다 → 잡음 조건 둘이 같은 잡음
    out = []
    for _, img, _ in val:
        x = img
        if "어둡게" in name:
            x = darken(x)                             # 어둡게를 먼저
        if "잡음" in name:
            x = add_noise(x, rng)                     # 그다음 잡음
        out.append(x)
    return out

lut = np.array([((i / 255) ** 0.5) * 255 for i in range(256)]).round().astype(np.uint8)
TREATMENTS = {
    "그대로": lambda im: im,
    "밝기 보정": lambda im: cv2.LUT(im, lut),                                   # 감마 0.5
    "잡음 제거+밝기 보정": lambda im: cv2.LUT(cv2.GaussianBlur(im, (5, 5), 0), lut),   # 블러 먼저, 감마 나중
}
CONDITIONS = ["원본", "어둡게", "잡음", "어둡게+잡음"]
sets = {c: make_condition(c) for c in CONDITIONS}

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

for c in CONDITIONS:
    shown = ", ".join(f"{t} {mean_gray([f(im) for im in sets[c]])}" for t, f in TREATMENTS.items())
    print(f"{c:7} 평균 밝기 → {shown}")

rows = []
for c in CONDITIONS:
    for t, f in TREATMENTS.items():
        TP = FP = FN = 0
        for img, (_, _, gts) in zip(sets[c], val):
            tp, fp, fn = match(detect(f(img)), 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
        rows.append({"조건": c, "처리": t, "맞힘": TP, "헛것": FP, "놓침": FN,
                     "정밀도": round(P, 3), "재현율": round(R, 3), "F1": round(F1, 3)})
report = pd.DataFrame(rows)
print(report.to_string(index=False))

# pivot: 조건을 줄, 처리를 칸으로 놓은 F1 표. 칸의 차례는 TREATMENTS 의 차례로 맞춘다
f1 = report.pivot(index="조건", columns="처리", values="F1").loc[CONDITIONS, list(TREATMENTS)]
print(f1.to_string())
print()
best = f1.idxmax(axis=1)                              # 줄마다 가장 큰 값이 있는 칸 이름
for c in CONDITIONS:
    print(f"{c:7} 가장 좋은 처리: {best[c]} (F1 {float(f1.loc[c, best[c]]):.3f}, 그대로 {float(f1.loc[c, '그대로']):.3f})")

fig, ax = plt.subplots(figsize=(10, 4), layout="constrained")
x = np.arange(len(CONDITIONS))
for k, t in enumerate(TREATMENTS):
    ax.bar(x + (k - 1) * 0.27, f1[t], width=0.27, label=t)
ax.set_xticks(x, labels=CONDITIONS)
ax.set_ylim(0, 1.15)
ax.set_ylabel("F1")
ax.set_title("조건과 처리에 따른 F1 (검증용 11장, IoU 0.5, conf 0.25)")
ax.legend(loc="upper center", ncol=3)
plt.show()

pick = [k for k, (name, _, _) in enumerate(val) if name == "part_022.png"][0]   # 부품 넷이 놓인 그림
_, _, gts = val[pick]
tiles = []
for c in CONDITIONS:
    row = []
    for t, f in TREATMENTS.items():
        tile = f(sets[c][pick]).copy()
        preds = detect(tile)
        tp, fp, fn = match(preds, gts)
        for gc, (x1, y1, x2, y2) in gts:                                      # 정답: 초록 얇은 선
            cv2.rectangle(tile, (round(x1), round(y1)), (round(x2), round(y2)), (0, 255, 0), 1)
        for pc, p, (x1, y1, x2, y2) in preds:                                 # 찾은 상자: 빨강 굵은 선
            cv2.rectangle(tile, (int(x1), int(y1)), (int(x2), int(y2)), (0, 0, 255), 2)
        # 위에 검은 띠를 깔고 조건, 처리, 맞힘 수를 영어로 적는다(putText 는 한글을 못 쓴다)
        cv2.rectangle(tile, (0, 0), (319, 18), (0, 0, 0), -1)
        tag = {"원본": "orig", "어둡게": "dark", "잡음": "noise", "어둡게+잡음": "dark+noise"}[c]
        fix = {"그대로": "as is", "밝기 보정": "gamma", "잡음 제거+밝기 보정": "blur+gamma"}[t]
        cv2.putText(tile, f"{tag} / {fix}  hit {tp}/{len(gts)} fp {fp}", (4, 13),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.42, (255, 255, 255), 1)
        row.append(tile)
    tiles.append(cv2.hconcat(row))                    # hconcat: 가로로 잇기
sheet = cv2.vconcat(tiles)                            # vconcat: 세로로 잇기
print("격자 크기:", sheet.shape, "· 저장:", cv2.imwrite("out_ch18_report.png", sheet))

plt.figure(figsize=(10, 10))
plt.imshow(cv2.cvtColor(sheet, cv2.COLOR_BGR2RGB))
plt.title("part_022.png 의 조건(줄) × 처리(칸) 결과 (out_ch18_report.png)")
plt.axis("off")
plt.show()