把预测结果放在某一个文件夹内里面Python代码-CSDN博客

以下是将预测结果保存到指定文件夹的完整Python代码：

## 完整代码

```python
import os
import numpy as np
import pandas as pd
from PIL import Image
import shutil
from datetime import datetime

class PredictionResultSaver:
def __init__(self, output_dir="prediction_results"):
"""
初始化预测结果保存器

Args:
output_dir: 输出目录路径
"""
self.output_dir = output_dir
self.create_output_dirs()

def create_output_dirs(self):
"""创建输出目录结构"""
# 主输出目录
os.makedirs(self.output_dir, exist_ok=True)

# 按类别创建子目录
self.cats_dir = os.path.join(self.output_dir, "cats")
self.dogs_dir = os.path.join(self.output_dir, "dogs")
self.uncertain_dir = os.path.join(self.output_dir, "uncertain")

for dir_path in [self.cats_dir, self.dogs_dir, self.uncertain_dir]:
os.makedirs(dir_path, exist_ok=True)

def save_prediction_results(self, classifier, test_images_dir, confidence_threshold=0.7):
"""
对测试文件夹中的所有图像进行预测并保存结果

Args:
classifier: 训练好的分类器
test_images_dir: 测试图像目录
confidence_threshold: 置信度阈值，低于此值视为不确定
"""
results = []
image_files = [f for f in os.listdir(test_images_dir)
if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.tiff'))]

print(f"找到 {len(image_files)} 张测试图像")

for image_file in image_files:
image_path = os.path.join(test_images_dir, image_file)

try:
# 预测
predicted_class, confidence = classifier.predict_single_image(image_path)

# 确定目标目录
if confidence < confidence_threshold:
target_dir = self.uncertain_dir
status = "uncertain"
else:
target_dir = self.cats_dir if predicted_class == "cats" else self.dogs_dir
status = "confident"

# 复制文件到目标目录
new_filename = f"{confidence:.4f}_{predicted_class}_{image_file}"
target_path = os.path.join(target_dir, new_filename)
shutil.copy2(image_path, target_path)

# 记录结果
results.append({
'filename': image_file,
'predicted_class': predicted_class,
'confidence': confidence,
'status': status,
'saved_path': target_path
})

print(f"预测: {image_file} -> {predicted_class} ({confidence:.4f}) -> {status}")

except Exception as e:
print(f"处理图像 {image_file} 时出错: {e}")
results.append({
'filename': image_file,
'predicted_class': 'error',
'confidence': 0.0,
'status': 'error',
'saved_path': '',
'error': str(e)
})

# 保存结果到CSV文件
self.save_results_to_csv(results)
self.generate_summary_report(results)

return results

def save_results_to_csv(self, results):
"""保存预测结果到CSV文件"""
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
csv_filename = f"prediction_results_{timestamp}.csv"
csv_path = os.path.join(self.output_dir, csv_filename)

df = pd.DataFrame(results)
df.to_csv(csv_path, index=False, encoding='utf-8')
print(f"预测结果已保存到: {csv_path}")

def generate_summary_report(self, results):
"""生成预测结果摘要报告"""
if not results:
return

df = pd.DataFrame(results)

# 统计信息
total_images = len(results)
confident_predictions = len(df[df['status'] == 'confident'])
uncertain_predictions = len(df[df['status'] == 'uncertain'])
errors = len(df[df['status'] == 'error'])

cats_count = len(df[df['predicted_class'] == 'cats'])
dogs_count = len(df[df['predicted_class'] == 'dogs'])

avg_confidence = df[df['confidence'] > 0]['confidence'].mean()

# 生成报告
report = f"""
预测结果摘要报告
生成时间: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}

总体统计:
- 总图像数量: {total_images}
- 确信预测: {confident_predictions} ({confident_predictions/total_images*100:.1f}%)
- 不确定预测: {uncertain_predictions} ({uncertain_predictions/total_images*100:.1f}%)
- 错误数量: {errors} ({errors/total_images*100:.1f}%)

分类结果:
- 猫: {cats_count} 张
- 狗: {dogs_count} 张

置信度统计:
- 平均置信度: {avg_confidence:.4f}
- 最高置信度: {df['confidence'].max():.4f}
- 最低置信度: {df[df['confidence'] > 0]['confidence'].min():.4f}
"""

# 保存报告
report_filename = f"prediction_summary_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
report_path = os.path.join(self.output_dir, report_filename)

with open(report_path, 'w', encoding='utf-8') as f:
f.write(report)

print(f"摘要报告已保存到: {report_path}")
print(report)

# 集成到之前的猫狗分类器中
def add_prediction_saving_to_classifier():
"""为猫狗分类器添加预测保存功能"""

# 修改之前的predict_single_image方法，使其可以被外部调用
def enhanced_predict_single_image(self, image_path):
"""
增强的单张图像预测方法

Args:
image_path: 图像路径

Returns:
predicted_class, confidence
"""
# 加载和预处理图像
img = Image.open(image_path)
img = img.resize(self.img_size)
img_array = np.array(img) / 255.0
img_array = np.expand_dims(img_array, axis=0)

# 预测
predictions = self.model.predict(img_array, verbose=0)
class_idx = np.argmax(predictions[0])
confidence = predictions[0][class_idx]

# 获取类别标签
class_labels = list(self.train_generator.class_indices.keys())
predicted_class = class_labels[class_idx]

return predicted_class, confidence

# 将新方法添加到原有的类中
from types import MethodType
import tensorflow as tf

# 假设你的分类器类叫做CatDogClassifier
# 在实际使用时替换为你的实际类名
tf.keras.models.Model.predict_single_image = enhanced_predict_single_image

# 使用示例
def main():
"""主函数 - 使用预测结果保存功能"""

# 初始化分类器（使用之前定义的CatDogClassifier）
classifier = CatDogClassifier()

# 加载训练好的模型
classifier.load_model("cat_dog_resnet50.h5") # 替换为你的模型路径

# 初始化预测结果保存器
result_saver = PredictionResultSaver("I:/prediction_results") # 替换为你想要的输出路径

# 对测试文件夹进行预测并保存结果
test_dir = "I:/test_images" # 替换为你的测试图像文件夹路径
results = result_saver.save_prediction_results(
classifier=classifier,
test_images_dir=test_dir,
confidence_threshold=0.8 # 可以调整置信度阈值
)

print("预测完成！结果已保存到指定文件夹。")

# 如果你想要一个简单的版本，可以使用这个函数
def simple_save_predictions(classifier, test_dir, output_dir="predictions"):
"""
简单版本的预测结果保存

Args:
classifier: 训练好的分类器
test_dir: 测试图像目录
output_dir: 输出目录
"""
os.makedirs(output_dir, exist_ok=True)

for image_file in os.listdir(test_dir):
if image_file.lower().endswith(('.png', '.jpg', '.jpeg')):
image_path = os.path.join(test_dir, image_file)

# 预测
predicted_class, confidence = classifier.predict_single_image(image_path)

# 创建类别子目录
class_dir = os.path.join(output_dir, predicted_class)
os.makedirs(class_dir, exist_ok=True)

# 复制文件
new_name = f"{confidence:.3f}_{image_file}"
target_path = os.path.join(class_dir, new_name)
shutil.copy2(image_path, target_path)

print(f"已保存: {image_file} -> {target_path}")

if __name__ == "__main__":
main()
```

## 使用方法

### 方法1：使用完整的预测保存器
```python
# 初始化
classifier = CatDogClassifier()
classifier.load_model("your_model.h5")

result_saver = PredictionResultSaver("output_folder")
results = result_saver.save_prediction_results(classifier, "test_images_folder")
```

### 方法2：简单版本
```python
simple_save_predictions(classifier, "test_images", "predictions_output")
```

## 输出目录结构

运行后会生成如下目录结构：
```
prediction_results/
├── cats/ # 预测为猫的图像
│ ├── 0.9567_cats_image1.jpg
│ └── 0.8923_cats_image2.jpg
├── dogs/ # 预测为狗的图像
│ ├── 0.9345_dogs_image1.jpg
│ └── 0.8765_dogs_image2.jpg
├── uncertain/ # 不确定的图像（置信度低）
│ └── 0.6456_uncertain_image.jpg
├── prediction_results_20231122_223045.csv # 详细结果CSV
└── prediction_summary_20231122_223045.txt # 摘要报告
```

## 文件命名规则

保存的文件会按照以下格式命名：
```
置信度_预测类别_原文件名.jpg
```
例如：`0.9567_cats_cat_photo.jpg`

这样你就可以清楚地看到每个预测结果的置信度和分类情况。