File size: 3,671 Bytes
2bfd19c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 | #!/usr/bin/env python3
"""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()
|