analysis/robustness_eval/test_robustness_ovcoco.py

#!/usr/bin/env python3
# Copyright (c) OpenMMLab. All rights reserved.
# Modified for OV-COCO dataset to compute base_ap50 and novel_ap50
"""
OV-COCO 鲁棒性测试脚本

与标准 test_robustness.py 的区别:
1. 使用 dataset.evaluate() 替代 coco_eval_with_return()
2. 这样 CocoDatasetOV 的 evaluate_det_segm() 会计算 base_ap50/novel_ap50/all_ap50
"""

import argparse
import copy
import os
import os.path as osp
import sys

import mmcv
import torch
from mmcv import DictAction
from mmcv.parallel import MMDataParallel
from mmcv.runner import load_checkpoint, wrap_fp16_model

from mmdet.apis import set_random_seed, single_gpu_test
from mmdet.datasets import build_dataloader, build_dataset
from mmdet.models import build_detector


def parse_args():
    parser = argparse.ArgumentParser(description='OV-COCO Robustness Test')
    parser.add_argument('config', help='test config file path')
    parser.add_argument('checkpoint', help='checkpoint file')
    parser.add_argument('--out', help='output result file')
    parser.add_argument(
        '--corruptions',
        type=str,
        nargs='+',
        default='benchmark',
        choices=[
            'all', 'benchmark', 'noise', 'blur', 'weather', 'digital',
            'holdout', 'None', 'gaussian_noise', 'shot_noise', 'impulse_noise',
            'defocus_blur', 'glass_blur', 'motion_blur', 'zoom_blur', 'snow',
            'frost', 'fog', 'brightness', 'contrast', 'elastic_transform',
            'pixelate', 'jpeg_compression', 'speckle_noise', 'gaussian_blur',
            'spatter', 'saturate'
        ],
        help='corruptions')
    parser.add_argument(
        '--severities',
        type=int,
        nargs='+',
        default=[1, 2, 3, 4, 5],
        help='corruption severity levels')
    parser.add_argument(
        '--eval',
        type=str,
        nargs='+',
        default=['bbox'],
        choices=['proposal', 'proposal_fast', 'bbox', 'segm', 'keypoints'],
        help='eval types')
    parser.add_argument(
        '--workers', type=int, default=8, help='workers per gpu')
    parser.add_argument('--show', action='store_true', help='show results')
    parser.add_argument(
        '--show-dir', help='directory where painted images will be saved')
    parser.add_argument(
        '--show-score-thr',
        type=float,
        default=0.3,
        help='score threshold (default: 0.3)')
    parser.add_argument('--seed', type=int, default=None, help='random seed')
    parser.add_argument(
        '--cfg-options',
        nargs='+',
        action=DictAction,
        help='override some settings in the used config')
    args = parser.parse_args()
    return args


def get_corruption_list(corruptions_arg):
    """解析 corruption 参数，返回实际的 corruption 列表"""
    if 'all' in corruptions_arg:
        return [
            'gaussian_noise', 'shot_noise', 'impulse_noise', 'defocus_blur',
            'glass_blur', 'motion_blur', 'zoom_blur', 'snow', 'frost', 'fog',
            'brightness', 'contrast', 'elastic_transform', 'pixelate',
            'jpeg_compression', 'speckle_noise', 'gaussian_blur', 'spatter',
            'saturate'
        ]
    elif 'benchmark' in corruptions_arg:
        return [
            'gaussian_noise', 'shot_noise', 'impulse_noise', 'defocus_blur',
            'glass_blur', 'motion_blur', 'zoom_blur', 'snow', 'frost', 'fog',
            'brightness', 'contrast', 'elastic_transform', 'pixelate',
            'jpeg_compression'
        ]
    elif 'noise' in corruptions_arg:
        return ['gaussian_noise', 'shot_noise', 'impulse_noise']
    elif 'blur' in corruptions_arg:
        return ['defocus_blur', 'glass_blur', 'motion_blur', 'zoom_blur']
    elif 'weather' in corruptions_arg:
        return ['snow', 'frost', 'fog', 'brightness']
    elif 'digital' in corruptions_arg:
        return ['contrast', 'elastic_transform', 'pixelate', 'jpeg_compression']
    elif 'holdout' in corruptions_arg:
        return ['speckle_noise', 'gaussian_blur', 'spatter', 'saturate']
    elif 'None' in corruptions_arg:
        return ['None']
    else:
        return corruptions_arg


