机器学习——十大大型猫科动物分类

# 加载预训练模型
pretrained_model = tf.keras.applications.EfficientNetB0(
    input_shape=(224, 224, 3),  # 输入图像的形状为(224, 224, 3)
    include_top=False,  # 不包含顶层 (输出层)
    weights='imagenet',  # 使用 ImageNet 数据集预训练的权重
    pooling='max'  # 使用最大池化操作作为模型的输出
)

# 冻结预训练神经网络的层
for i, layer in enumerate(pretrained_model.layers):
    pretrained_model.layers[i].trainable = False  

num_classes = len(set(train_images.classes)) # 计算训练集中的类别数量

# 数据增强步骤
augment = tf.keras.Sequential([
  layers.experimental.preprocessing.RandomFlip("horizontal"),  # 随机水平翻转
  layers.experimental.preprocessing.RandomRotation(0.13),  # 随机旋转
  layers.experimental.preprocessing.RandomZoom(0.12),  # 随机缩放
  layers.experimental.preprocessing.RandomContrast(0.12),  # 随机对比度调整
], name='AugmentationLayer')

inputs = layers.Input(shape=(224, 224, 3), name='inputLayer')  # 输入层
x = augment(inputs)  # 应用数据增强到输入数据上
pretrain_out = pretrained_model(x, training=False)  # 使用预训练模型提取特征，设置 training=False 表示在推理阶段使用预训练权重
x = layers.Dense(256)(pretrain_out)  # 添加一个全连接层，节点数为256
x = layers.Activation(activation="relu")(x)  # 使用 ReLU 激活函数
x = BatchNormalization()(x)  # 批归一化
x = layers.Dropout(0.45)(x)  # 添加一个 Dropout 层，丢弃率为0.45
x = layers.Dense(num_classes)(x)  # 添加一个输出层，节点数为类别数量
outputs = layers.Activation(activation="softmax", dtype=tf.float32, name='activationLayer')(x)  # 使用 softmax 激活函数作为输出层，用于多分类问题
model = Model(inputs=inputs, outputs=outputs)  # 定义模型的输入和输出

model.compile(
    optimizer=Adam(0.0005),  # 使用 Adam 优化器，学习率为0.0005
    loss='categorical_crossentropy',  # 使用交叉熵损失函数
    metrics=['accuracy']  # 评估指标为准确率
)

print(model.summary())  # 打印模型的概要信息

history = model.fit(
    train_images,  # 训练集数据
    steps_per_epoch=len(train_images),  # 每个epoch的步数，这里设置为训练集样本数量
    validation_data=val_images,  # 验证集数据
    validation_steps=len(val_images),  # 验证集每个epoch的步数，这里设置为验证集样本数量
    epochs=3,  # 迭代的轮数
    callbacks=[
        EarlyStopping(
            monitor="val_loss",  # 监控验证集损失值
            patience=3,  # 如果连续3个epoch验证集损失值没有改善，则停止训练
            restore_best_weights=True  # 在停止训练后恢复到验证集损失最低的权重
        ),
        ReduceLROnPlateau(
            monitor='val_loss',  # 监控验证集损失值
            factor=0.2,  # 学习率下降的因子，即将学习率乘以0.2
            patience=2,  # 如果连续2个epoch验证集损失值没有改善，则降低学习率
            mode='min'  # 监控损失值减小的模式
        )
    ]
)
model.save_weights('./checkpoints/my_checkpoint')  # 保存模型权重到指定路径

pretrained_model.trainable = True  # 设置预训练模型为可训练

for layer in pretrained_model.layers:
    if isinstance(layer, layers.BatchNormalization):  # 将BatchNorm层设置为不可训练
        layer.trainable = False

# 查看前10个层的训练情况
for l in pretrained_model.layers[:10]:
    print(l.name, l.trainable)

model.compile(
    optimizer=Adam(0.00001),  # 微调需要非常小的学习率
    loss='categorical_crossentropy',
    metrics=['accuracy']
)
# model.load_weights('./checkpoints/my_checkpoint')  # 加载之前保存的模型权重
print(model.summary())  # 打印模型概述信息
history = model.fit(
    train_images,
    steps_per_epoch=len(train_images),
    validation_data=val_images,
    validation_steps=len(val_images),
    epochs=2,
    callbacks=[
        EarlyStopping(monitor="val_loss",  # 监控验证集损失指标
                      patience=3,
                      restore_best_weights=True),  # 如果连续5个轮次验证集损失都在增加，则停止训练
        ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=2, mode='min')  # 如果连续2个轮次验证集损失没有减少，则降低学习率
    ]
)
model.save_weights('./checkpoints/my_checkpoint')  # 保存模型权重

