code/detection_trt/eval_panoptic.py

#!/usr/bin/env python3
"""
COCO Panoptic 评估脚本
评估 DeCLIP (csa模式) 和 CLIP (vanilla模式) 在 TRT 加速前后的零样本分类准确率

Usage:
    # PyTorch 模型评估
    python eval_panoptic.py --backend pytorch --checkpoint <path> --mode csa
    
    # TensorRT 模型评估
    python eval_panoptic.py --backend tensorrt --engine <path> --mode csa
"""

import os
import sys
import argparse
import json
from pathlib import Path
from typing import List, Dict, Tuple, Optional
from dataclasses import dataclass, asdict
from datetime import datetime
from tqdm import tqdm

import torch
import torch.nn.functional as F
import numpy as np

# 添加项目根目录到路径
SCRIPT_DIR = Path(__file__).parent
DECLIP_ROOT = SCRIPT_DIR.parent
sys.path.insert(0, str(DECLIP_ROOT))
sys.path.insert(0, str(DECLIP_ROOT / 'src'))


@dataclass
class EvalResult:
    """评估结果"""
    model_name: str
    mode: str
    backend: str
    precision: str
    
    # COCO Panoptic 结果
    rois_thing_macc1: float
    rois_thing_macc5: float
    rois_stuff_macc1: float
    rois_stuff_macc5: float
    
    maskpool_thing_macc1: float
    maskpool_thing_macc5: float
    maskpool_stuff_macc1: float
    maskpool_stuff_macc5: float
    
    crops_thing_macc1: float
    crops_thing_macc5: float
    crops_stuff_macc1: float
    crops_stuff_macc5: float
    
    # 总体指标
    total_samples: int
    timestamp: str


class PyTorchEvaluator:
    """PyTorch 模型评估器"""
    
    def __init__(self, model, device='cuda:0', mode='csa'):
        self.model = model
        self.device = torch.device(device)
        self.mode = mode
        self.model.to(self.device)
        self.model.eval()
    
    def encode_pseudo_boxes(
        self, 
        images: torch.Tensor, 
        rois: List[torch.Tensor],
        normalize: bool = True
    ) -> torch.Tensor:
        """编码伪边界框特征"""
        if hasattr(self.model, 'encode_pseudo_boxes'):
            return self.model.encode_pseudo_boxes(
                images, rois, normalize=normalize, mode=self.mode
            )
        else:
            # 使用 visual 模块
            return self.model.visual.extract_roi_features(
                images, rois, mode=self.mode
            )
    
    def encode_masks(
        self,
        images: torch.Tensor,
        masks: List[torch.Tensor],
        normalize: bool = True
    ) -> torch.Tensor:
        """编码 mask 特征"""
        if hasattr(self.model, 'encode_masks'):
            return self.model.encode_masks(
                images, masks, normalize=normalize, mode=self.mode
            )
        else:
            # 使用 mask_pool
            return self.model.visual.mask_pool(images, masks, mode=self.mode)
    
    def encode_image(
        self,
        images: torch.Tensor,
        normalize: bool = True
    ) -> torch.Tensor:
        """编码图像特征"""
        if hasattr(self.model, 'encode_image'):
            return self.model.encode_image(images, normalize=normalize)
        else:
            features = self.model.visual.forward_features(images)
            if normalize:
                features = F.normalize(features, dim=-1)
            return features