def main():
    args = parse_args()

    assert args.out, 'Please specify output file with --out'

    if not args.out.endswith(('.pkl', '.pickle')):
        raise ValueError('The output file must be a pkl file.')

    cfg = mmcv.Config.fromfile(args.config)
    if args.cfg_options is not None:
        cfg.merge_from_dict(args.cfg_options)

    # set cudnn_benchmark
    if cfg.get('cudnn_benchmark', False):
        torch.backends.cudnn.benchmark = True

    cfg.model.pretrained = None
    cfg.data.test.test_mode = True

    if args.workers == 0:
        args.workers = cfg.data.workers_per_gpu

    # set random seeds
    if args.seed is not None:
        set_random_seed(args.seed)

    corruptions = get_corruption_list(args.corruptions)
    
    # 如果是 None corruption，只测试 severity 0
    if corruptions == ['None']:
        args.severities = [0]

    aggregated_results = {}
    
    for corruption in corruptions:
        aggregated_results[corruption] = {}
        
        for severity in args.severities:
            print(f'\nTesting {corruption} at severity {severity}')
            
            # 复制测试数据配置
            test_data_cfg = copy.deepcopy(cfg.data.test)
            
            # 添加 corruption transform
            if severity > 0:
                corruption_trans = dict(
                    type='Corrupt',
                    corruption=corruption,
                    severity=severity)
                # 在 LoadImageFromFile 之后插入
                test_data_cfg['pipeline'].insert(1, corruption_trans)
            
            # 构建数据集 (使用 CocoDatasetOV)
            dataset = build_dataset(test_data_cfg)
            data_loader = build_dataloader(
                dataset,
                samples_per_gpu=1,
                workers_per_gpu=args.workers,
                dist=False,
                shuffle=False)
            
            # 构建模型
            cfg.model.train_cfg = None
            model = build_detector(cfg.model, test_cfg=cfg.get('test_cfg'))
            
            fp16_cfg = cfg.get('fp16', None)
            if fp16_cfg is not None:
                wrap_fp16_model(model)
            
            checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu')
            
            # 设置类别
            if 'CLASSES' in checkpoint.get('meta', {}):
                model.CLASSES = checkpoint['meta']['CLASSES']
            else:
                model.CLASSES = dataset.CLASSES
            
            model = MMDataParallel(model, device_ids=[0])
            
            # 运行推理
            show_dir = args.show_dir
            if show_dir is not None:
                show_dir = osp.join(show_dir, corruption, str(severity))
                if not osp.exists(show_dir):
                    os.makedirs(show_dir)
            
            outputs = single_gpu_test(
                model, data_loader, args.show, show_dir, args.show_score_thr)
            
            # 保存原始输出
            mmcv.dump(outputs, args.out)
            
            # 使用 dataset.evaluate() 计算指标
            # 关键: classwise=True 才能计算 base_ap50 和 novel_ap50
            eval_results = dataset.evaluate(
                outputs,
                metric=args.eval,
                classwise=True,
                logger=None
            )
            
            # 打印结果
            print(f'\nResults for {corruption} at severity {severity}:')
            for key, value in eval_results.items():
                if isinstance(value, float):
                    print(f'  {key}: {value:.4f}')
                else:
                    print(f'  {key}: {value}')
            
            # 存储结果
            aggregated_results[corruption][severity] = eval_results
            
            # 清理 GPU 内存
            del model
            del data_loader
            del dataset
            torch.cuda.empty_cache()
    
    # 保存聚合结果
    eval_results_filename = (
        osp.splitext(args.out)[0] + '_results' + osp.splitext(args.out)[1])
    mmcv.dump(aggregated_results, eval_results_filename)
    
    print(f'\nAggregated results saved to: {eval_results_filename}')
    
    # 打印汇总
    print_summary(aggregated_results)


def print_summary(aggregated_results):
    """打印结果汇总"""
    print('\n' + '=' * 80)
    print('Summary of OV-COCO Robustness Evaluation')
    print('=' * 80)
    
    # 收集所有指标
    all_base_ap50 = []
    all_novel_ap50 = []
    all_all_ap50 = []
    all_bbox_mAP = []
    all_bbox_mAP_50 = []
    
    print(f'\n{"Corruption":<25} {"Sev":>4} {"Base AP50":>10} {"Novel AP50":>11} {"All AP50":>10} {"mAP":>8} {"mAP50":>8}')
    print('-' * 80)
    
    for corruption in aggregated_results:
        for severity in sorted(aggregated_results[corruption].keys()):
            results = aggregated_results[corruption][severity]
            
            base_ap50 = results.get('base_ap50', float('nan'))
            novel_ap50 = results.get('novel_ap50', float('nan'))
            all_ap50 = results.get('all_ap50', float('nan'))
            bbox_mAP = results.get('bbox_mAP', float('nan'))
            bbox_mAP_50 = results.get('bbox_mAP_50', float('nan'))
            
            print(f'{corruption:<25} {severity:>4} {base_ap50:>10.2f} {novel_ap50:>11.2f} {all_ap50:>10.2f} {bbox_mAP:>8.3f} {bbox_mAP_50:>8.3f}')
            
            if severity > 0:  # 不包含 clean data
                all_base_ap50.append(base_ap50)
                all_novel_ap50.append(novel_ap50)
                all_all_ap50.append(all_ap50)
                all_bbox_mAP.append(bbox_mAP)
                all_bbox_mAP_50.append(bbox_mAP_50)
    
    # 计算 mPC
    import numpy as np
    print('-' * 80)
    print(f'{"mPC (Mean)":<25} {"":>4} {np.nanmean(all_base_ap50):>10.2f} {np.nanmean(all_novel_ap50):>11.2f} {np.nanmean(all_all_ap50):>10.2f} {np.nanmean(all_bbox_mAP):>8.3f} {np.nanmean(all_bbox_mAP_50):>8.3f}')
    print('=' * 80)


if __name__ == '__main__':
    main()