# 定义所需变量
tr_acc = history.history['accuracy']  # 训练准确率
tr_loss = history.history['loss']  # 训练损失
val_acc = history.history['val_accuracy']  # 验证准确率
val_loss = history.history['val_loss']  # 验证损失
index_loss = np.argmin(val_loss)  # 最小验证损失的索引
val_lowest = val_loss[index_loss]  # 最小验证损失
index_acc = np.argmax(val_acc)  # 最大验证准确率的索引
acc_highest = val_acc[index_acc]  # 最大验证准确率
Epochs = [i + 1 for i in range(len(tr_acc))]  # 轮次
loss_label = f'最佳轮次= {str(index_loss + 1)}'  # 损失标签
acc_label = f'最佳轮次= {str(index_acc + 1)}'  # 准确率标签

# 绘制训练历史记录图
plt.figure(figsize=(20, 8))
plt.style.use('fivethirtyeight')

plt.subplot(1, 2, 1)
plt.plot(Epochs, tr_loss, 'r', label='训练损失')
plt.plot(Epochs, val_loss, 'g', label='验证损失')
plt.scatter(index_loss + 1, val_lowest, s=150, c='blue', label=loss_label)
plt.title('训练和验证损失')
plt.xlabel('轮次')
plt.ylabel('损失')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(Epochs, tr_acc, 'r', label='训练准确率')
plt.plot(Epochs, val_acc, 'g', label='验证准确率')
plt.scatter(index_acc + 1, acc_highest, s=150, c='blue', label=acc_label)
plt.title('训练和验证准确率')
plt.xlabel('轮次')
plt.ylabel('准确率')
plt.legend()

plt.tight_layout
plt.show()

results = model.evaluate(test_images, verbose=0)

print("    Test Loss: {:.5f}".format(results[0]))  # 打印测试损失
print("Test Accuracy: {:.2f}%".format(results[1] * 100))  # 打印测试准确率

# 获取真实标签和预测标签
y_true = test_images.classes  # 真实标签
y_pred = np.argmax(model.predict(test_images), axis=1)  # 预测标签

# 计算F1得分
f1 = f1_score(y_true, y_pred, average='macro')
print("F1 Score:", f1)

# 打印分类报告
print(classification_report(y_true, y_pred, target_names=test_images.class_indices.keys()))

# 将索引和类别名称做对应关系
classes = dict(zip(test_images.class_indices.values(), test_images.class_indices.keys()))

# 构建包含真实标签、预测标签和其他信息的DataFrame
Predictions = pd.DataFrame({
    "Image Index": list(range(len(test_images.labels))),  # 图像索引
    "Test Labels": test_images.labels,  # 真实标签
    "Test Classes": [classes[i] for i in test_images.labels],  # 真实类别
    "Prediction Labels": y_pred,  # 预测标签
    "Prediction Classes": [classes[i] for i in y_pred],  # 预测类别
    "Path": test_images.filenames,  # 图像路径
    "Prediction Probability": [x for x in np.asarray(tf.reduce_max(model.predict(test_images), axis=1))]  # 预测类别的概率
})

# 打印部分预测结果
Predictions.head(8)

# 创建一个大图，设置图像大小为20x20英寸
plt.figure(figsize=(20, 20))

# 获取预测错误的最高概率结果的前20个样本，并按照概率值进行排序
subset = Predictions[Predictions["Test Labels"] != Predictions["Prediction Labels"]].sort_values("Prediction Probability").tail(20).reset_index()

# 遍历每个样本并绘制子图
for i, row in subset.iterrows():
    # 在大图上创建子图，每行显示5个子图，共4行
    plt.subplot(5, 4, i+1)

    # 加载图像并显示
    image_path = row['Path']
    image = Image.open(image_path)
    plt.imshow(image)

    # 设置子图标题，包括真实类别和预测类别信息
    plt.title(f'TRUE: {row["Test Classes"]} | PRED: {row["Prediction Classes"]}', fontsize=8)

    # 关闭子图的坐标轴
    plt.axis('off')

# 显示图像
plt.show()