class TensorRTEvaluator:
    """TensorRT 模型评估器"""
    
    def __init__(self, engine_path: str, device='cuda:0'):
        self.engine_path = engine_path
        self.device = device
        
        self._load_engine()
    
    def _load_engine(self):
        """加载 TRT 引擎"""
        import tensorrt as trt
        import pycuda.driver as cuda
        import pycuda.autoinit
        
        self.cuda = cuda
        self.trt = trt
        
        logger = trt.Logger(trt.Logger.WARNING)
        runtime = trt.Runtime(logger)
        
        with open(self.engine_path, 'rb') as f:
            self.engine = runtime.deserialize_cuda_engine(f.read())
        
        self.context = self.engine.create_execution_context()
        self.stream = cuda.Stream()
        
        self.input_name = self.engine.get_tensor_name(0)
        self.output_name = self.engine.get_tensor_name(1)
    
    def encode_dense(self, images: np.ndarray) -> np.ndarray:
        """编码密集特征"""
        cuda = self.cuda
        
        # 设置输入形状
        self.context.set_input_shape(self.input_name, images.shape)
        output_shape = self.context.get_tensor_shape(self.output_name)
        
        output = np.empty(output_shape, dtype=np.float32)
        
        # GPU 内存
        d_input = cuda.mem_alloc(images.nbytes)
        d_output = cuda.mem_alloc(output.nbytes)
        
        # 推理
        cuda.memcpy_htod_async(d_input, images.astype(np.float32), self.stream)
        
        self.context.set_tensor_address(self.input_name, int(d_input))
        self.context.set_tensor_address(self.output_name, int(d_output))
        self.context.execute_async_v3(self.stream.handle)
        
        cuda.memcpy_dtoh_async(output, d_output, self.stream)
        self.stream.synchronize()
        
        return output
    
    def extract_roi_features(
        self,
        images: np.ndarray,
        rois: List[np.ndarray]
    ) -> np.ndarray:
        """从密集特征中提取 ROI 特征"""
        # 获取密集特征
        dense_features = self.encode_dense(images)
        
        # ROI Align (使用 PyTorch 实现)
        dense_features_torch = torch.from_numpy(dense_features).cuda()
        
        from torchvision.ops import roi_align
        
        all_roi_features = []
        
        for batch_idx, boxes in enumerate(rois):
            if len(boxes) == 0:
                continue
            
            boxes_torch = torch.from_numpy(boxes).cuda()
            
            # 将归一化坐标转换为特征图坐标
            _, _, fh, fw = dense_features.shape
            boxes_scaled = boxes_torch.clone()
            boxes_scaled[:, [0, 2]] *= fw
            boxes_scaled[:, [1, 3]] *= fh
            
            # 添加 batch index
            batch_indices = torch.full((len(boxes_scaled), 1), batch_idx, 
                                       device=boxes_scaled.device, dtype=boxes_scaled.dtype)
            boxes_with_batch = torch.cat([batch_indices, boxes_scaled], dim=1)
            
            # ROI Align
            roi_feats = roi_align(
                dense_features_torch,
                boxes_with_batch,
                output_size=(1, 1),
                spatial_scale=1.0,
                sampling_ratio=-1,
                aligned=True
            )
            
            roi_feats = roi_feats.squeeze(-1).squeeze(-1)
            all_roi_features.append(roi_feats)
        
        if all_roi_features:
            return torch.cat(all_roi_features, dim=0).cpu().numpy()
        else:
            return np.array([])


def load_coco_panoptic_dataset(args):
    """加载 COCO Panoptic 数据集"""
    from training.data import get_data
    
    # 构建参数
    class DataArgs:
        def __init__(self, args_dict):
            for k, v in args_dict.items():
                setattr(self, k, v)
    
    data_args = DataArgs({
        'val_data': args.val_ann,
        'val_image_root': args.val_img,
        'val_segm_root': args.panoptic_segm,
        'embed_path': args.embed_path,
        'test_type': 'coco_panoptic',
        'det_image_size': args.image_size,
        'device': args.device,
        'workers': args.workers,
        'batch_size': args.batch_size,
        'distributed': False,
        'world_size': 1,
        'rank': 0,
    })
    
    data = get_data(data_args, preprocess_fn=None)
    
    return data


