"""14장 · 실전: rfdetr 패키지 (3) ONNX 로 내보내기 · onnxruntime 추론 · 지연 시간 재기.

무엇을 하나
  1. 미세 조정한 모델(ch14_out_pretrained/checkpoint_best_total.pth)을 model.export() 로 ONNX 파일로 내보내고,
     파일 안(opset, 입출력 텐서, 함께 적힌 메타데이터)을 들여다본다.
  2. 전처리(리사이즈 · 정규화)를 직접 하고 onnxruntime 으로 돌려, PyTorch 모델의 출력과 수치로 비교한다 (check).
  3. 출력 텐서 dets(박스) · labels(클래스 로짓)를 직접 후처리해(시그모이드 → 질의 × 클래스 전체에서 상위 K)
     model.predict() 의 결과와 같은지 확인한다 (check).
  4. 지연 시간을 잰다: PyTorch(GPU FP32 · GPU FP16 자동 혼합 정밀도 · CPU), onnxruntime(CPU), 그리고 predict() 전체와
     패키지의 추론 전용 스냅숏 model.inference().
     예열 뒤 여러 번, 구성들을 번갈아 재서 중앙값과 분포를 보고, 순전파 사이에 200 ms 쉬었을 때 값이 달라지는지도 본다.
  5. 그림 ch14-latency.png

실행
  python ch14_export.py            # 본 실행: 약 5분 (그 가운데 3분은 model.inference() 스냅숏 두 개를 준비하는 시간.
                                   #   GPU · CPU 를 다른 작업과 나눠 쓰는 중에 잰 값이고, 기계가 붐빌 때는 9분까지 걸렸다)
  python ch14_export.py --quick    # 반복 횟수를 줄이고 스냅숏 준비를 건너뛴 연기 시험 (1 – 2분).
                                   #   미세 조정 결과가 없으면 COCO 사전 학습 Nano 로 대신한다
산출물은 ch14_export/ (ONNX 파일) 과 ch14_export_results.json 에 저장된다.

필요한 패키지 (이 장에서만): pip install "rfdetr[onnx]"   (onnx · onnxruntime. rfdetr 1.12.1 에서 확인)
ch14_finetune.py 의 load_finetuned · detections_to_prediction 을 가져다 쓴다.
"""

from __future__ import annotations

import argparse
import copy
import json
import os
import subprocess
import sys
import time
import warnings
from importlib.metadata import version

import numpy as np
import torch
import torch.nn.functional as F
from PIL import Image

from ch14_finetune import OUT_PRETRAINED, load_finetuned, pick_device
from ch14_make_coco import load_coco_split

warnings.filterwarnings("ignore")

EXPORT_DIR = "ch14_export"
RESULTS_FILE = "ch14_export_results.json"
CPU_THREADS = 8  # CPU 로 잴 때 쓰는 스레드 수 (PyTorch · onnxruntime 을 같게 맞춘다)


# --8<-- [start:preprocess]
def preprocess(image: np.ndarray, size: int, means, stds) -> np.ndarray:
    """그림 한 장을 모델 입력으로 바꾼다. predict() 가 안에서 하는 일과 같다.

    image: (H, W, 3) uint8 RGB  →  돌려주는 값: (1, 3, size, size) float32
      ① 0 – 255 → 0 – 1,  (H, W, 3) → (3, H, W)
      ② 가로세로 비율을 무시하고 size × size 로 쌍선형 보간 (antialias 없음)
      ③ 채널마다 (값 − 평균) / 표준편차  — ImageNet 의 평균 · 표준편차
    """
    x = torch.from_numpy(image).permute(2, 0, 1).float() / 255.0           # (3, H, W)
    x = F.interpolate(x[None], size=(size, size), mode="bilinear", align_corners=False)  # (1, 3, size, size)
    mean = torch.tensor(means).view(1, 3, 1, 1)
    std = torch.tensor(stds).view(1, 3, 1, 1)
    return ((x - mean) / std).numpy()
# --8<-- [end:preprocess]