preds = model.predict_generator(test_images)  # 对测试图像进行预测
y_pred = np.argmax(preds, axis=1)  # 获取预测结果中概率最高的类别索引
g_dict = test_images.class_indices  # 获取类别名称和对应索引的字典
classes = list(g_dict.keys())  # 将类别名称转换为列表

# 计算混淆矩阵
cm = confusion_matrix(test_images.classes, y_pred)

# 创建一个大图，设置图像大小为30x30英寸
plt.figure(figsize=(30, 30))

# 在图像上显示混淆矩阵
plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
plt.title('Confusion Matrix')
plt.colorbar()

# 设置刻度标签
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)

# 设置阈值，用于在混淆矩阵中显示数值
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
    plt.text(j, i, cm[i, j], horizontalalignment='center',
             color='white' if cm[i, j] > thresh else 'black')

# 调整图像布局并设置标签
plt.tight_layout()
plt.ylabel('True Label')
plt.xlabel('Predicted Label')

# 显示图像
plt.show()

import itertools
import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from PIL import Image
from sklearn.metrics import classification_report, f1_score , confusion_matrix

import tensorflow as tf
from tensorflow import keras
from keras.layers import Dense, Dropout , BatchNormalization
from tensorflow.keras.optimizers import Adam
from tensorflow.keras import layers,models,Model
from keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.layers.experimental import preprocessing
from tensorflow.keras.callbacks import Callback, EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
from tensorflow.keras import mixed_precision
mixed_precision.set_global_policy('mixed_float16')

# 数据集路径
dataset = {
    "train_data": "/kaggle/input/cats-in-the-wild-image-classification/train",
    "valid_data": "/kaggle/input/cats-in-the-wild-image-classification/valid",
    "test_data": "/kaggle/input/cats-in-the-wild-image-classification/test"
}

all_data = []  # 存储所有数据的列表
for path in dataset.values():  # 遍历数据集路径
    data = {"imgpath": [], "labels": []}  # 创建存储图像路径和标签的字典
    category = os.listdir(path)  # 获取当前路径下的分类目录列表

    for folder in category:  # 遍历每个分类目录
        folderpath = os.path.join(path, folder)  # 组合出分类目录的完整路径
        filelist = os.listdir(folderpath)  # 获取分类目录下的文件列表
        for file in filelist:  # 遍历每个文件
            fpath = os.path.join(folderpath, file)  # 组合出文件的完整路径
            data["imgpath"].append(fpath)  # 将文件路径添加到"imgpath"列表中
            data["labels"].append(folder)  # 将标签添加到"labels"列表中

    all_data.append(data.copy())  # 将当前数据字典的副本添加到all_data列表中
    data.clear()  # 清空当前数据字典

# 将数据转换为DataFrame对象
train_df = pd.DataFrame(all_data[0], index=range(len(all_data[0]['imgpath'])))
valid_df = pd.DataFrame(all_data[1], index=range(len(all_data[1]['imgpath'])))
test_df = pd.DataFrame(all_data[2], index=range(len(all_data[2]['imgpath'])))

# 将标签转换为数字
lb = LabelEncoder()
train_df['encoded_labels'] = lb.fit_transform(train_df['labels'])  # 将训练数据集的标签转换为数字形式
valid_df['encoded_labels'] = lb.fit_transform(valid_df['labels'])  # 将验证数据集的标签转换为数字形式
test_df['encoded_labels'] = lb.fit_transform(test_df['labels'])  # 将测试数据集的标签转换为数字形式

# 统计每个类别的训练数据图片数量
train = train_df["labels"].value_counts()

# 获取类别标签和对应的图片数量
label = train.tolist()
index = train.index.tolist()

# 颜色列表，用于给每个条形显示不同的颜色
colors = [
    "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd",
    "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf",
    "#aec7e8", "#ffbb78", "#98df8a", "#ff9896", "#c5b0d5",
    "#c49c94", "#f7b6d2", "#c7c7c7", "#dbdb8d", "#9edae5",
    "#5254a3", "#6b6ecf", "#bdbdbd", "#8ca252", "#bd9e39",
    "#ad494a", "#8c6d31", "#6b6ecf", "#e7ba52", "#ce6dbd",
    "#9c9ede", "#cedb9c", "#de9ed6", "#ad494a", "#d6616b",
    "#f7f7f7", "#7b4173", "#a55194", "#ce6dbd"
]

# 创建绘图窗口，并设置尺寸和标题
plt.figure(figsize=(30, 30))
plt.title("Training data images count per class", fontsize=38)