def macc_with_is_thing(correct_matrix, is_thing, all_cls_labels, prefix):
    """计算 thing/stuff 分别的 mAcc"""
    def _macc(corrects, cls_labels):
        if len(cls_labels) == 0:
            return 0.0
            
        min_id = cls_labels.min().item()
        max_id = cls_labels.max().item()
        cand_labels = list(range(min_id, max_id + 1))
        
        acc_per_cls = []
        for lb in cand_labels:
            corrects_per_cls = corrects[cls_labels == lb]
            if corrects_per_cls.shape[0] == 0:
                continue
            acc_per_cls.append(corrects_per_cls.mean().item())
        
        if len(acc_per_cls) == 0:
            return 0.0
        return sum(acc_per_cls) / len(acc_per_cls)
    
    results = {}
    thing_correct_matrix = correct_matrix[is_thing > 0]
    stuff_correct_matrix = correct_matrix[is_thing < 1]
    
    thing_cls_labels = all_cls_labels[is_thing > 0].long()
    stuff_cls_labels = all_cls_labels[is_thing < 1].long()
    
    thing_top1_acc = _macc(thing_correct_matrix[:, 0], thing_cls_labels)
    thing_top5_acc = _macc(thing_correct_matrix.sum(-1), thing_cls_labels)
    
    stuff_top1_acc = _macc(stuff_correct_matrix[:, 0], stuff_cls_labels)
    stuff_top5_acc = _macc(stuff_correct_matrix.sum(-1), stuff_cls_labels)
    
    results[f'{prefix}.thing.macc1'] = thing_top1_acc
    results[f'{prefix}.thing.macc5'] = thing_top5_acc
    results[f'{prefix}.stuff.macc1'] = stuff_top1_acc
    results[f'{prefix}.stuff.macc5'] = stuff_top5_acc
    
    return results


def evaluate_pytorch(model, dataloader, args) -> EvalResult:
    """评估 PyTorch 模型"""
    device = torch.device(args.device)
    
    # 加载类别嵌入
    cls_embeddings = dataloader.dataset.embeddings
    cls_embeddings = F.normalize(torch.from_numpy(cls_embeddings).float(), dim=-1)
    cls_embeddings = cls_embeddings.to(device)
    
    evaluator = PyTorchEvaluator(model, device=args.device, mode=args.mode)
    
    correct_rois = []
    correct_maskpool = []
    correct_crops = []
    all_is_thing = []
    all_cls_labels = []
    
    with torch.no_grad():
        for batch in tqdm(dataloader, desc="Evaluating"):
            _, images, bboxes, image_crops, gt_masks, masked_image_crops = batch
            
            images = images.to(device)
            bboxes = bboxes.to(device)
            image_crops = image_crops.to(device)
            gt_masks = gt_masks.to(device)
            
            # 解析 bbox
            rois = []
            cls_labels = []
            image_crops_list = []
            gt_masks_list = []
            is_thing = []
            
            for bboxes_per_image, crops_per_image, gt_mask in \
                    zip(bboxes, image_crops, gt_masks):
                valid = bboxes_per_image[:, 5] > 0.5
                rois.append(bboxes_per_image[valid, :4])
                cls_labels.append(bboxes_per_image[valid, 4])
                image_crops_list.append(crops_per_image[valid])
                gt_masks_list.append(gt_mask[valid])
                is_thing.append(bboxes_per_image[valid, 7])
            
            cls_labels = torch.cat(cls_labels, dim=0).to(torch.long)
            if cls_labels.shape[0] == 0:
                continue
            
            image_crops = torch.cat(image_crops_list)
            is_thing = torch.cat(is_thing, dim=0)
            
            # 提取特征
            roi_features = evaluator.encode_pseudo_boxes(images, rois, normalize=True)
            maskpool_features = evaluator.encode_masks(images, gt_masks_list, normalize=True)
            crop_features = evaluator.encode_image(image_crops, normalize=True)
            
            # 分类
            roi_logits = roi_features @ cls_embeddings.T
            crop_logits = crop_features @ cls_embeddings.T
            maskpool_logits = maskpool_features @ cls_embeddings.T
            
            _, roi_top5_inds = roi_logits.topk(5)
            _, crop_top5_inds = crop_logits.topk(5)
            _, maskpool_top5_inds = maskpool_logits.topk(5)
            
            correct_rois.append(roi_top5_inds == cls_labels.view(-1, 1))
            correct_crops.append(crop_top5_inds == cls_labels.view(-1, 1))
            correct_maskpool.append(maskpool_top5_inds == cls_labels.view(-1, 1))
            all_is_thing.append(is_thing)
            all_cls_labels.append(cls_labels)
    
    # 汇总结果
    correct_rois = torch.cat(correct_rois).float()
    correct_crops = torch.cat(correct_crops).float()
    correct_maskpool = torch.cat(correct_maskpool).float()
    all_is_thing = torch.cat(all_is_thing)
    all_cls_labels = torch.cat(all_cls_labels)
    
    rois_results = macc_with_is_thing(correct_rois, all_is_thing, all_cls_labels, 'rois')
    crops_results = macc_with_is_thing(correct_crops, all_is_thing, all_cls_labels, 'crops')
    maskpool_results = macc_with_is_thing(correct_maskpool, all_is_thing, all_cls_labels, 'maskpool')
    
    return EvalResult(
        model_name=args.model_name,
        mode=args.mode,
        backend='pytorch',
        precision='fp16' if args.fp16 else 'fp32',
        
        rois_thing_macc1=rois_results['rois.thing.macc1'],
        rois_thing_macc5=rois_results['rois.thing.macc5'],
        rois_stuff_macc1=rois_results['rois.stuff.macc1'],
        rois_stuff_macc5=rois_results['rois.stuff.macc5'],
        
        maskpool_thing_macc1=maskpool_results['maskpool.thing.macc1'],
        maskpool_thing_macc5=maskpool_results['maskpool.thing.macc5'],
        maskpool_stuff_macc1=maskpool_results['maskpool.stuff.macc1'],
        maskpool_stuff_macc5=maskpool_results['maskpool.stuff.macc5'],
        
        crops_thing_macc1=crops_results['crops.thing.macc1'],
        crops_thing_macc5=crops_results['crops.thing.macc5'],
        crops_stuff_macc1=crops_results['crops.stuff.macc1'],
        crops_stuff_macc5=crops_results['crops.stuff.macc5'],
        
        total_samples=len(correct_rois),
        timestamp=datetime.now().isoformat()
    )