# --8<-- [start:postprocess]
def postprocess(dets: np.ndarray, logits: np.ndarray, width: int, height: int, num_select: int = 300,
                threshold: float = 0.5):
    """모델의 날출력 한 장 분량을 탐지 결과로 바꾼다. 패키지의 PostProcess 와 같은 순서다.

    dets:   (Q, 4)  질의마다의 박스, 정규화 (cx, cy, w, h)          (Q = 질의 수 300)
    logits: (Q, C)  질의마다 · 클래스마다의 로짓 (시그모이드 전)     (C = 머리의 출력 칸 수)
    돌려주는 값: xyxy (n, 4) 원본 픽셀 좌표, scores (n,), class_ids (n,), query_ids (n,)
    """
    prob = 1.0 / (1.0 + np.exp(-logits))                 # ① 시그모이드: (Q, C) 칸마다 독립인 점수
    flat = prob.reshape(-1)                              # ② (Q·C,) 로 편다 — "질의 × 클래스" 쌍 전체
    order = np.argsort(-flat, kind="stable")[:num_select]  # ③ 점수 상위 num_select 개의 쌍
    scores = flat[order]
    query_ids = order // prob.shape[1]                   # ④ 편 번호 → 질의 번호 (몫)
    class_ids = order % prob.shape[1]                    #            → 클래스 번호 (나머지)
    cx, cy, w, h = dets[query_ids].T                     # ⑤ 그 질의의 박스를 가져와 (같은 질의가 두 번 뽑힐 수도 있다)
    xyxy = np.stack([cx - w / 2, cy - h / 2, cx + w / 2, cy + h / 2], axis=1)
    xyxy = xyxy * np.array([width, height, width, height], dtype=np.float32)  # ⑥ 원본 그림의 픽셀 단위로
    xyxy = np.clip(xyxy, 0.0, [width, height, width, height])                 #    그림 밖으로 나간 부분은 자른다
    keep = scores > threshold                            # ⑦ 문턱값보다 큰 것만. NMS 는 없다
    return xyxy[keep], scores[keep], class_ids[keep], query_ids[keep]
# --8<-- [end:postprocess]


# --8<-- [start:timer]
def measure(run, warmup: int, repeats: int, sync=None, sleep: float = 0.0) -> np.ndarray:
    """run() 을 warmup 번 헛돌린 뒤 repeats 번 재서, 한 번마다 걸린 시간(ms)의 배열을 돌려준다.

    sync:  GPU 는 명령을 "예약" 만 하고 바로 돌아오므로, 재기 전후에 torch.cuda.synchronize 로 끝나기를 기다려야 한다.
    sleep: 순전파 사이에 쉬는 시간(초). 논문은 GPU 가 전력 제한에 걸리지 않게 200 ms 를 쉬었다.
    """
    for _ in range(warmup):
        run()
    if sync:
        sync()
    times = np.zeros(repeats)
    for i in range(repeats):
        if sleep:
            time.sleep(sleep)
        start = time.perf_counter()
        run()
        if sync:
            sync()
        times[i] = (time.perf_counter() - start) * 1000.0
    return times


def summarize(times: np.ndarray) -> dict:
    return {"median": float(np.median(times)), "p10": float(np.percentile(times, 10)),
            "p90": float(np.percentile(times, 90)), "mean": float(times.mean()), "n": int(len(times))}
# --8<-- [end:timer]