# 设置坐标轴标签
plt.xlabel('Number of images', fontsize=35)
plt.ylabel('Classes', fontsize=35)

# 使用水平条形图绘制每个类别的图片数量
plt.barh(index, label, color=colors)

# 开启网格线
plt.grid(True)

# 显示图形
plt.show()

# 从 train_df 中随机抽取 15 条样本数据，并设置随机种子为 1，以确保结果可复现
train_df.sample(n=15, random_state=1)

# 打印训练数据集的头部样本
print("----------Train-------------")
print(train_df[["imgpath", "labels"]].head(5))

# 打印训练数据集的形状（行数和列数）
print(train_df.shape)

# 打印验证数据集的头部样本
print("--------Validation----------")
print(valid_df[["imgpath", "labels"]].head(5))

# 打印验证数据集的形状（行数和列数）
print(valid_df.shape)

# 打印测试数据集的头部样本
print("----------Test--------------")
print(test_df[["imgpath", "labels"]].head(5))

# 打印测试数据集的形状（行数和列数）
print(test_df.shape)

# 设置图像大小为 15x12
plt.figure(figsize=(15, 12))

# 随机抽取验证数据集中的 16 条样本并进行展示
for i, row in valid_df.sample(n=16).reset_index().iterrows():
    plt.subplot(4, 4, i+1)  # 设置子图布局为 4 行 4 列，并指定当前子图位置
    image_path = row['imgpath']  # 获取图片路径
    image = Image.open(image_path)  # 打开并加载图片
    plt.imshow(image)  # 在子图中显示图片
    plt.title(row['labels'])  # 设置子图标题为样本的标签
    plt.axis('off')  # 关闭坐标轴

# 展示所有子图
plt.show()

%%time

BATCH_SIZE = 10  # 批量大小
IMAGE_SIZE = (224, 224)  # 图片大小

# 创建带有预处理函数的图像生成器
generator = ImageDataGenerator(
    preprocessing_function=tf.keras.applications.efficientnet.preprocess_input,
    # 这里也可以添加图像增强操作
)

# 将数据集分为三部分并分别进行准备
train_images = generator.flow_from_dataframe(
    dataframe=train_df,  # 训练数据集 DataFrame 对象
    x_col='imgpath',  # 图片路径列名
    y_col='labels',  # 标签列名
    target_size=IMAGE_SIZE,  # 缩放图片大小
    color_mode='rgb',  # 图片颜色模式：RGB
    class_mode='categorical',  # 标签为多分类标签
    batch_size=BATCH_SIZE,  # 批量大小
    shuffle=True,  # 是否随机乱序
    seed=42,  # 随机种子，用于重复实验结果
)

val_images = generator.flow_from_dataframe(
    dataframe=valid_df,  # 验证数据集 DataFrame 对象
    x_col='imgpath',  # 图片路径列名
    y_col='labels',  # 标签列名
    target_size=IMAGE_SIZE,  # 缩放图片大小
    color_mode='rgb',  # 图片颜色模式：RGB
    class_mode='categorical',  # 标签为多分类标签
    batch_size=BATCH_SIZE,  # 批量大小
    shuffle=False,  # 不需要随机乱序
)

test_images = generator.flow_from_dataframe(
    dataframe=test_df,  # 测试数据集 DataFrame 对象
    x_col='imgpath',  # 图片路径列名
    y_col='labels',  # 标签列名
    target_size=IMAGE_SIZE,  # 缩放图片大小
    color_mode='rgb',  # 图片颜色模式：RGB
    class_mode='categorical',  # 标签为多分类标签
    batch_size=BATCH_SIZE,  # 批量大小
    shuffle=False,  # 不需要随机乱序
)

# 加载预训练模型
pretrained_model = tf.keras.applications.EfficientNetB0(
    input_shape=(224, 224, 3),  # 输入图像的形状为(224, 224, 3)
    include_top=False,  # 不包含顶层 (输出层)
    weights='imagenet',  # 使用 ImageNet 数据集预训练的权重
    pooling='max'  # 使用最大池化操作作为模型的输出
)

# 冻结预训练神经网络的层
for i, layer in enumerate(pretrained_model.layers):
    pretrained_model.layers[i].trainable = False  

num_classes = len(set(train_images.classes)) # 计算训练集中的类别数量