def evaluate_tensorrt(engine_path, dataloader, args) -> EvalResult:
    """评估 TensorRT 模型"""
    device = torch.device(args.device)
    
    # 加载类别嵌入
    cls_embeddings = dataloader.dataset.embeddings
    cls_embeddings = F.normalize(torch.from_numpy(cls_embeddings).float(), dim=-1)
    cls_embeddings = cls_embeddings.to(device)
    
    evaluator = TensorRTEvaluator(engine_path, device=args.device)
    
    correct_rois = []
    all_is_thing = []
    all_cls_labels = []
    
    with torch.no_grad():
        for batch in tqdm(dataloader, desc="Evaluating TRT"):
            _, images, bboxes, image_crops, gt_masks, masked_image_crops = batch
            
            images_np = images.numpy()
            bboxes = bboxes.to(device)
            
            # 解析 bbox
            rois = []
            cls_labels = []
            is_thing = []
            
            for bboxes_per_image in bboxes:
                valid = bboxes_per_image[:, 5] > 0.5
                rois.append(bboxes_per_image[valid, :4].cpu().numpy())
                cls_labels.append(bboxes_per_image[valid, 4])
                is_thing.append(bboxes_per_image[valid, 7])
            
            cls_labels = torch.cat(cls_labels, dim=0).to(torch.long).to(device)
            if cls_labels.shape[0] == 0:
                continue
            
            is_thing = torch.cat(is_thing, dim=0).to(device)
            
            # TRT 推理
            roi_features_np = evaluator.extract_roi_features(images_np, rois)
            
            if len(roi_features_np) == 0:
                continue
            
            roi_features = torch.from_numpy(roi_features_np).to(device)
            roi_features = F.normalize(roi_features, dim=-1)
            
            # 分类
            roi_logits = roi_features @ cls_embeddings.T
            _, roi_top5_inds = roi_logits.topk(5)
            
            correct_rois.append(roi_top5_inds == cls_labels.view(-1, 1))
            all_is_thing.append(is_thing)
            all_cls_labels.append(cls_labels)
    
    # 汇总结果
    if not correct_rois:
        print("Warning: No valid samples")
        return None
    
    correct_rois = torch.cat(correct_rois).float()
    all_is_thing = torch.cat(all_is_thing)
    all_cls_labels = torch.cat(all_cls_labels)
    
    rois_results = macc_with_is_thing(correct_rois, all_is_thing, all_cls_labels, 'rois')
    
    return EvalResult(
        model_name=Path(engine_path).stem,
        mode=args.mode,
        backend='tensorrt',
        precision='fp16',
        
        rois_thing_macc1=rois_results['rois.thing.macc1'],
        rois_thing_macc5=rois_results['rois.thing.macc5'],
        rois_stuff_macc1=rois_results['rois.stuff.macc1'],
        rois_stuff_macc5=rois_results['rois.stuff.macc5'],
        
        # TRT 只支持 ROI 特征
        maskpool_thing_macc1=0.0,
        maskpool_thing_macc5=0.0,
        maskpool_stuff_macc1=0.0,
        maskpool_stuff_macc5=0.0,
        
        crops_thing_macc1=0.0,
        crops_thing_macc5=0.0,
        crops_stuff_macc1=0.0,
        crops_stuff_macc5=0.0,
        
        total_samples=len(correct_rois),
        timestamp=datetime.now().isoformat()
    )