def hand_example():
    """본문의 손계산 예: 질의 3개 · 클래스 2개짜리 날출력을 postprocess 에 넣어 본다 (그림 너비 200, 높이 100)."""
    dets = np.array([[0.5, 0.5, 0.2, 0.4], [0.25, 0.75, 0.5, 0.5], [0.8, 0.2, 0.1, 0.1]], dtype=np.float32)
    logits = np.array([[2.0, -1.0], [0.0, 1.0], [-3.0, -2.0]], dtype=np.float32)
    prob = 1.0 / (1.0 + np.exp(-logits))
    print("  손계산 예: 시그모이드 점수 (질의 3 × 클래스 2) =", [[round(float(v), 4) for v in row] for row in prob])
    order = np.argsort(-prob.reshape(-1), kind="stable")[:3]
    print(f"    편 번호 상위 3개 {order.tolist()} → 질의 {(order // 2).tolist()}, 클래스 {(order % 2).tolist()},"
          f" 점수 {[round(float(v), 4) for v in prob.reshape(-1)[order]]}")
    xyxy, scores, class_ids, query_ids = postprocess(dets, logits, width=200, height=100, num_select=3, threshold=0.5)
    for box, score, class_id, query in zip(xyxy, scores, class_ids, query_ids):
        print(f"    문턱값 0.5 통과: 질의 {query}, 클래스 {class_id}, 점수 {score:.4f}, xyxy {[round(float(v), 1) for v in box]}")


def hardware_names():
    cpu = "unknown CPU"
    try:
        with open("/proc/cpuinfo", encoding="utf-8") as f:
            cpu = next(line.split(":", 1)[1].strip() for line in f if line.startswith("model name"))
    except (OSError, StopIteration):
        pass
    gpu = torch.cuda.get_device_name(0) if torch.cuda.is_available() else "GPU 없음"
    return cpu, gpu


def gpu_utilization() -> str:
    """잴 때 GPU 를 다른 프로세스가 쓰고 있었는지 기록해 둔다 (nvidia-smi 가 없으면 빈 문자열)."""
    try:
        out = subprocess.run(["nvidia-smi", "--query-gpu=utilization.gpu,memory.used", "--format=csv,noheader"],
                             capture_output=True, text=True, timeout=10).stdout.strip()
        return out
    except (OSError, subprocess.SubprocessError):
        return ""


def load_model(quick: bool):
    """미세 조정한 모델을 읽는다. 없으면 --quick 에서만 COCO 사전 학습 Nano 로 대신한다."""
    if os.path.exists(os.path.join(OUT_PRETRAINED, "checkpoint_best_total.pth")):
        return load_finetuned(OUT_PRETRAINED), "fine-tuned Nano (Shape World, 3 classes)"
    if not quick:
        raise SystemExit(f"{OUT_PRETRAINED}/ 가 없습니다. 먼저 `python ch14_finetune.py` 를 실행하세요.")
    from rfdetr import RFDETRNano

    return RFDETRNano(), "COCO-pretrained Nano (no fine-tuned checkpoint found)"