# 数据增强步骤
augment = tf.keras.Sequential([
  layers.experimental.preprocessing.RandomFlip("horizontal"),  # 随机水平翻转
  layers.experimental.preprocessing.RandomRotation(0.13),  # 随机旋转
  layers.experimental.preprocessing.RandomZoom(0.12),  # 随机缩放
  layers.experimental.preprocessing.RandomContrast(0.12),  # 随机对比度调整
], name='AugmentationLayer')

inputs = layers.Input(shape=(224, 224, 3), name='inputLayer')  # 输入层
x = augment(inputs)  # 应用数据增强到输入数据上
pretrain_out = pretrained_model(x, training=False)  # 使用预训练模型提取特征，设置 training=False 表示在推理阶段使用预训练权重
x = layers.Dense(256)(pretrain_out)  # 添加一个全连接层，节点数为256
x = layers.Activation(activation="relu")(x)  # 使用 ReLU 激活函数
x = BatchNormalization()(x)  # 批归一化
x = layers.Dropout(0.45)(x)  # 添加一个 Dropout 层，丢弃率为0.45
x = layers.Dense(num_classes)(x)  # 添加一个输出层，节点数为类别数量
outputs = layers.Activation(activation="softmax", dtype=tf.float32, name='activationLayer')(x)  # 使用 softmax 激活函数作为输出层，用于多分类问题
model = Model(inputs=inputs, outputs=outputs)  # 定义模型的输入和输出

model.compile(
    optimizer=Adam(0.0005),  # 使用 Adam 优化器，学习率为0.0005
    loss='categorical_crossentropy',  # 使用交叉熵损失函数
    metrics=['accuracy']  # 评估指标为准确率
)

print(model.summary())  # 打印模型的概要信息

history = model.fit(
    train_images,  # 训练集数据
    steps_per_epoch=len(train_images),  # 每个epoch的步数，这里设置为训练集样本数量
    validation_data=val_images,  # 验证集数据
    validation_steps=len(val_images),  # 验证集每个epoch的步数，这里设置为验证集样本数量
    epochs=3,  # 迭代的轮数
    callbacks=[
        EarlyStopping(
            monitor="val_loss",  # 监控验证集损失值
            patience=3,  # 如果连续3个epoch验证集损失值没有改善，则停止训练
            restore_best_weights=True  # 在停止训练后恢复到验证集损失最低的权重
        ),
        ReduceLROnPlateau(
            monitor='val_loss',  # 监控验证集损失值
            factor=0.2,  # 学习率下降的因子，即将学习率乘以0.2
            patience=2,  # 如果连续2个epoch验证集损失值没有改善，则降低学习率
            mode='min'  # 监控损失值减小的模式
        )
    ]
)
model.save_weights('./checkpoints/my_checkpoint')  # 保存模型权重到指定路径

pretrained_model.trainable = True  # 设置预训练模型为可训练

for layer in pretrained_model.layers:
    if isinstance(layer, layers.BatchNormalization):  # 将BatchNorm层设置为不可训练
        layer.trainable = False

# 查看前10个层的训练情况
for l in pretrained_model.layers[:10]:
    print(l.name, l.trainable)

model.compile(
    optimizer=Adam(0.00001),  # 微调需要非常小的学习率
    loss='categorical_crossentropy',
    metrics=['accuracy']
)
# model.load_weights('./checkpoints/my_checkpoint')  # 加载之前保存的模型权重
print(model.summary())  # 打印模型概述信息
history = model.fit(
    train_images,
    steps_per_epoch=len(train_images),
    validation_data=val_images,
    validation_steps=len(val_images),
    epochs=2,
    callbacks=[
        EarlyStopping(monitor="val_loss",  # 监控验证集损失指标
                      patience=3,
                      restore_best_weights=True),  # 如果连续5个轮次验证集损失都在增加，则停止训练
        ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=2, mode='min')  # 如果连续2个轮次验证集损失没有减少，则降低学习率
    ]
)
model.save_weights('./checkpoints/my_checkpoint')  # 保存模型权重

# 定义所需变量
tr_acc = history.history['accuracy']  # 训练准确率
tr_loss = history.history['loss']  # 训练损失
val_acc = history.history['val_accuracy']  # 验证准确率
val_loss = history.history['val_loss']  # 验证损失
index_loss = np.argmin(val_loss)  # 最小验证损失的索引
val_lowest = val_loss[index_loss]  # 最小验证损失
index_acc = np.argmax(val_acc)  # 最大验证准确率的索引
acc_highest = val_acc[index_acc]  # 最大验证准确率
Epochs = [i + 1 for i in range(len(tr_acc))]  # 轮次
loss_label = f'最佳轮次= {str(index_loss + 1)}'  # 损失标签
acc_label = f'最佳轮次= {str(index_acc + 1)}'  # 准确率标签

