| |
| """Profile GmNet-S3 inference without training or dataset access.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| import platform |
| import sys |
| import time |
| from pathlib import Path |
| from typing import Any |
|
|
| import torch |
|
|
| REPO_ROOT = Path(__file__).resolve().parents[1] |
| if str(REPO_ROOT) not in sys.path: |
| sys.path.insert(0, str(REPO_ROOT)) |
|
|
| from gmnet.analysis import load_model_checkpoint |
| from gmnet.analysis.profiling import benchmark_model |
| from gmnet.analysis.profiling import percentile |
|
|
|
|
| DEFAULT_CHECKPOINT = Path("/nfs/ywang29/GmNet/gmnet_s3.npy") |
| DEFAULT_OUTPUT_DIR = Path("/tmp/gmnet_runs/e12_profile") |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--checkpoint", type=Path, default=DEFAULT_CHECKPOINT) |
| parser.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR) |
| parser.add_argument("--input-size", type=int, default=224) |
| parser.add_argument("--cuda-device", default="cuda:0") |
| parser.add_argument("--cuda-batches", type=int, nargs="+", default=[1, 32]) |
| parser.add_argument( |
| "--cuda-precisions", |
| nargs="+", |
| choices=("fp32", "bf16"), |
| default=["fp32", "bf16"], |
| ) |
| parser.add_argument("--cuda-warmup", type=int, default=30) |
| parser.add_argument("--cuda-iterations", type=int, default=100) |
| parser.add_argument("--skip-cuda", action="store_true") |
| parser.add_argument("--cpu", action="store_true") |
| parser.add_argument("--cpu-batches", type=int, nargs="+", default=[1]) |
| parser.add_argument("--cpu-precision", choices=("fp32", "bf16"), default="fp32") |
| parser.add_argument("--cpu-warmup", type=int, default=5) |
| parser.add_argument("--cpu-iterations", type=int, default=20) |
| parser.add_argument("--cpu-threads", type=int, default=min(os.cpu_count() or 1, 16)) |
| parser.add_argument("--onnx", action="store_true") |
| parser.add_argument("--onnx-runtime", action="store_true") |
| parser.add_argument("--onnx-opset", type=int, default=18) |
| parser.add_argument("--onnx-warmup", type=int, default=10) |
| parser.add_argument("--onnx-iterations", type=int, default=50) |
| return parser.parse_args() |
|
|
|
|
| def export_and_check_onnx( |
| model: torch.nn.Module, |
| *, |
| destination: Path, |
| input_size: int, |
| opset: int, |
| ) -> dict[str, Any]: |
| import onnx |
|
|
| destination.parent.mkdir(parents=True, exist_ok=True) |
| model.eval().cpu() |
| example = torch.randn(1, 3, input_size, input_size) |
| torch.onnx.export( |
| model, |
| example, |
| destination, |
| input_names=["images"], |
| output_names=["logits"], |
| dynamic_axes={"images": {0: "batch"}, "logits": {0: "batch"}}, |
| opset_version=opset, |
| do_constant_folding=True, |
| dynamo=False, |
| ) |
| graph = onnx.load(destination) |
| onnx.checker.check_model(graph) |
| return { |
| "status": "checked", |
| "path": str(destination), |
| "size_bytes": destination.stat().st_size, |
| "onnx_version": onnx.__version__, |
| "opset": opset, |
| "dynamic_batch": True, |
| "checker": "passed", |
| } |
|
|
|
|
| def benchmark_onnxruntime( |
| path: Path, |
| *, |
| model: torch.nn.Module, |
| input_size: int, |
| warmup_iterations: int, |
| measured_iterations: int, |
| threads: int, |
| ) -> tuple[dict[str, Any], dict[str, Any]]: |
| import numpy as np |
| import onnxruntime as ort |
|
|
| options = ort.SessionOptions() |
| options.intra_op_num_threads = threads |
| options.inter_op_num_threads = 1 |
| session = ort.InferenceSession( |
| str(path), |
| sess_options=options, |
| providers=["CPUExecutionProvider"], |
| ) |
| input_name = session.get_inputs()[0].name |
| inputs = np.random.default_rng(20260712).standard_normal( |
| (1, 3, input_size, input_size), dtype=np.float32 |
| ) |
| with torch.inference_mode(): |
| torch_output = model(torch.from_numpy(inputs)).detach().cpu().numpy() |
| ort_output = session.run(None, {input_name: inputs})[0] |
| absolute_error = np.abs(torch_output - ort_output) |
| for _ in range(warmup_iterations): |
| session.run(None, {input_name: inputs}) |
| timings = [] |
| for _ in range(measured_iterations): |
| started = time.perf_counter() |
| outputs = session.run(None, {input_name: inputs}) |
| timings.append((time.perf_counter() - started) * 1_000.0) |
| if not np.isfinite(outputs[0]).all(): |
| raise ValueError("ONNX Runtime produced non-finite output") |
| mean_ms = sum(timings) / len(timings) |
| measurement = { |
| "device": "onnxruntime-cpu", |
| "precision": "fp32", |
| "batch_size": 1, |
| "input_size": input_size, |
| "warmup_iterations": warmup_iterations, |
| "measured_iterations": measured_iterations, |
| "latency_mean_ms": mean_ms, |
| "latency_p50_ms": percentile(timings, 0.50), |
| "latency_p95_ms": percentile(timings, 0.95), |
| "throughput_mean_images_per_second": 1_000.0 / mean_ms, |
| "throughput_at_p50_images_per_second": ( |
| 1_000.0 / percentile(timings, 0.50) |
| ), |
| "peak_cuda_memory_mb": None, |
| "current_cuda_memory_mb": None, |
| } |
| runtime = { |
| "status": "completed", |
| "onnxruntime_version": ort.__version__, |
| "providers": session.get_providers(), |
| "intra_op_threads": threads, |
| "inter_op_threads": 1, |
| "numerical_parity": { |
| "max_absolute_error": float(absolute_error.max()), |
| "mean_absolute_error": float(absolute_error.mean()), |
| "top1_equal": bool( |
| np.array_equal(torch_output.argmax(1), ort_output.argmax(1)) |
| ), |
| }, |
| } |
| return measurement, runtime |
|
|
|
|
| def render_markdown(result: dict[str, Any]) -> str: |
| rows = [] |
| for measurement in result["measurements"]: |
| peak = measurement["peak_cuda_memory_mb"] |
| rows.append( |
| f"| {measurement['device']} | {measurement['precision']} | " |
| f"{measurement['batch_size']} | {measurement['latency_p50_ms']:.3f} | " |
| f"{measurement['latency_p95_ms']:.3f} | " |
| f"{measurement['throughput_mean_images_per_second']:.2f} | " |
| f"{peak:.2f} |" if peak is not None else |
| f"| {measurement['device']} | {measurement['precision']} | " |
| f"{measurement['batch_size']} | {measurement['latency_p50_ms']:.3f} | " |
| f"{measurement['latency_p95_ms']:.3f} | " |
| f"{measurement['throughput_mean_images_per_second']:.2f} | n/a |" |
| ) |
| checkpoint = result["checkpoint"] |
| onnx_audit = result["onnx"] |
| runtime_audit = result["onnxruntime"] |
| onnx_lines = [] |
| if onnx_audit["status"] == "checked": |
| onnx_lines.append( |
| f"- ONNX: checker passed at opset {onnx_audit['opset']}; artifact " |
| f"size is {onnx_audit['size_bytes']} bytes." |
| ) |
| if runtime_audit["status"] == "completed": |
| parity = runtime_audit["numerical_parity"] |
| onnx_lines.append( |
| "- ONNX Runtime parity: max absolute error " |
| f"{parity['max_absolute_error']:.6g}, top-1 equal " |
| f"{parity['top1_equal']}." |
| ) |
| return "\n".join( |
| [ |
| "# E12 Local Inference Profile", |
| "", |
| f"- Checkpoint: `{checkpoint['path']}` (`{checkpoint['sha256']}`).", |
| f"- Topology: `{checkpoint['selected_topology']}`.", |
| "- Runtime: eager PyTorch, inference mode, random normalized-shape input.", |
| "- CUDA measurements use CUDA events after warmup; CPU uses perf_counter.", |
| *onnx_lines, |
| "- INT8 is blocked: no validated full-model calibration/quantization " |
| "pipeline is available.", |
| "", |
| "| Device | Precision | Batch | p50 (ms) | p95 (ms) | " |
| "Mean throughput (image/s) | Peak CUDA memory (MiB) |", |
| "|---|---|---:|---:|---:|---:|---:|", |
| *rows, |
| "", |
| ] |
| ) |
|
|
|
|
| def main() -> int: |
| args = parse_args() |
| args.output_dir.mkdir(parents=True, exist_ok=True) |
| measurements = [] |
| checkpoint_audit: dict[str, Any] | None = None |
| cpu_model: torch.nn.Module | None = None |
|
|
| if not args.skip_cuda: |
| if not torch.cuda.is_available(): |
| raise RuntimeError("CUDA profiling requested but CUDA is unavailable") |
| torch.backends.cudnn.benchmark = True |
| model, checkpoint_audit = load_model_checkpoint( |
| args.checkpoint, device=args.cuda_device |
| ) |
| for precision in args.cuda_precisions: |
| for batch_size in args.cuda_batches: |
| measurements.append( |
| benchmark_model( |
| model, |
| device=args.cuda_device, |
| batch_size=batch_size, |
| input_size=args.input_size, |
| precision=precision, |
| warmup_iterations=args.cuda_warmup, |
| measured_iterations=args.cuda_iterations, |
| ) |
| ) |
| del model |
| torch.cuda.empty_cache() |
|
|
| if args.cpu: |
| torch.set_num_threads(args.cpu_threads) |
| cpu_model, cpu_audit = load_model_checkpoint(args.checkpoint, device="cpu") |
| checkpoint_audit = checkpoint_audit or cpu_audit |
| for batch_size in args.cpu_batches: |
| measurements.append( |
| benchmark_model( |
| cpu_model, |
| device="cpu", |
| batch_size=batch_size, |
| input_size=args.input_size, |
| precision=args.cpu_precision, |
| warmup_iterations=args.cpu_warmup, |
| measured_iterations=args.cpu_iterations, |
| ) |
| ) |
| onnx_audit: dict[str, Any] = {"status": "not_requested"} |
| onnxruntime_audit: dict[str, Any] = {"status": "not_requested"} |
| if args.onnx or args.onnx_runtime: |
| if cpu_model is None: |
| cpu_model, cpu_audit = load_model_checkpoint( |
| args.checkpoint, device="cpu" |
| ) |
| checkpoint_audit = checkpoint_audit or cpu_audit |
| onnx_path = args.output_dir / "gmnet_s3.onnx" |
| onnx_audit = export_and_check_onnx( |
| cpu_model, |
| destination=onnx_path, |
| input_size=args.input_size, |
| opset=args.onnx_opset, |
| ) |
| if args.onnx_runtime: |
| measurement, onnxruntime_audit = benchmark_onnxruntime( |
| onnx_path, |
| model=cpu_model, |
| input_size=args.input_size, |
| warmup_iterations=args.onnx_warmup, |
| measured_iterations=args.onnx_iterations, |
| threads=args.cpu_threads, |
| ) |
| measurements.append(measurement) |
| if not measurements or checkpoint_audit is None: |
| raise ValueError("no profiling target selected; enable CUDA or --cpu") |
|
|
| result = { |
| "schema_version": 1, |
| "experiment": "E12", |
| "status": "completed", |
| "method": "eager_inference_cuda_events_or_cpu_perf_counter", |
| "torch_version": torch.__version__, |
| "cuda_version": torch.version.cuda, |
| "cudnn_version": torch.backends.cudnn.version(), |
| "python_version": platform.python_version(), |
| "platform": platform.platform(), |
| "cpu_count": os.cpu_count(), |
| "cpu_threads_used": args.cpu_threads if args.cpu else None, |
| "checkpoint": checkpoint_audit, |
| "onnx": onnx_audit, |
| "onnxruntime": onnxruntime_audit, |
| "int8": { |
| "status": "blocked", |
| "reason": ( |
| "No validated full-model INT8 calibration and quantization " |
| "pipeline is available. Linear-only dynamic quantization is not " |
| "reported as whole-model INT8." |
| ), |
| }, |
| "measurements": measurements, |
| } |
| json_path = args.output_dir / "results.json" |
| markdown_path = args.output_dir / "RESULTS.md" |
| json_path.write_text(json.dumps(result, indent=2, sort_keys=True), encoding="utf-8") |
| markdown_path.write_text(render_markdown(result), encoding="utf-8") |
| print(json.dumps({"results": str(json_path), "markdown": str(markdown_path)})) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
