| |
| """Evaluate a single inference run: PSNR vs baseline, reuse rate, peak memory.""" |
|
|
| import argparse |
| import json |
| import re |
| import sys |
|
|
| _BASELINE_CACHE = {} |
|
|
|
|
| def load_video_frames(path, max_frames=None, stride=1): |
| import cv2 |
| import numpy as np |
|
|
| cap = cv2.VideoCapture(path) |
| frames = [] |
| idx = 0 |
| while True: |
| ret, img = cap.read() |
| if not ret: |
| break |
| if idx % stride == 0: |
| frames.append(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)) |
| if max_frames is not None and len(frames) >= max_frames: |
| break |
| idx += 1 |
| cap.release() |
| return np.stack(frames) if frames else None |
|
|
|
|
| def align_frames(gt, gen): |
| import cv2 |
| import numpy as np |
|
|
| n = min(len(gt), len(gen)) |
| gt = gt[:n] |
| gen = gen[:n] |
| if gt.shape[1:3] != gen.shape[1:3]: |
| h, w = gt.shape[1], gt.shape[2] |
| gen = np.stack([cv2.resize(f, (w, h)) for f in gen]) |
| return gt, gen |
|
|
|
|
| def psnr(gt, gen): |
| import numpy as np |
|
|
| gt, gen = align_frames(gt, gen) |
| mse = np.mean((gt.astype(np.float32) - gen.astype(np.float32)) ** 2) |
| if mse == 0: |
| return float("inf") |
| return 10 * np.log10(255**2 / mse) |
|
|
|
|
| def ssim_simple(gt, gen): |
| import numpy as np |
|
|
| gt, gen = align_frames(gt, gen) |
| gt_f = gt.astype(np.float32) / 255.0 |
| gen_f = gen.astype(np.float32) / 255.0 |
| mu_g = gt_f.mean() |
| mu_p = gen_f.mean() |
| var_g = gt_f.var() |
| var_p = gen_f.var() |
| cov = ((gt_f - mu_g) * (gen_f - mu_p)).mean() |
| c1, c2 = 0.01**2, 0.03**2 |
| return ((2 * mu_g * mu_p + c1) * (2 * cov + c2)) / ((mu_g**2 + mu_p**2 + c1) * (var_g + var_p + c2)) |
|
|
|
|
| def black_ratio(frames, thresh=5): |
| import numpy as np |
| return float(np.mean(frames.max(axis=-1) < thresh)) |
|
|
|
|
| def parse_log(log_path): |
| reuse_rates = [] |
| peak_gb = None |
| with open(log_path, "r", errors="ignore") as f: |
| text = f.read() |
| for m in re.finditer(r"reuse_rate=([\d.]+)%", text): |
| reuse_rates.append(float(m.group(1))) |
| m = re.search(r"Peak memory allocated:\s*([\d.]+)\s*GB", text) |
| if m: |
| peak_gb = float(m.group(1)) |
| avg_reuse = sum(reuse_rates) / len(reuse_rates) if reuse_rates else None |
| return avg_reuse, peak_gb |
|
|
|
|
| def parse_metric(metric_path): |
| with open(metric_path, "r") as f: |
| payload = json.load(f) |
| summary = payload.get("chunk_execution_summary", {}) |
| rates = [v["reuse_rate"] for v in summary.values()] |
| return (sum(rates) / len(rates) * 100) if rates else None |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--baseline", required=True) |
| parser.add_argument("--generated", required=True) |
| parser.add_argument("--log", required=True) |
| parser.add_argument("--metric", default="") |
| args = parser.parse_args() |
|
|
| gt = load_video_frames(args.baseline) |
| gen = load_video_frames(args.generated) |
| if gt is None or gen is None: |
| print("PSNR=NA,SSIM=NA,BLACK=NA,REUSE=NA,PEAK=NA") |
| return |
|
|
| p = psnr(gt, gen) |
| s = ssim_simple(gt, gen) |
| b = black_ratio(gen) |
| reuse, peak = parse_log(args.log) |
| if args.metric: |
| metric_reuse = parse_metric(args.metric) |
| if metric_reuse is not None: |
| reuse = metric_reuse |
|
|
| psnr_s = "inf" if p == float("inf") else f"{p:.4f}" |
| ssim_s = f"{s:.6f}" |
| black_s = f"{b:.6f}" |
| reuse_s = f"{reuse:.2f}" if reuse is not None else "NA" |
| peak_s = f"{peak:.2f}" if peak is not None else "NA" |
| print(f"PSNR={psnr_s}") |
| print(f"SSIM={ssim_s}") |
| print(f"BLACK={black_s}") |
| print(f"REUSE={reuse_s}") |
| print(f"PEAK={peak_s}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
