254 lines
8.1 KiB
Python
254 lines
8.1 KiB
Python
"""
|
||
PC端推理脚本 - 生成测试结果和性能数据
|
||
|
||
功能:
|
||
1. 加载训练好的模型(PyTorch/量化/ONNX)
|
||
2. 在测试集上运行推理
|
||
3. 生成详细的结果报告(准确率、混淆矩阵、推理时间)
|
||
4. 保存结果数据供论文使用
|
||
"""
|
||
import os
|
||
import argparse
|
||
import time
|
||
import json
|
||
import numpy as np
|
||
import torch
|
||
import torch.nn as nn
|
||
from torch.utils.data import DataLoader
|
||
from torchvision import transforms
|
||
from PIL import Image
|
||
import matplotlib.pyplot as plt
|
||
import seaborn as sns
|
||
from sklearn.metrics import confusion_matrix, classification_report
|
||
from tqdm import tqdm
|
||
|
||
from model import create_model
|
||
from dataset import LightImageDataset
|
||
|
||
|
||
def load_model(model_path, num_classes=10, device='cpu'):
|
||
"""加载训练好的模型"""
|
||
print(f"加载模型: {model_path}")
|
||
model = create_model(num_classes=num_classes, pretrained=False)
|
||
|
||
checkpoint = torch.load(model_path, map_location=device)
|
||
if 'model_state_dict' in checkpoint:
|
||
model.load_state_dict(checkpoint['model_state_dict'])
|
||
else:
|
||
model.load_state_dict(checkpoint)
|
||
|
||
model = model.to(device)
|
||
model.eval()
|
||
print("模型加载完成")
|
||
return model
|
||
|
||
|
||
def inference_single_image(model, image_path, transform, device, class_names):
|
||
"""对单张图像进行推理"""
|
||
image = Image.open(image_path).convert('RGB')
|
||
image_tensor = transform(image).unsqueeze(0).to(device)
|
||
|
||
with torch.no_grad():
|
||
start_time = time.time()
|
||
output = model(image_tensor)
|
||
inference_time = (time.time() - start_time) * 1000 # ms
|
||
|
||
probabilities = torch.softmax(output, dim=1)
|
||
pred_class = torch.argmax(probabilities, dim=1).item()
|
||
confidence = probabilities[0][pred_class].item()
|
||
|
||
return pred_class, confidence, inference_time
|
||
|
||
|
||
def inference_dataset(model, data_loader, device):
|
||
"""在整个数据集上运行推理"""
|
||
model.eval()
|
||
|
||
all_preds = []
|
||
all_labels = []
|
||
all_probs = []
|
||
inference_times = []
|
||
|
||
print("开始推理...")
|
||
with torch.no_grad():
|
||
for images, labels in tqdm(data_loader, desc="推理进度"):
|
||
images = images.to(device)
|
||
labels = labels.to(device)
|
||
|
||
# 推理
|
||
start_time = time.time()
|
||
outputs = model(images)
|
||
batch_time = (time.time() - start_time) * 1000 # ms
|
||
inference_times.append(batch_time / len(images))
|
||
|
||
# 获取预测结果
|
||
probabilities = torch.softmax(outputs, dim=1)
|
||
predictions = torch.argmax(probabilities, dim=1)
|
||
|
||
all_preds.extend(predictions.cpu().numpy())
|
||
all_labels.extend(labels.cpu().numpy())
|
||
all_probs.extend(probabilities.cpu().numpy())
|
||
|
||
return np.array(all_preds), np.array(all_labels), np.array(all_probs), inference_times
|
||
|
||
|
||
def calculate_metrics(y_true, y_pred, class_names):
|
||
"""计算各种评估指标"""
|
||
# 准确率
|
||
accuracy = np.mean(y_true == y_pred)
|
||
|
||
# 分类报告
|
||
report = classification_report(y_true, y_pred,
|
||
target_names=class_names,
|
||
output_dict=True)
|
||
|
||
# 混淆矩阵
|
||
cm = confusion_matrix(y_true, y_pred)
|
||
|
||
return accuracy, report, cm
|
||
|
||
|
||
def plot_confusion_matrix(cm, class_names, save_path):
|
||
"""绘制混淆矩阵"""
|
||
plt.figure(figsize=(12, 10))
|
||
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
|
||
xticklabels=class_names,
|
||
yticklabels=class_names)
|
||
plt.title('混淆矩阵', fontsize=16, fontproperties='SimHei')
|
||
plt.ylabel('真实类别', fontsize=12, fontproperties='SimHei')
|
||
plt.xlabel('预测类别', fontsize=12, fontproperties='SimHei')
|
||
plt.tight_layout()
|
||
plt.savefig(save_path, dpi=300, bbox_inches='tight')
|
||
plt.close()
|
||
print(f"混淆矩阵已保存: {save_path}")
|
||
|
||
|
||
def save_results(results, output_dir):
|
||
"""保存结果到JSON文件"""
|
||
os.makedirs(output_dir, exist_ok=True)
|
||
output_path = os.path.join(output_dir, 'inference_results.json')
|
||
|
||
with open(output_path, 'w', encoding='utf-8') as f:
|
||
json.dump(results, f, indent=4, ensure_ascii=False)
|
||
|
||
print(f"结果已保存: {output_path}")
|
||
|
||
|
||
def main():
|
||
parser = argparse.ArgumentParser(description='PC端模型推理')
|
||
parser.add_argument('--model_path', type=str,
|
||
default='../data/models/best_model.pth',
|
||
help='模型路径')
|
||
parser.add_argument('--data_dir', type=str,
|
||
default='../data/processed/val',
|
||
help='测试数据目录')
|
||
parser.add_argument('--output_dir', type=str,
|
||
default='../results',
|
||
help='结果输出目录')
|
||
parser.add_argument('--batch_size', type=int, default=32,
|
||
help='批次大小')
|
||
parser.add_argument('--num_classes', type=int, default=10,
|
||
help='类别数量')
|
||
parser.add_argument('--device', type=str, default='cpu',
|
||
help='设备 (cpu/cuda)')
|
||
args = parser.parse_args()
|
||
|
||
# 设置设备
|
||
device = torch.device(args.device if torch.cuda.is_available() else 'cpu')
|
||
print(f"使用设备: {device}")
|
||
|
||
# 创建输出目录
|
||
os.makedirs(args.output_dir, exist_ok=True)
|
||
|
||
# 数据预处理
|
||
transform = transforms.Compose([
|
||
transforms.Resize((224, 224)),
|
||
transforms.ToTensor(),
|
||
transforms.Normalize(mean=[0.485, 0.456, 0.406],
|
||
std=[0.229, 0.224, 0.225])
|
||
])
|
||
|
||
# 加载数据集
|
||
print(f"加载测试数据: {args.data_dir}")
|
||
test_dataset = LightImageDataset(args.data_dir, transform=transform)
|
||
test_loader = DataLoader(test_dataset, batch_size=args.batch_size,
|
||
shuffle=False, num_workers=0)
|
||
|
||
class_names = [f'class_{i}' for i in range(args.num_classes)]
|
||
print(f"测试样本数: {len(test_dataset)}")
|
||
print(f"类别数: {args.num_classes}")
|
||
|
||
# 加载模型
|
||
model = load_model(args.model_path, args.num_classes, device)
|
||
|
||
# 运行推理
|
||
print("\n" + "="*50)
|
||
print("开始推理测试")
|
||
print("="*50)
|
||
preds, labels, probs, inf_times = inference_dataset(model, test_loader, device)
|
||
|
||
# 计算指标
|
||
accuracy, report, cm = calculate_metrics(labels, preds, class_names)
|
||
|
||
# 计算推理时间统计
|
||
avg_time = np.mean(inf_times)
|
||
std_time = np.std(inf_times)
|
||
min_time = np.min(inf_times)
|
||
max_time = np.max(inf_times)
|
||
|
||
# 打印结果
|
||
print("\n" + "="*50)
|
||
print("推理结果")
|
||
print("="*50)
|
||
print(f"总体准确率: {accuracy*100:.2f}%")
|
||
print(f"\n平均推理时间: {avg_time:.2f} ms/图像")
|
||
print(f"标准差: {std_time:.2f} ms")
|
||
print(f"最小时间: {min_time:.2f} ms")
|
||
print(f"最大时间: {max_time:.2f} ms")
|
||
print(f"吞吐量: {1000/avg_time:.2f} FPS")
|
||
|
||
print("\n各类别详细指标:")
|
||
print("-"*50)
|
||
for class_name in class_names:
|
||
if class_name in report:
|
||
metrics = report[class_name]
|
||
print(f"{class_name}:")
|
||
print(f" 精确率: {metrics['precision']*100:.2f}%")
|
||
print(f" 召回率: {metrics['recall']*100:.2f}%")
|
||
print(f" F1分数: {metrics['f1-score']*100:.2f}%")
|
||
print(f" 样本数: {metrics['support']}")
|
||
|
||
# 绘制混淆矩阵
|
||
cm_path = os.path.join(args.output_dir, 'confusion_matrix.png')
|
||
plot_confusion_matrix(cm, class_names, cm_path)
|
||
|
||
# 保存结果
|
||
results = {
|
||
'model_path': args.model_path,
|
||
'test_samples': len(test_dataset),
|
||
'accuracy': float(accuracy),
|
||
'inference_time': {
|
||
'average_ms': float(avg_time),
|
||
'std_ms': float(std_time),
|
||
'min_ms': float(min_time),
|
||
'max_ms': float(max_time),
|
||
'fps': float(1000/avg_time)
|
||
},
|
||
'classification_report': report,
|
||
'confusion_matrix': cm.tolist(),
|
||
'predictions': preds.tolist(),
|
||
'ground_truth': labels.tolist()
|
||
}
|
||
|
||
save_results(results, args.output_dir)
|
||
|
||
print("\n" + "="*50)
|
||
print("推理完成!")
|
||
print(f"结果保存在: {args.output_dir}")
|
||
print("="*50)
|
||
|
||
|
||
if __name__ == '__main__':
|
||
main()
|
||
|