# 绘制训练历史记录图
plt.figure(figsize=(20, 8))
plt.style.use('fivethirtyeight')

plt.subplot(1, 2, 1)
plt.plot(Epochs, tr_loss, 'r', label='训练损失')
plt.plot(Epochs, val_loss, 'g', label='验证损失')
plt.scatter(index_loss + 1, val_lowest, s=150, c='blue', label=loss_label)
plt.title('训练和验证损失')
plt.xlabel('轮次')
plt.ylabel('损失')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(Epochs, tr_acc, 'r', label='训练准确率')
plt.plot(Epochs, val_acc, 'g', label='验证准确率')
plt.scatter(index_acc + 1, acc_highest, s=150, c='blue', label=acc_label)
plt.title('训练和验证准确率')
plt.xlabel('轮次')
plt.ylabel('准确率')
plt.legend()

plt.tight_layout
plt.show()

results = model.evaluate(test_images, verbose=0)

print("    Test Loss: {:.5f}".format(results[0]))  # 打印测试损失
print("Test Accuracy: {:.2f}%".format(results[1] * 100))  # 打印测试准确率

# 获取真实标签和预测标签
y_true = test_images.classes  # 真实标签
y_pred = np.argmax(model.predict(test_images), axis=1)  # 预测标签

# 计算F1得分
f1 = f1_score(y_true, y_pred, average='macro')
print("F1 Score:", f1)

# 打印分类报告
print(classification_report(y_true, y_pred, target_names=test_images.class_indices.keys()))

# 将索引和类别名称做对应关系
classes = dict(zip(test_images.class_indices.values(), test_images.class_indices.keys()))

# 构建包含真实标签、预测标签和其他信息的DataFrame
Predictions = pd.DataFrame({
    "Image Index": list(range(len(test_images.labels))),  # 图像索引
    "Test Labels": test_images.labels,  # 真实标签
    "Test Classes": [classes[i] for i in test_images.labels],  # 真实类别
    "Prediction Labels": y_pred,  # 预测标签
    "Prediction Classes": [classes[i] for i in y_pred],  # 预测类别
    "Path": test_images.filenames,  # 图像路径
    "Prediction Probability": [x for x in np.asarray(tf.reduce_max(model.predict(test_images), axis=1))]  # 预测类别的概率
})

# 打印部分预测结果
Predictions.head(8)

# 创建一个大图，设置图像大小为20x20英寸
plt.figure(figsize=(20, 20))

# 获取预测错误的最高概率结果的前20个样本，并按照概率值进行排序
subset = Predictions[Predictions["Test Labels"] != Predictions["Prediction Labels"]].sort_values("Prediction Probability").tail(20).reset_index()

# 遍历每个样本并绘制子图
for i, row in subset.iterrows():
    # 在大图上创建子图，每行显示5个子图，共4行
    plt.subplot(5, 4, i+1)

    # 加载图像并显示
    image_path = row['Path']
    image = Image.open(image_path)
    plt.imshow(image)

    # 设置子图标题，包括真实类别和预测类别信息
    plt.title(f'TRUE: {row["Test Classes"]} | PRED: {row["Prediction Classes"]}', fontsize=8)

    # 关闭子图的坐标轴
    plt.axis('off')

# 显示图像
plt.show()

preds = model.predict_generator(test_images)  # 对测试图像进行预测
y_pred = np.argmax(preds, axis=1)  # 获取预测结果中概率最高的类别索引
g_dict = test_images.class_indices  # 获取类别名称和对应索引的字典
classes = list(g_dict.keys())  # 将类别名称转换为列表

# 计算混淆矩阵
cm = confusion_matrix(test_images.classes, y_pred)

# 创建一个大图，设置图像大小为30x30英寸
plt.figure(figsize=(30, 30))

# 在图像上显示混淆矩阵
plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
plt.title('Confusion Matrix')
plt.colorbar()

# 设置刻度标签
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)

# 设置阈值，用于在混淆矩阵中显示数值
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
    plt.text(j, i, cm[i, j], horizontalalignment='center',
             color='white' if cm[i, j] > thresh else 'black')

# 调整图像布局并设置标签
plt.tight_layout()
plt.ylabel('True Label')
plt.xlabel('Predicted Label')

# 显示图像
plt.show()