def print_result(result: EvalResult):
    """打印评估结果"""
    print(f"\n{'='*60}")
    print(f"Evaluation Results: {result.model_name}")
    print(f"{'='*60}")
    print(f"Backend:        {result.backend}")
    print(f"Mode:           {result.mode}")
    print(f"Precision:      {result.precision}")
    print(f"Total Samples:  {result.total_samples}")
    print(f"-" * 40)
    print(f"\nROI Features:")
    print(f"  Thing mAcc@1: {result.rois_thing_macc1:.4f}")
    print(f"  Thing mAcc@5: {result.rois_thing_macc5:.4f}")
    print(f"  Stuff mAcc@1: {result.rois_stuff_macc1:.4f}")
    print(f"  Stuff mAcc@5: {result.rois_stuff_macc5:.4f}")
    
    if result.maskpool_thing_macc1 > 0:
        print(f"\nMask Pool Features:")
        print(f"  Thing mAcc@1: {result.maskpool_thing_macc1:.4f}")
        print(f"  Thing mAcc@5: {result.maskpool_thing_macc5:.4f}")
        print(f"  Stuff mAcc@1: {result.maskpool_stuff_macc1:.4f}")
        print(f"  Stuff mAcc@5: {result.maskpool_stuff_macc5:.4f}")
    
    if result.crops_thing_macc1 > 0:
        print(f"\nCrop Features:")
        print(f"  Thing mAcc@1: {result.crops_thing_macc1:.4f}")
        print(f"  Thing mAcc@5: {result.crops_thing_macc5:.4f}")
        print(f"  Stuff mAcc@1: {result.crops_stuff_macc1:.4f}")
        print(f"  Stuff mAcc@5: {result.crops_stuff_macc5:.4f}")
    
    print(f"{'='*60}")