def draw_latency(rows: list[dict], cpu: str, gpu: str, fig_dir: str):
    """구성마다 잰 시간의 분포를 상자 그림으로 (가로축 로그)."""
    import matplotlib

    matplotlib.use("Agg")
    import matplotlib.pyplot as plt

    fig, ax = plt.subplots(figsize=(10.5, 0.55 * len(rows) + 1.6))
    data = [r["times"] for r in rows][::-1]
    labels = [r["label"] for r in rows][::-1]
    colors = ["#0072b2" if r["device"] == "gpu" else "#d55e00" for r in rows][::-1]
    boxes = ax.boxplot(data, vert=False, whis=(10, 90), showfliers=False, patch_artist=True, widths=0.6)
    for patch, color in zip(boxes["boxes"], colors):
        patch.set_facecolor(color)
        patch.set_alpha(0.55)
    for median in boxes["medians"]:
        median.set_color("black")
    quiet = [r["quiet"] for r in rows][::-1]
    ax.plot(quiet, range(1, len(quiet) + 1), linestyle="none", marker="D", color="black", markersize=5,
            label="median of the quietest round")
    for y, (times, q) in enumerate(zip(data, quiet), start=1):
        ax.text(np.percentile(times, 90) * 1.08, y, f"{np.median(times):.1f} ms (quietest {q:.1f})", va="center", fontsize=8)
    ax.legend(fontsize=8, loc="upper right")
    ax.set_yticks(range(1, len(labels) + 1))
    ax.set_yticklabels(labels, fontsize=8)
    ax.set_xscale("log")
    ax.set_xlim(right=max(np.percentile(t, 90) for t in data) * 6)
    ax.set_xlabel("latency per image, batch 1 (ms, log scale)\nbox: 25-75%, whiskers: 10-90%, line: median over all rounds")
    ax.grid(alpha=0.3, axis="x", which="both")
    ax.set_title(f"RF-DETR Nano 384x384 on this laptop (blue: GPU, orange: CPU)\n{gpu} / {cpu}", fontsize=9)
    fig.tight_layout()
    os.makedirs(fig_dir, exist_ok=True)
    path = os.path.join(fig_dir, "ch14-latency.png")
    fig.savefig(path, dpi=120)
    plt.close(fig)
    print(f"  그림 저장: {path}")


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--quick", action="store_true", help="반복 횟수를 줄인 연기 시험")
    parser.add_argument("--data", default=None, help="COCO 형식 데이터셋 폴더 (기본 ch14_shapes_coco)")
    parser.add_argument("--fig-dir", default="figures")
    parser.add_argument("--seed", type=int, default=0)
    args = parser.parse_args()
    torch.manual_seed(args.seed)
    sys.stdout.reconfigure(line_buffering=True)
    dataset_dir = args.data or ("ch14_shapes_coco_quick" if args.quick else "ch14_shapes_coco")
    if not os.path.exists(os.path.join(dataset_dir, "test")):
        raise SystemExit(f"{dataset_dir}/ 가 없습니다. 먼저 `python ch14_make_coco.py{' --quick' if args.quick else ''}` 를 실행하세요.")
    test_paths, _ = load_coco_split(os.path.join(dataset_dir, "test"))

    import onnx
    import onnxruntime as ort

    device = pick_device()
    cpu_name, gpu_name = hardware_names()
    print(f"[0] 환경: rfdetr {version('rfdetr')}, torch {torch.__version__}, onnx {onnx.__version__},"
          f" onnxruntime {ort.__version__} (실행 제공자 {ort.get_available_providers()})")
    print(f"  GPU: {gpu_name} | CPU: {cpu_name} (코어 {os.cpu_count()}개)")

    model, model_name = load_model(args.quick)
    size = model.model.resolution
    print(f"[1] 모델: {model_name}, 입력 해상도 {size}×{size}")

    # --8<-- [start:export]
    print(f"[2] ONNX 로 내보내기 → {EXPORT_DIR}/")
    start = time.time()
    onnx_path = model.export(output_dir=EXPORT_DIR, verbose=False)  # 기본값: format="onnx", opset_version=17, batch_size=1
    print(f"  model.export() 가 돌려준 경로: {onnx_path}  ({time.time() - start:.1f}초,"
          f" {os.path.getsize(onnx_path) / 2**20:.1f} MB)")
    graph = onnx.load(str(onnx_path))
    print(f"  opset {graph.opset_import[0].version}, 노드 {len(graph.graph.node)}개")
    options = ort.SessionOptions()
    options.intra_op_num_threads = CPU_THREADS  # 연산 하나를 몇 개의 스레드로 나눠 계산할 것인가
    session = ort.InferenceSession(str(onnx_path), options, providers=["CPUExecutionProvider"])
    for tensor in session.get_inputs():
        print(f"  입력  {tensor.name!r}: 모양 {tensor.shape}, {tensor.type}")
    for tensor in session.get_outputs():
        print(f"  출력  {tensor.name!r}: 모양 {tensor.shape}, {tensor.type}")
    meta = json.loads({p.key: p.value for p in graph.metadata_props}["rfdetr_inference"])
    shown = ("input_shape", "means", "stds", "channel_order", "resize_interpolation", "resize_antialias",
             "outputs", "box_format", "class_names", "num_select")
    print("  파일에 함께 적힌 메타데이터(일부):", json.dumps({k: meta[k] for k in shown}, ensure_ascii=False))
    # --8<-- [end:export]

    # --8<-- [start:parity]
    print("[3] onnxruntime 추론 vs PyTorch 순전파 (같은 입력 텐서)")
    image = np.asarray(Image.open(test_paths[0]).convert("RGB"))  # (192, 192, 3) uint8
    height, width = image.shape[:2]
    reference = model.predict(test_paths[0], threshold=0.5)        # 비교 기준. (처음 부를 때 모델이 GPU 로 옮겨진다)
    x = preprocess(image, size, model.means, model.stds)           # (1, 3, 384, 384)
    dets, logits = session.run(["dets", "labels"], {"input": x})   # 이름으로 꺼낸다: 둘 다 (1, 300, 4) 일 수 있다!
    net = model.model.model.eval()                                  # 실제 nn.Module. eval() 을 잊지 않는다
    with torch.no_grad():
        out = net(torch.from_numpy(x).to(model.model.device))      # {"pred_boxes": (1, 300, 4), "pred_logits": (1, 300, C)}
    torch_boxes = out["pred_boxes"].float().cpu().numpy()[0]        # (300, 4)
    torch_logits = out["pred_logits"].float().cpu().numpy()[0]      # (300, C)
    box_diff = np.abs(dets[0] - torch_boxes).max(axis=1)            # 질의마다의 박스 차이 (300,)
    logit_diff = np.abs(logits[0] - torch_logits).max(axis=1)
    best = (1.0 / (1.0 + np.exp(-logits[0]))).max(axis=1)           # 질의마다의 최고 점수 (300,)
    confident = best > 0.05                                         # "쓸모 있는" 질의
    differ = box_diff > 1e-3
    r, g, b = (int(v) for v in image[0, 0])
    print(f"  전처리 예: 왼쪽 위 픽셀 RGB ({r}, {g}, {b}) → 정규화 뒤 {[round(float(v), 4) for v in x[0, :, 0, 0]]}"
          f"  (R 채널 손계산: ({r}/255 − 0.485)/0.229 = {(r / 255 - 0.485) / 0.229:.4f})")
    print(f"  입력 {x.shape} → dets {dets.shape}, labels {logits.shape}")
    print(f"  check (점수 0.05 초과 질의 {int(confident.sum())}개): 박스 최대 차이 {box_diff[confident].max():.1e},"
          f" 로짓 최대 차이 {logit_diff[confident].max():.1e}  (PyTorch {device} vs onnxruntime CPU)")
    print(f"  질의 300개 전체: 박스 최대 차이 {box_diff.max():.1e}, 로짓 최대 차이 {logit_diff.max():.1e}"
          f" | 박스 차이가 1e-3 을 넘는 질의 {int(differ.sum())}개, 그 질의들의 최고 점수 {best[differ].max() if differ.any() else 0.0:.3f}")
    diff_boxes, diff_logits = float(box_diff[confident].max()), float(logit_diff[confident].max())
    # --8<-- [end:parity]

    print("[4] 날출력을 직접 후처리 vs model.predict()")
    hand_example()
    xyxy, scores, class_ids, query_ids = postprocess(dets[0], logits[0], width, height, threshold=0.5)
    names = meta["class_names"]
    print(f"  로짓 (Q, C) = {logits[0].shape} → 쌍 {logits[0].size}개 가운데 상위 300개 → 문턱값 0.5 를 넘는 것 {len(scores)}개")
    for box, score, class_id, query in zip(xyxy, scores, class_ids, query_ids):
        name = names[class_id] if class_id < len(names) else f"slot {class_id}"
        print(f"    질의 {query:3d} · 클래스 {class_id} ({name}): 점수 {score:.4f}, xyxy {[round(float(v), 1) for v in box]}")
    same = len(reference) == len(scores)
    diff_xyxy = float(np.abs(reference.xyxy - xyxy).max()) if same and len(scores) else float("nan")
    diff_score = float(np.abs(reference.confidence - scores).max()) if same and len(scores) else float("nan")
    print(f"  check: predict() 와 개수 같음 {same}, 클래스 같음 {same and reference.class_id.tolist() == class_ids.tolist()},"
          f" 박스 최대 차이 {diff_xyxy:.1e} 픽셀, 점수 최대 차이 {diff_score:.1e}")
    probabilities = 1.0 / (1.0 + np.exp(-logits[0]))
    print(f"  질의마다 가장 높은 점수의 분포: 0.5 초과 {int((probabilities.max(1) > 0.5).sum())}개,"
          f" 0.05 이하 {int((probabilities.max(1) <= 0.05).sum())}개 (질의 {len(probabilities)}개 가운데)")

    # --8<-- [start:latency]
    print("[5] 지연 시간 (배치 1, 그림 1장당 ms)")
    rounds = 2 if args.quick else 10              # 구성들을 이 횟수만큼 번갈아 돌며 잰다
    gpu_n, cpu_n = (5, 2) if args.quick else (20, 4)  # 한 라운드에서 구성 하나를 재는 횟수 (GPU, CPU)
    x_cpu = torch.from_numpy(x)
    default_threads = torch.get_num_threads()     # PyTorch 의 기본 스레드 수 (보통 코어 수)
    configs = []                                  # 잴 구성의 목록: 이름 · 실행할 함수 · 한 라운드의 횟수 …

    def add(label, key, run, n, device_kind="gpu", sleep=0.0, threads=None):
        configs.append({"label": label, "key": key, "run": run, "n": n, "device": device_kind, "sleep": sleep,
                        "threads": threads})

    if device == "cuda":
        x_gpu = x_cpu.cuda()

        def forward_fp16():
            with torch.autocast("cuda", dtype=torch.float16):  # 자동 혼합 정밀도: 되는 연산은 FP16 으로
                return net(x_gpu)

        with torch.no_grad():
            out16 = forward_fp16()
        keep = torch.from_numpy(confident).to(x_gpu.device)  # 점수 0.05 초과 질의만 비교 (이유는 [3] 과 같다)
        print(f"  FP16 과 FP32 의 출력 차이 (점수 0.05 초과 질의):"
              f" 박스 최대 {float((out16['pred_boxes'].float() - out['pred_boxes'])[0][keep].abs().max()):.1e},"
              f" 로짓 최대 {float((out16['pred_logits'].float() - out['pred_logits'])[0][keep].abs().max()):.1e}")
        add("PyTorch GPU FP32, forward only", "torch_gpu_fp32", lambda: net(x_gpu), gpu_n)
        add("PyTorch GPU FP16 autocast, forward only", "torch_gpu_fp16", forward_fp16, gpu_n)
        add("PyTorch GPU FP32, forward only, 200 ms sleep between", "torch_gpu_fp32_sleep", lambda: net(x_gpu),
            max(2, gpu_n // 4), sleep=0.2)
        add("PyTorch GPU FP32, model.predict() end to end", "torch_gpu_predict",
            lambda: model.predict(image, threshold=0.5, include_source_image=False), gpu_n)
        # 패키지가 권하는 추론 전용 스냅숏: 고정 배치 · 고정 해상도로 추적(trace)해 CUDA 그래프로 재생한다.
        # 준비가 길어(분 단위) --quick 에서는 건너뛴다.
        for dtype, tag in (() if args.quick else (("float32", "FP32"), ("float16", "FP16"))):
            start = time.time()
            predictor = model.inference(dtype=dtype)  # RFDETRInference 를 돌려준다 (원래 model 은 그대로)
            print(f"  model.inference(dtype={dtype!r}) 준비 {time.time() - start:.1f}초")
            add(f"PyTorch GPU {tag}, model.inference() predictor end to end", f"torch_gpu_predictor_{tag.lower()}",
                lambda predictor=predictor: predictor.predict(image, threshold=0.5), gpu_n)
            if dtype == "float16":
                half = predictor.predict(image, threshold=0.5)
                print(f"  FP16 스냅숏의 예측: {len(half)}개, predict() 와 박스 최대 차이"
                      f" {float(np.abs(half.xyxy - reference.xyxy).max()) if len(half) == len(reference) else float('nan'):.2f} 픽셀")
    net_cpu = net if device == "cpu" else copy.deepcopy(net).cpu()
    add(f"onnxruntime CPU FP32 ({CPU_THREADS} threads), forward only", "ort_cpu_fp32",
        lambda: session.run(["dets", "labels"], {"input": x}), cpu_n, "cpu")
    add(f"PyTorch CPU FP32 ({CPU_THREADS} threads), forward only", "torch_cpu_fp32", lambda: net_cpu(x_cpu), cpu_n, "cpu",
        threads=CPU_THREADS)
    if default_threads != CPU_THREADS:
        add(f"PyTorch CPU FP32 ({default_threads} threads = default), forward only", "torch_cpu_fp32_default",
            lambda: net_cpu(x_cpu), 1, "cpu", threads=default_threads)

    # 기계를 다른 작업과 나눠 쓰면 부하가 시시각각 변한다. 구성 A 를 다 재고 B 를 재면 "그때 기계가 한가했는가" 가
    # 결과에 섞인다. 그래서 A, B, C … 를 조금씩 번갈아(라운드) 재서, 부하의 변화가 모든 구성에 고르게 묻게 한다.
    print(f"  라운드 {rounds}번 · 구성 {len(configs)}개를 번갈아 잰다. 시작할 때: load average {os.getloadavg()[0]:.1f}"
          f" (CPU 코어 {os.cpu_count()}개), GPU 사용률 · 메모리 {gpu_utilization() or '-'}")
    sync = torch.cuda.synchronize if device == "cuda" else None
    collected = {c["key"]: [] for c in configs}
    with torch.no_grad():
        for _ in range(rounds):
            for c in configs:
                if c["threads"]:
                    torch.set_num_threads(c["threads"])
                is_gpu = c["device"] == "gpu"
                collected[c["key"]].append(measure(c["run"], 3 if is_gpu else 1, c["n"], sync if is_gpu else None, c["sleep"]))
    torch.set_num_threads(default_threads)
    print(f"  끝났을 때: load average {os.getloadavg()[0]:.1f}, GPU 사용률 · 메모리 {gpu_utilization() or '-'}")
    # 라운드마다의 중앙값을 표로: 행 = 구성, 열 = 라운드. 어떤 라운드에서 모든 구성이 함께 느려졌다면 기계가 붐빈 것이다.
    medians = np.array([[np.median(t) for t in collected[c["key"]]] for c in configs])  # (구성 수, 라운드 수)
    relative = medians / np.median(medians, axis=1, keepdims=True)  # 구성마다 자기 중앙값으로 나눠 단위를 없앤다
    quiet = int(relative.mean(axis=0).argmin())                     # 모든 구성이 전체적으로 가장 빨랐던 라운드
    print("  라운드별 중앙값 (ms): " + " ".join(f"{'R' + str(r + 1):>8s}" for r in range(rounds)))
    for c, row in zip(configs, medians):
        print(f"    {c['key']:22s}" + " ".join(f"{v:8.1f}" for v in row))
    print(f"  가장 한가했던 라운드: R{quiet + 1}")
    rows = []
    print(f"  {'구성':58s} 전체 중앙값 |      10% |      90% | R{quiet + 1} 의 중앙값 | n")
    for c, row in zip(configs, medians):
        times = np.concatenate(collected[c["key"]])
        stats = summarize(times)
        rows.append({"label": c["label"], "key": c["key"], "device": c["device"], "times": times.tolist(),
                     "round_medians": row.tolist(), "quiet": float(row[quiet]), **stats})
        print(f"  {c['label']:58s} {stats['median']:10.2f} | {stats['p10']:8.2f} | {stats['p90']:8.2f} |"
              f" {row[quiet]:12.2f} | {stats['n']}")
    # --8<-- [end:latency]

    draw_latency(rows, cpu_name, gpu_name, args.fig_dir)
    with open(RESULTS_FILE, "w", encoding="utf-8") as f:
        json.dump({"model": model_name, "cpu": cpu_name, "gpu": gpu_name, "parity": {"boxes": diff_boxes, "logits": diff_logits},
                   "latency": rows}, f)
    print(f"  요약 저장: {RESULTS_FILE}")


if __name__ == "__main__":
    main()
