| """새 주제(부재 맥락) 용 3-fold 분할 + fold별 내부 검증 세트(inner_val) + 검증 보고서. |
| |
| 사용법: |
| python make_split3.py [--common ../common] [--data ../dacl10k_v2_devphase] [--workers N] |
| |
| 입력 (수정하지 않음): <common>/classes.json, <common>/gt_masks/<image>.npz (19,H,W bool), |
| <data>/annotations/{train,validation}/*.json (원래 split 확인용) |
| 출력 (이 스크립트 폴더): classes.json(복사), split_3fold.json, split3_report.md, image_stats.json(사진별 집계 캐시) |
| |
| - 층화 라벨: 사진마다 19개 클래스 포함 여부 (gt_masks 기준), iterstrat MultilabelStratifiedKFold(3, shuffle, seed 42) |
| - inner_val[k]: 시험 fold k 를 뺀 두 fold 사진 중 10%, 같은 19차원으로 iterstrat MultilabelStratifiedShuffleSplit(seed 42) |
| """ |
| import argparse |
| import glob |
| import json |
| import os |
| import shutil |
| from multiprocessing import Pool |
|
|
| import numpy as np |
|
|
| SEED = 42 |
| N_FOLDS = 3 |
| INNER = 0.10 |
| FLAG_PP = 1.0 |
|
|
|
|
| def image_stats(args): |
| path, ri, comp_idx = args |
| m = np.load(path)["mask"] |
| present = [bool(x.any()) for x in m] |
| anyc = m[comp_idx].any(0) |
| rust = m[ri] |
| return os.path.basename(path)[:-4], {"present": present, "npx": int(rust.size), "rust_px": int(rust.sum()), |
| "rust_on_comp": bool((rust & anyc).any())} |
|
|
|
|
| def main(): |
| try: |
| from iterstrat.ml_stratifiers import MultilabelStratifiedKFold, MultilabelStratifiedShuffleSplit |
| except ImportError: |
| raise SystemExit("iterstrat (iterative-stratification) 가 설치되어 있지 않습니다. 대체 방법을 쓰지 않고 중단합니다.") |
| here = os.path.dirname(os.path.abspath(__file__)) |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--common", default=os.path.join(here, "..", "common")) |
| ap.add_argument("--data", default=os.path.join(here, "..", "dacl10k_v2_devphase")) |
| ap.add_argument("--workers", type=int, default=6) |
| args = ap.parse_args() |
| common, data = os.path.abspath(args.common), os.path.abspath(args.data) |
| np.random.seed(SEED) |
|
|
| shutil.copyfile(os.path.join(common, "classes.json"), os.path.join(here, "classes.json")) |
| cl = json.load(open(os.path.join(here, "classes.json"), encoding="utf-8"))["classes"] |
| names_c = [c["name"] for c in cl] |
| comp_idx = [c["index"] for c in cl if c["type"] == "component"] |
| ri, wi = names_c.index("Rust"), names_c.index("Weathering") |
|
|
| orig = {} |
| for sp in ("train", "validation"): |
| for p in glob.glob(os.path.join(data, "annotations", sp, "*.json")): |
| orig[os.path.basename(p)[:-5]] = sp |
| names = sorted(orig) |
| assert len(names) == 7910, len(names) |
|
|
| cache = os.path.join(here, "image_stats.json") |
| if os.path.exists(cache): |
| st = json.load(open(cache, encoding="utf-8")) |
| else: |
| jobs = [(os.path.join(common, "gt_masks", n + ".npz"), ri, comp_idx) for n in names] |
| st = {} |
| with Pool(args.workers) as pool: |
| for i, (n, r) in enumerate(pool.imap_unordered(image_stats, jobs, chunksize=8)): |
| st[n] = r |
| if (i + 1) % 1000 == 0: |
| print(f"{i + 1}/{len(names)}", flush=True) |
| with open(cache, "w", encoding="utf-8") as f: |
| json.dump(st, f) |
|
|
| Y = np.array([st[n]["present"] for n in names], int) |
| X = np.zeros((len(names), 1)) |
| fold = np.zeros(len(names), int) |
| for k, (_, te) in enumerate(MultilabelStratifiedKFold(n_splits=N_FOLDS, shuffle=True, random_state=SEED).split(X, Y)): |
| fold[te] = k |
| inner = {} |
| for k in range(N_FOLDS): |
| pool_idx = np.where(fold != k)[0] |
| msss = MultilabelStratifiedShuffleSplit(n_splits=1, test_size=INNER, random_state=SEED) |
| _, va = next(msss.split(X[pool_idx], Y[pool_idx])) |
| inner[str(k)] = sorted(names[i] for i in pool_idx[va]) |
|
|
| with open(os.path.join(here, "split_3fold.json"), "w", encoding="utf-8") as f: |
| json.dump({"seed": SEED, "n_folds": N_FOLDS, |
| "stratify": "presence of 19 classes (14 damage + 5 component)", "grouping": "image", |
| "images": {n: {"fold": int(fold[i]), "orig_split": orig[n]} for i, n in enumerate(names)}, |
| "inner_val": inner}, f, indent=1) |
|
|
| |
| idx = {n: i for i, n in enumerate(names)} |
| F = range(N_FOLDS) |
| sel = {k: np.where(fold == k)[0] for k in F} |
| has_comp = Y[:, comp_idx].any(1) |
| rust_on = np.array([st[n]["rust_on_comp"] for n in names]) |
| rust_px = np.array([st[n]["rust_px"] for n in names], float) |
| npx = np.array([st[n]["npx"] for n in names], float) |
| L = ["# 3-fold 분할 검증 보고서", "", |
| f"- 사진 {len(names)}장 (train {sum(v == 'train' for v in orig.values())}, validation " |
| f"{sum(v == 'validation' for v in orig.values())}), 교량 ID 없음 → 사진 단위 분할", |
| f"- 층화: 19개 클래스 포함 여부 (gt_masks 기준), iterstrat MultilabelStratifiedKFold(n_splits=3, shuffle=True, random_state={SEED})", |
| f"- inner_val: 시험 fold k 를 뺀 두 fold 의 {INNER:.0%}, 같은 19차원으로 MultilabelStratifiedShuffleSplit(random_state={SEED})", |
| f"- ⚠️ = fold 간 포함 비율 차이 > {FLAG_PP}%p", "", |
| "## fold별 요약", "", "| 항목 | " + " | ".join(f"fold {k}" for k in F) + " | 전체 |", "|---" * (N_FOLDS + 2) + "|"] |
| L.append("| 사진 | " + " | ".join(str(len(sel[k])) for k in F) + f" | {len(names)} |") |
| L.append("| 원래 train / validation | " + " | ".join( |
| f"{sum(orig[names[i]] == 'train' for i in sel[k])} / {sum(orig[names[i]] == 'validation' for i in sel[k])}" for k in F) + " | 6935 / 975 |") |
| warns = [] |
|
|
| def row(label, mask, flag=True): |
| r = [mask[sel[k]].mean() * 100 for k in F] |
| spread = max(r) - min(r) |
| mark = " ⚠️" if flag and spread > FLAG_PP else "" |
| if mark: |
| warns.append(f"{label}: {spread:.2f}%p") |
| return f"| {label}{mark} | " + " | ".join(f"{int(mask[sel[k]].sum())} ({r[i]:.2f}%)" for i, k in enumerate(F)) \ |
| + f" | {int(mask.sum())} ({mask.mean() * 100:.2f}%) |" |
| L.append(row("부재 있는 사진", has_comp)) |
| L.append(row("녹(Rust) 있는 사진", Y[:, ri].astype(bool))) |
| L.append(row("녹이 부재 위에 있는 사진", rust_on)) |
| L.append(row("풍화(Weathering) 있는 사진", Y[:, wi].astype(bool))) |
| L.append("| 녹 픽셀 비율 | " + " | ".join(f"{rust_px[sel[k]].sum() / npx[sel[k]].sum() * 100:.3f}%" for k in F) |
| + f" | {rust_px.sum() / npx.sum() * 100:.3f}% |") |
| L += ["", "## 클래스별 포함 사진 수 (비율)", "", "| index | 클래스 | 종류 | " + " | ".join(f"fold {k}" for k in F) |
| + " | 전체 | fold 간 차이 (%p) |", "|---" * (N_FOLDS + 5) + "|"] |
| for c in cl: |
| j = c["index"] |
| r = [Y[sel[k], j].mean() * 100 for k in F] |
| spread = max(r) - min(r) |
| mark = " ⚠️" if spread > FLAG_PP else "" |
| if mark: |
| warns.append(f"{c['name']}: {spread:.2f}%p") |
| L.append(f"| {j} | {c['name']}{mark} | {'손상' if c['type'] == 'damage' else '부재'} | " |
| + " | ".join(f"{int(Y[sel[k], j].sum())} ({r[i]:.2f}%)" for i, k in enumerate(F)) |
| + f" | {int(Y[:, j].sum())} ({Y[:, j].mean() * 100:.2f}%) | {spread:.2f} |") |
| L += ["", "## inner_val (fold k 학습 시 체크포인트 선택용)", "", |
| "| 시험 fold | 학습 풀 사진 | inner_val 사진 | 실제 학습 사진 | inner_val 녹 있는 사진 | inner_val 부재 있는 사진 |", |
| "|---|---:|---:|---:|---:|---:|"] |
| for k in F: |
| iv = np.array([idx[n] for n in inner[str(k)]]) |
| pool_n = int((fold != k).sum()) |
| assert all(fold[iv] != k) |
| L.append(f"| {k} | {pool_n} | {len(iv)} ({len(iv) / pool_n:.1%}) | {pool_n - len(iv)} | " |
| f"{int(Y[iv, ri].sum())} ({Y[iv, ri].mean():.1%}) | {int(has_comp[iv].sum())} ({has_comp[iv].mean():.1%}) |") |
| L += ["", "## 경고", ""] + ([f"- ⚠️ {w}" for w in warns] or [f"- 없음 (모든 항목의 fold 간 차이 ≤ {FLAG_PP}%p)"]) + [""] |
| with open(os.path.join(here, "split3_report.md"), "w", encoding="utf-8") as f: |
| f.write("\n".join(L)) |
| print("warnings:", len(warns)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
