import argparse import torch import numpy as np import pandas as pd from data import AVLip import torch.utils.data from models import build_model from sklearn.metrics import average_precision_score, confusion_matrix, accuracy_score, roc_auc_score, roc_curve import os def custom_collate(batch): """自定义 collate 函数，处理包含文件路径的批次数据""" # batch 是一个列表，每个元素是 (img, crops, label, img_path) imgs = torch.stack([item[0] for item in batch]) # 处理 crops（列表的列表）：crops[scale_idx][sample_idx] 是一个 tensor # 需要将其转换为：crops[scale_idx] 是一个 tensor，形状为 (batch_size, 3, 224, 224) num_scales = len(batch[0][1]) # 尺度数（通常是3个：1.0x, 0.65x, 0.45x） num_crops_per_scale = len(batch[0][1][0]) # 每个尺度的 crop 数量（通常是5） crops = [] for scale_idx in range(num_scales): scale_crops = [] for crop_idx in range(num_crops_per_scale): # 收集 batch 中所有样本在这个尺度和 crop 索引下的 tensor crop_tensors = [batch[sample_idx][1][scale_idx][crop_idx] for sample_idx in range(len(batch))] # 堆叠成一个 batch tensor crop_batch = torch.stack(crop_tensors) scale_crops.append(crop_batch) crops.append(scale_crops) labels = torch.tensor([item[2] for item in batch]) img_paths = [item[3] for item in batch] return imgs, crops, labels, img_paths def compute_eer(y_true, y_pred_proba): """计算 EER (Equal Error Rate) 和对应的阈值""" # 获取 ROC 曲线上的点 fpr, tpr, thresholds = roc_curve(y_true, y_pred_proba) fnr = 1 - tpr # 找到 FPR 和 FNR 差异最小的点，即为 EER eer_threshold = thresholds[np.nanargmin(np.abs(fpr - fnr))] eer = fpr[np.nanargmin(np.abs(fpr - fnr))] return eer, eer_threshold def compute_acc_at_eer(y_true, y_pred_proba, eer_threshold): """计算在 EER 阈值下的准确率""" y_pred_binary = (y_pred_proba >= eer_threshold).astype(int) acc = accuracy_score(y_true, y_pred_binary) return acc def validate(model, loader, gpu_id): print("validating...") device = torch.device(f"cuda:{gpu_id[0]}" if torch.cuda.is_available() else "cpu") with torch.no_grad(): y_true, y_pred = [], [] img_paths = [] # 存储每个样本的文件路径 for batch_data in loader: # 解包数据：现在使用 custom_collate，返回 (imgs, crops, labels, img_paths) imgs, crops, labels, batch_paths = batch_data # 保存文件路径 img_paths.extend(batch_paths) img_tens = imgs.to(device) # crops 现在是正确格式：crops[scale_idx][crop_idx] 是 (batch_size, 3, 224, 224) # 只需要将每个 tensor 移动到 device crops_tens = [[t.to(device) for t in scale_crops] for scale_crops in crops] features = model.get_features(img_tens).to(device) y_pred.extend(model(crops_tens, features)[0].sigmoid().flatten().tolist()) y_true.extend(labels.flatten().tolist()) y_true = np.array(y_true) y_pred_proba = np.array(y_pred) # 保留连续的概率值 y_pred_binary = np.where(y_pred_proba >= 0.5, 1, 0) # 二值化用于 acc 计算 # Get AP (使用连续概率值) ap = average_precision_score(y_true, y_pred_proba) # Get AUC (使用连续概率值) auc = roc_auc_score(y_true, y_pred_proba) # 计算其他指标 (使用二值化结果) cm = confusion_matrix(y_true, y_pred_binary) tp, fn, fp, tn = cm.ravel() fnr = fn / (fn + tp) fpr = fp / (fp + tn) acc = accuracy_score(y_true, y_pred_binary) # 计算 EER 和 ACC@EER eer, eer_threshold = compute_eer(y_true, y_pred_proba) acc_at_eer = compute_acc_at_eer(y_true, y_pred_proba, eer_threshold) return acc, ap, auc, fpr, fnr, eer, acc_at_eer, y_true, y_pred, img_paths if __name__ == "__main__": parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument("--real_list_path", type=str, default="./datasets/val/0_real") parser.add_argument("--fake_list_path", type=str, default="./datasets/val/1_fake") parser.add_argument("--max_sample", type=int, default=1000, help="max number of validate samples") parser.add_argument("--batch_size", type=int, default=10) parser.add_argument("--data_label", type=str, default="val") parser.add_argument("--arch", type=str, default="CLIP:ViT-L/14") parser.add_argument("--ckpt", type=str, default="./checkpoints/ckpt.pth") parser.add_argument("--gpu", type=int, default=0) parser.add_argument("--output_csv", type=str, default=None, help="Path to save inference results as CSV") opt = parser.parse_args() device = torch.device(f"cuda:{opt.gpu}" if torch.cuda.is_available() else "cpu") print(f"Using cuda {opt.gpu} for inference.") model = build_model(opt.arch) state_dict = torch.load(opt.ckpt, map_location="cpu") model.load_state_dict(state_dict["model"]) print("Model loaded.") model.eval() model.to(device) dataset = AVLip(opt) loader = data_loader = torch.utils.data.DataLoader( dataset, batch_size=opt.batch_size, shuffle=False, # 改为 False 以保持顺序 collate_fn=custom_collate # 使用自定义 collate 函数 ) acc, ap, auc, fpr, fnr, eer, acc_at_eer, y_true, y_pred, img_paths = validate(model, loader, gpu_id=[opt.gpu]) print(f"acc: {acc} ap: {ap} auc: {auc} fpr: {fpr} fnr: {fnr} eer: {eer} acc@eer: {acc_at_eer}") # 保存结果到 CSV if opt.output_csv is not None: print(f"Saving inference results to {opt.output_csv}...") # 计算 EER 和对应的阈值 eer, eer_threshold = compute_eer(np.array(y_true), np.array(y_pred)) acc_at_eer = compute_acc_at_eer(np.array(y_true), np.array(y_pred), eer_threshold) print(f"EER: {eer}, EER threshold: {eer_threshold}, ACC@EER: {acc_at_eer}") # 准备数据 results = [] y_pred_proba = np.array(y_pred) y_pred_binary = np.where(y_pred_proba >= 0.5, 1, 0) y_pred_at_eer = (y_pred_proba >= eer_threshold).astype(int) for i in range(len(y_true)): result_dict = { 'img_path': img_paths[i] if i < len(img_paths) else f'sample_{i}', 'true_label': int(y_true[i]), 'pred_prob': float(y_pred_proba[i]), 'pred_label_05': int(y_pred_binary[i]), 'pred_label_eer': int(y_pred_at_eer[i]) } results.append(result_dict) # 保存到 CSV df = pd.DataFrame(results) df.to_csv(opt.output_csv, index=False) print(f"Results saved to {opt.output_csv}") # 保存汇总统计到另一个文件 summary_path = opt.output_csv.replace('.csv', '_summary.csv') summary = { 'metric': ['acc', 'ap', 'auc', 'fpr', 'fnr', 'eer', 'acc_at_eer', 'eer_threshold'], 'value': [acc, ap, auc, fpr, fnr, eer, acc_at_eer, eer_threshold] } df_summary = pd.DataFrame(summary) df_summary.to_csv(summary_path, index=False) print(f"Summary saved to {summary_path}")