Files

254 lines
8.1 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""
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()