def parse_args():
    parser = argparse.ArgumentParser(description='COCO Panoptic 评估')
    
    # 模型配置
    parser.add_argument('--backend', type=str, default='pytorch',
                        choices=['pytorch', 'tensorrt'],
                        help='推理后端')
    parser.add_argument('--checkpoint', type=str,
                        help='PyTorch 模型检查点路径')
    parser.add_argument('--engine', type=str,
                        help='TensorRT 引擎路径')
    parser.add_argument('--model-name', type=str, default='EVA02-CLIP-B-16',
                        help='模型名称')
    parser.add_argument('--mode', type=str, default='csa',
                        choices=['vanilla', 'csa'],
                        help='特征模式')
    parser.add_argument('--fp16', action='store_true',
                        help='使用 FP16 (仅 PyTorch)')
    
    # 数据配置
    parser.add_argument('--coco-root', type=str,
                        default='/mnt/SSD8T/home/wjj/dataset/standard_coco',
                        help='COCO 数据集根目录')
    parser.add_argument('--val-ann', type=str,
                        default='annotations/panoptic_val2017.json',
                        help='验证集标注文件')
    parser.add_argument('--val-img', type=str,
                        default='val2017',
                        help='验证集图像目录')
    parser.add_argument('--panoptic-segm', type=str,
                        default='annotations/panoptic_val2017',
                        help='Panoptic 分割标注目录')
    parser.add_argument('--embed-path', type=str,
                        default='metadata/coco_panoptic_clip_hand_craft_EVACLIP_ViTB16.npy',
                        help='类别嵌入路径')
    
    # 评估配置
    parser.add_argument('--image-size', type=int, default=560,
                        help='图像尺寸')
    parser.add_argument('--batch-size', type=int, default=1,
                        help='批处理大小')
    parser.add_argument('--workers', type=int, default=4,
                        help='数据加载工作进程数')
    
    # 输出配置
    parser.add_argument('--output', type=str, default='results/panoptic_results.json',
                        help='输出文件路径')
    
    parser.add_argument('--device', type=str, default='cuda:0',
                        help='设备')
    
    return parser.parse_args()


def main():
    args = parse_args()
    
    # 补全路径
    if not os.path.isabs(args.val_ann):
        args.val_ann = os.path.join(args.coco_root, args.val_ann)
    if not os.path.isabs(args.val_img):
        args.val_img = os.path.join(args.coco_root, args.val_img)
    if not os.path.isabs(args.panoptic_segm):
        args.panoptic_segm = os.path.join(args.coco_root, args.panoptic_segm)
    if not os.path.isabs(args.embed_path):
        args.embed_path = os.path.join(DECLIP_ROOT, args.embed_path)
    
    print(f"\n{'='*60}")
    print("COCO Panoptic Evaluation")
    print(f"{'='*60}")
    print(f"Backend: {args.backend}")
    print(f"Mode: {args.mode}")
    print(f"Image Size: {args.image_size}")
    
    # 加载数据
    print("\nLoading dataset...")
    data = load_coco_panoptic_dataset(args)
    dataloader = data['val'].dataloader
    print(f"Dataset loaded: {len(dataloader)} batches")
    
    # 评估
    if args.backend == 'pytorch':
        if not args.checkpoint:
            raise ValueError("--checkpoint is required for PyTorch backend")
        
        print(f"\nLoading PyTorch model: {args.checkpoint}")
        from open_clip import create_model
        
        model = create_model(
            args.model_name,
            pretrained='eva',
            device=args.device,
            precision='fp16' if args.fp16 else 'fp32',
            output_dict=True,
            cache_dir=args.checkpoint
        )
        
        result = evaluate_pytorch(model, dataloader, args)
        
    elif args.backend == 'tensorrt':
        if not args.engine:
            raise ValueError("--engine is required for TensorRT backend")
        
        print(f"\nLoading TensorRT engine: {args.engine}")
        result = evaluate_tensorrt(args.engine, dataloader, args)
    
    # 打印结果
    if result:
        print_result(result)
        
        # 保存结果
        output_path = Path(args.output)
        output_path.parent.mkdir(parents=True, exist_ok=True)
        
        with open(output_path, 'w') as f:
            json.dump(asdict(result), f, indent=2)
        
        print(f"\nResults saved to: {output_path}")


if __name__ == '__main__':
    main()