#!/usr/bin/env python3 """ 速度测试脚本 - 对比 CLIP 与 DeCLIP 在不同精度和 batch size 下的性能 测试矩阵： - 精度：FP32 PyTorch, FP16 PyTorch, FP16 TensorRT, FP8 TensorRT - Batch sizes: 1, 16, 64, 128 - 模型：CLIP (vanilla), DeCLIP (csa) 指标： - 延迟 (ms) - 吞吐量 (FPS) - 显存使用 (MB) Usage: # 测试单个模型和 batch size python benchmark.py --model-tag clip --batch-size 32 --cache-dir /path/to/clip.pt # 测试所有 batch sizes python benchmark.py --model-tag declip --batch-sizes 1,16,64,128 --cache-dir /path/to/declip.pt # 仅测试 TRT python benchmark.py --model-tag declip --skip-pytorch --batch-sizes 1,16,64,128 """ import os import sys import argparse import json import time import numpy as np from pathlib import Path from typing import Optional, Dict, Any, List from datetime import datetime import logging import torch import torch.nn as nn logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) PROJECT_ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(PROJECT_ROOT / "src")) # 默认 batch sizes DEFAULT_BATCH_SIZES = [1, 16, 64, 128] # ============== TensorRT 推理引擎 ============== class TRTInference: """TensorRT 推理引擎封装""" def __init__(self, engine_path: str): import tensorrt as trt self.logger = trt.Logger(trt.Logger.WARNING) self.engine_path = engine_path logger.info(f"Loading TensorRT engine: {engine_path}") with open(engine_path, 'rb') as f: engine_data = f.read() runtime = trt.Runtime(self.logger) self.engine = runtime.deserialize_cuda_engine(engine_data) self.context = self.engine.create_execution_context() self.input_name = self.engine.get_tensor_name(0) self.output_name = self.engine.get_tensor_name(1) self.engine_device_memory_bytes = self._get_device_memory_size(self.engine) self.context_device_memory_bytes = self._get_device_memory_size(self.context) @staticmethod def _get_device_memory_size(obj) -> Optional[int]: if hasattr(obj, "device_memory_size"): value = getattr(obj, "device_memory_size") return value() if callable(value) else value if hasattr(obj, "get_device_memory_size"): try: return obj.get_device_memory_size() except Exception: return None return None def infer(self, input_tensor: torch.Tensor) -> torch.Tensor: """执行推理""" self.context.set_input_shape(self.input_name, tuple(input_tensor.shape)) if self.context_device_memory_bytes is None: self.context_device_memory_bytes = self._get_device_memory_size(self.context) output_shape = self.context.get_tensor_shape(self.output_name) output_tensor = torch.empty(tuple(output_shape), dtype=torch.float32, device=input_tensor.device) self.context.set_tensor_address(self.input_name, input_tensor.data_ptr()) self.context.set_tensor_address(self.output_name, output_tensor.data_ptr()) stream = torch.cuda.current_stream().cuda_stream self.context.execute_async_v3(stream) torch.cuda.synchronize() return output_tensor # ============== PyTorch 模型封装 ============== class PyTorchModel: """PyTorch 模型封装""" def __init__( self, model_name: str = "EVA02-CLIP-B-16", cache_dir: str = None, mode: str = "csa", precision: str = "fp32", device: str = "cuda", ): from open_clip.eva_clip import create_model self.device = torch.device(device) self.precision = precision self.mode = mode logger.info(f"Loading PyTorch model ({precision}), mode={mode}, cache_dir={cache_dir}...") # 使用 eva_clip.create_model，pretrained 参数直接传入 checkpoint 路径 # 会自动从 checkpoint 字典中提取 state_dict（支持 model|module|state_dict key） # force_custom_clip=True 确保创建 CustomCLIP 类，与 checkpoint 的 key 格式匹配 self.model = create_model( model_name, pretrained=cache_dir, precision="fp32", device=self.device, force_custom_clip=True, ) self.model.eval() if precision == "fp16": self.model = self.model.half() @torch.no_grad() def infer(self, input_tensor: torch.Tensor) -> torch.Tensor: return self.model.visual.encode_dense(input_tensor, keep_shape=True, mode=self.mode) # ============== 测试函数 ============== def _parse_visible_devices(visible: str): parts = [p.strip() for p in visible.split(",") if p.strip()] if not parts: return None if all(p.isdigit() for p in parts): return [int(p) for p in parts] return parts def _get_nvml_handle(pynvml): device_index = torch.cuda.current_device() visible = os.environ.get("CUDA_VISIBLE_DEVICES") if visible: parts = _parse_visible_devices(visible) if parts: if isinstance(parts[0], int): if device_index < len(parts): device_index = parts[device_index] return pynvml.nvmlDeviceGetHandleByIndex(device_index) if device_index < len(parts): try: return pynvml.nvmlDeviceGetHandleByUUID(parts[device_index]) except Exception: pass return pynvml.nvmlDeviceGetHandleByIndex(device_index) class NVMLMemoryTracker: """使用 NVML 统计进程级 GPU 显存""" def __init__(self): self.available = False self._pynvml = None self._handle = None self._pid = os.getpid() self._error = None try: import pynvml self._pynvml = pynvml pynvml.nvmlInit() self._handle = _get_nvml_handle(pynvml) self.available = True except Exception as e: self._error = e def get_process_used_mb(self) -> Optional[float]: if not self.available: return None try: processes = self._pynvml.nvmlDeviceGetComputeRunningProcesses(self._handle) except Exception: try: processes = self._pynvml.nvmlDeviceGetGraphicsRunningProcesses(self._handle) except Exception: return None for proc in processes: if proc.pid == self._pid: used = getattr(proc, "usedGpuMemory", None) if used is None or used < 0: return None return used / (1024 ** 2) return 0.0 def get_device_used_mb(self) -> Optional[float]: if not self.available: return None try: info = self._pynvml.nvmlDeviceGetMemoryInfo(self._handle) return info.used / (1024 ** 2) except Exception: return None def shutdown(self): if not self.available: return try: self._pynvml.nvmlShutdown() except Exception: pass def get_gpu_memory_mb() -> float: return torch.cuda.memory_allocated() / (1024 ** 2) def get_gpu_memory_peak_mb() -> float: return torch.cuda.max_memory_allocated() / (1024 ** 2) def reset_gpu_memory_stats(): torch.cuda.reset_peak_memory_stats() torch.cuda.empty_cache() def benchmark_latency( model, input_shape: tuple, warmup_iterations: int = 50, benchmark_iterations: int = 200, device: str = "cuda", input_dtype: torch.dtype = torch.float32, ) -> Dict[str, float]: """测试推理延迟""" device = torch.device(device) reset_gpu_memory_stats() model_memory_mb = get_gpu_memory_mb() dummy_input = torch.randn(input_shape, device=device, dtype=input_dtype) nvml_tracker = NVMLMemoryTracker() nvml_base_mb = None nvml_peak_mb = None nvml_device_base_mb = None nvml_device_peak_mb = None if nvml_tracker.available: nvml_base_mb = nvml_tracker.get_process_used_mb() nvml_peak_mb = nvml_base_mb if nvml_base_mb is not None else 0.0 nvml_device_base_mb = nvml_tracker.get_device_used_mb() nvml_device_peak_mb = nvml_device_base_mb if nvml_device_base_mb is not None else 0.0 # Warmup for _ in range(warmup_iterations): _ = model.infer(dummy_input) if nvml_tracker.available: used_mb = nvml_tracker.get_process_used_mb() if used_mb is not None: if nvml_peak_mb is None: nvml_peak_mb = used_mb else: nvml_peak_mb = max(nvml_peak_mb, used_mb) device_used_mb = nvml_tracker.get_device_used_mb() if device_used_mb is not None: if nvml_device_peak_mb is None: nvml_device_peak_mb = device_used_mb else: nvml_device_peak_mb = max(nvml_device_peak_mb, device_used_mb) torch.cuda.synchronize() # Benchmark latencies = [] for _ in range(benchmark_iterations): torch.cuda.synchronize() start = time.perf_counter() _ = model.infer(dummy_input) torch.cuda.synchronize() end = time.perf_counter() latencies.append((end - start) * 1000) if nvml_tracker.available: used_mb = nvml_tracker.get_process_used_mb() if used_mb is not None: if nvml_peak_mb is None: nvml_peak_mb = used_mb else: nvml_peak_mb = max(nvml_peak_mb, used_mb) device_used_mb = nvml_tracker.get_device_used_mb() if device_used_mb is not None: if nvml_device_peak_mb is None: nvml_device_peak_mb = device_used_mb else: nvml_device_peak_mb = max(nvml_device_peak_mb, device_used_mb) latencies = np.array(latencies) torch_peak_memory_mb = get_gpu_memory_peak_mb() nvml_peak_total_mb = None nvml_peak_delta_mb = None if nvml_peak_mb is not None and nvml_base_mb is not None: nvml_peak_total_mb = nvml_peak_mb nvml_peak_delta_mb = max(nvml_peak_mb - nvml_base_mb, 0.0) if nvml_peak_delta_mb is not None and nvml_peak_delta_mb > 0: peak_memory_mb = nvml_peak_delta_mb peak_memory_source = "nvml-delta" elif nvml_peak_total_mb is not None and nvml_peak_total_mb > 0: peak_memory_mb = nvml_peak_total_mb peak_memory_source = "nvml-total" else: peak_memory_mb = torch_peak_memory_mb peak_memory_source = "torch" nvml_tracker.shutdown() return { "mean_ms": float(np.mean(latencies)), "std_ms": float(np.std(latencies)), "min_ms": float(np.min(latencies)), "max_ms": float(np.max(latencies)), "p50_ms": float(np.percentile(latencies, 50)), "p95_ms": float(np.percentile(latencies, 95)), "p99_ms": float(np.percentile(latencies, 99)), "throughput_fps": float(1000 / np.mean(latencies) * input_shape[0]), "model_memory_mb": float(model_memory_mb), "peak_memory_mb": float(peak_memory_mb), "base_memory_mb": float(nvml_base_mb) if nvml_base_mb is not None else None, "peak_memory_total_mb": float(nvml_peak_total_mb) if nvml_peak_total_mb is not None else None, "torch_peak_memory_mb": float(torch_peak_memory_mb), "peak_memory_source": peak_memory_source, "nvml_device_base_mb": float(nvml_device_base_mb) if nvml_device_base_mb is not None else None, "nvml_device_peak_mb": float(nvml_device_peak_mb) if nvml_device_peak_mb is not None else None, "batch_size": input_shape[0], } def find_trt_engine(engine_dir: Path, model_tag: str, mode: str, image_size: int, precision: str, batch_size: int) -> Optional[Path]: """查找 TRT 引擎文件""" # 尝试 batch-specific 引擎 engine_name = f"{model_tag}_eva_clip_b16_{mode}_{image_size}_{precision}_bs{batch_size}.trt" engine_path = engine_dir / engine_name if engine_path.exists(): return engine_path # 回退到旧命名格式（单一 batch） old_name = f"{model_tag}_eva_clip_b16_{mode}_{image_size}_{precision}.trt" old_path = engine_dir / old_name if old_path.exists() and batch_size == 1: return old_path return None def run_single_benchmark( model_tag: str, checkpoint: str, mode: str, precision: str, batch_size: int, image_size: int, engine_dir: Path, warmup: int = 50, iterations: int = 200, ) -> Optional[Dict[str, Any]]: """运行单个基准测试""" device = "cuda" input_shape = (batch_size, 3, image_size, image_size) result = None if precision in ["fp32", "fp16"]: # PyTorch 模式 try: model = PyTorchModel( cache_dir=checkpoint, mode=mode, precision=precision, device=device, ) input_dtype = torch.float16 if precision == "fp16" else torch.float32 result = benchmark_latency( model, input_shape, warmup, iterations, device, input_dtype=input_dtype, ) result["precision"] = precision result["backend"] = "pytorch" del model torch.cuda.empty_cache() except Exception as e: logger.error(f"PyTorch {precision} failed: {e}") elif precision.startswith("trt-"): # TensorRT 模式 trt_precision = precision.replace("trt-", "") engine_path = find_trt_engine(engine_dir, model_tag, mode, image_size, trt_precision, batch_size) if engine_path is None: logger.warning(f"TRT engine not found for {model_tag}, {trt_precision}, bs={batch_size}") return None try: model = TRTInference(str(engine_path)) result = benchmark_latency(model, input_shape, warmup, iterations, device) result["precision"] = trt_precision result["backend"] = "tensorrt" result["engine_path"] = str(engine_path) if model.engine_device_memory_bytes is not None: result["trt_engine_device_memory_mb"] = model.engine_device_memory_bytes / (1024 ** 2) if model.context_device_memory_bytes is not None: result["trt_context_device_memory_mb"] = model.context_device_memory_bytes / (1024 ** 2) del model torch.cuda.empty_cache() except Exception as e: logger.error(f"TensorRT {trt_precision} failed: {e}") if result: result["model_tag"] = model_tag result["mode"] = mode return result def print_results_table(results: List[Dict[str, Any]], title: str = "Benchmark Results"): """打印结果表格""" if not results: logger.warning("No results to print") return print("\n" + "=" * 110) print(f" {title}") print("=" * 110) headers = ["Model", "Backend", "Precision", "Batch", "Mean (ms)", "Std (ms)", "P95 (ms)", "FPS", "Peak Mem (MB)"] col_widths = [10, 10, 10, 6, 12, 10, 10, 12, 14] header_row = " | ".join(h.center(w) for h, w in zip(headers, col_widths)) print(header_row) print("-" * len(header_row)) for r in results: row = [ r.get("model_tag", "")[:10], r.get("backend", "")[:10], r.get("precision", "")[:10], str(r.get("batch_size", "")), f"{r['mean_ms']:.2f}", f"{r['std_ms']:.2f}", f"{r['p95_ms']:.2f}", f"{r['throughput_fps']:.1f}", f"{r['peak_memory_mb']:.1f}", ] print(" | ".join(str(v).center(w) for v, w in zip(row, col_widths))) print("=" * 110) def main(): parser = argparse.ArgumentParser(description="Benchmark EVA-CLIP inference") # 模型参数 parser.add_argument("--model-name", type=str, default="EVA02-CLIP-B-16") parser.add_argument("--cache-dir", type=str, default=None, help="Path to model checkpoint, e.g. EVA02_CLIP_B_psz16_s8B.pt or declip epoch_6.pt") parser.add_argument("--mode", type=str, default="csa", choices=["csa", "vanilla", "dummy_csa", "qq_xformer"]) parser.add_argument("--image-size", type=int, default=560) # TRT 参数 parser.add_argument("--engine-dir", type=str, default="./trt_engines") parser.add_argument("--model-tag", type=str, default="", help="Model tag for engine naming") # 测试参数 parser.add_argument("--batch-size", type=int, default=None, help="Single batch size (deprecated, use --batch-sizes)") parser.add_argument("--batch-sizes", type=str, default="1,16,64,128", help="Comma-separated batch sizes") parser.add_argument("--precisions", type=str, default="fp32,fp16,trt-fp16,trt-fp8", help="Comma-separated precisions to test") parser.add_argument("--warmup", type=int, default=50) parser.add_argument("--iterations", type=int, default=200) # 输出 parser.add_argument("--output-dir", type=str, default="./results") parser.add_argument("--output-json", type=str, default=None, help="Output JSON file (auto-generated if not specified)") # 控制 parser.add_argument("--skip-pytorch", action="store_true") parser.add_argument("--skip-trt", action="store_true") args = parser.parse_args() # 解析参数 if args.batch_size: batch_sizes = [args.batch_size] else: batch_sizes = [int(x.strip()) for x in args.batch_sizes.split(",")] precisions = [x.strip() for x in args.precisions.split(",")] if args.skip_pytorch: precisions = [p for p in precisions if not p in ["fp32", "fp16"]] if args.skip_trt: precisions = [p for p in precisions if not p.startswith("trt-")] engine_dir = Path(args.engine_dir) output_dir = Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) logger.info(f"Batch sizes: {batch_sizes}") logger.info(f"Precisions: {precisions}") logger.info(f"Device: {torch.cuda.get_device_name(0)}") # 验证 if not args.skip_pytorch and args.cache_dir is None: parser.error("--cache-dir is required for PyTorch tests (or use --skip-pytorch)") # 运行测试 all_results = [] for precision in precisions: for batch_size in batch_sizes: logger.info(f"\n--- {precision.upper()}, Batch {batch_size} ---") result = run_single_benchmark( model_tag=args.model_tag, checkpoint=args.cache_dir, mode=args.mode, precision=precision, batch_size=batch_size, image_size=args.image_size, engine_dir=engine_dir, warmup=args.warmup, iterations=args.iterations, ) if result: all_results.append(result) # 打印结果 print_results_table(all_results, f"Benchmark Results - {args.model_tag}") # 保存结果 if args.output_json: output_file = Path(args.output_json) else: timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") output_file = output_dir / f"{args.model_tag}_benchmark_{timestamp}.json" output_data = { "config": { "model_tag": args.model_tag, "mode": args.mode, "image_size": args.image_size, "batch_sizes": batch_sizes, "precisions": precisions, "device": torch.cuda.get_device_name(0), "timestamp": datetime.now().isoformat(), }, "results": all_results, } with open(output_file, 'w') as f: json.dump(output_data, f, indent=2) logger.info(f"Results saved: {output_file}") if __name__ == "__main__": main()