猫狗大战----【Inter校企合作】

一、问题以及数据集

1.问题描述

         在这个问题中，你将面临一个经典的机器学习分类挑战——猫狗大战。你的任务是建立一个分类模型，能够准确地区分图像中是猫还是狗。

2.预期解决方案：

你的目标是通过训练一个机器学习模型，使其在给定一张图像时能够准确地预测图像中是猫还是狗。模型应该能够推广到未见过的图像，并在测试数据上表现良好。我们期待您将其部署到模拟的生产环境中——这里推理时间和二分类准确度（F1分数）将作为评分的主要依据。

3.数据集

链接：百度网盘 请输入提取码 

提取码：jc34

二、数据集

1.数据集：

本实验数据集由test1和train两个文件组成

 其中train文件夹中分别有12500张cat图片，12500张dog图片

在test1文件夹中有25000张不知为cat或是dog的图片

2.查看图片：

三、解决方案 

1. 加载、查看 训练集/测试集

查看训练集/测试集大小：

#训练集
# 图片路径
train_path = './data/train' 
test_path = './data/test1'


#获取所有图片文件名
train_files = os.listdir(train_path)
test_files = os.listdir(test_path)

print("训练集大小为：{}".format(len(train_files)))
print("测试集大小为：{}".format(len(test_files)))

运行结果：

 2.处理数据

2.1训练集

        创建一个空的 pandas.DataFrame 对象 train_df，用于存储数据集的信息。

head() 方法打印输出 train_df 的前几行数据。

#构造数据集
image_paths = []
labels = []

#循环遍历文件
for file in train_files:
    label = file.split('.')[0]
    labels.append(label)
    image_path = os.path.join(train_path,file)
    image_paths.append(image_path)
    
train_df = pandas.DataFrame()#创建dataFrame
train_df['train_image_path'] = image_paths
train_df['label'] = labels
train_df.head()

运行结果：

2.2测试集

#测试集
image_paths = []
test_idx = []
for file in test_files:
    idx = file.split('.')[0]
    test_idx.append(idx)
    image_path = os.path.join(test_path,file)
    image_paths.append(image_path)
    
test_df = pandas.DataFrame()
test_df['test_image_path'] = image_paths
test_df.head()

运行结果

3.分割训练集为数据集以及验证集

        使用 train_set['label'].hist() 和 val_set['label'].hist() 分别绘制训练集和验证集中各类标签的直方图。

#以下为分层抽样，随机抽样容易出现偏差
from sklearn.model_selection import train_test_split

#更新Numpy
#!pip install numpy --upgrade

#stratify参数被设置时，会按照标签的比例将数据集分为训练集和测试集
train_set,val_set = train_test_split(train_df,random_state = 42 , stratify = train_df['label'])

print("训练集大小：{}".format(len(train_set)))
print("验证集大小：{}".format(len(val_set)))

train_set['label'].hist()#此时样本是无偏的
val_set['label'].hist()

运行结果

4.数据增强

在这里使用 了Keras 的 ImageDataGenerator 类对训练集进行数据增强。

1.1训练集

        创建一个数据增强器 train_gen，其中包括了多种数据增强方法，例如缩放、旋转、剪切、翻转等。通过这些数据增强方法，可以生成更多的训练图像，增加模型的泛化能力。

#数据增强

train_gen = ImageDataGenerator(
    zoom_range=0.1,
    rotation_range=10,
    rescale=1./255,
    shear_range=0.1,
    horizontal_flip=True,
    width_shift_range=0.1,
    height_shift_range=0.1
)

train_generator = train_gen.flow_from_dataframe(
    dataframe=train_set,
    x_col='train_image_path',
    y_col='label',
    target_size=(200,200),
    class_mode='binary',
    batch_size=128,
    shuffle=False
)

print(len(train_generator))

运行结果

1.2验证集

#验证集
val_gen = ImageDataGenerator(
    rescale=1./255
)
val_generator = val_gen.flow_from_dataframe(
    dataframe=val_set,
    x_col='train_image_path',#指定参数范围
    y_col='label',
    target_size=(200,200),
    class_mode='binary',#表示为二分类问题
    batch_size=128,#每批次生成128张图片
    shuffle=False#不对数据进行随机打乱
)
#打印验证集数据生成器长度
print(len(val_generator))

运行结果

1.3测试集

#测试集
test_datagen = ImageDataGenerator(
    rescale=1./255
)
test_generator = test_datagen.flow_from_dataframe(
    dataframe=test_df,
    x_col='test_image_path',
    y_col=None,
    target_size=(200,200),
    class_mode=None,
    batch_size=128,
    shuffle=False
)
print(len(test_generator))

运行结果

5.搭建模型

在这里使用 Keras 中的 VGG16 预训练模型搭建了一个卷积神经网络模型。

        对 VGG16 的所有层进行权重冻结，即不进行训练。这是因为预训练好的 VGG16 模型已经在大规模的数据集上进行了训练，具有较强的特征提取能力，我们只需要将其作为卷积部分来提取图像特征即可。

        向 model 中添加 VGG16 的卷积部分 vgg16，即将其作为第一层。由于 vgg16 的权重已经被冻结，因此在训练过程中不会更新它的权重。接着向 model 中添加一个展平层 Flatten()，将卷积层的输出展平成一维向量，方便全连接层处理。然后向 model 中添加一个具有 128 个神经元的全连接层 Dense(128, activation='relu')，使用 ReLU 激活函数。最后向 model 中添加一个具有 1 个神经元的输出层 Dense(1, activation='sigmoid')，使用 sigmoid 激活函数，用于进行二分类任务。

from keras.applications.vgg16 import VGG16
from keras.models import Sequential
from keras.layers import Flatten, Dense

# 加载VGG16预训练模型，不包括顶部的全连接层
vgg16 = VGG16(weights='imagenet', include_top=False, input_shape=(200, 200, 3))

# 冻结VGG16的权重，不进行训练
for layer in vgg16.layers:
    layer.trainable = False
    
# 创建模型
model = Sequential()
#添加VGG16的卷积部分
model.add(vgg16)
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

6.设计优化器和损失函数

优化器为adam

损失函数为交叉熵损失binary_crossentropy

model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])

model.summary()

运行结果

7.对模型进行10轮迭代训练

checkpoint_save_path = "./model/model_train.h5"

print('------------------------load the model----------------------------')


cp_callback = tf.keras.callbacks.ModelCheckpoint(
    filepath=checkpoint_save_path,
    save_weights_only=False,
    save_best_only=True
)

# 对模型进行训练
history = model.fit(
    train_generator,
    epochs=10,
    batch_size=128,
    validation_data=val_generator,
    validation_freq=1,
    callbacks=[cp_callback],
    verbose=1
)

运行结果

会挑选acc结果最好的一次对训练模型进行保存

7.使用验证集预测并计算f1值

使用训练好的model来对验证集进行训练，并计算f1的值

# 加载保存的模型
loaded_model = tf.keras.models.load_model('./model/model_train.h5')

# 生成验证集预测结果
pred = loaded_model.predict(val_generator,steps = len(val_generator))
predicted_classes = np.array([int(prediction[0] > 0.5) for prediction in pred])


true_labels = val_generator.classes
# 计算f1-score
f1 = f1_score(true_labels, predicted_classes)
print("验证集f1-score为：{}".format(f1))

运行结果 

可以得到f1值为0.93左右 ,229秒完成预测

8.使用oneAPI加速

1.1 使用oneAPI组件对预测进行加速

在代码中，通过设置环境变量TF_ENABLE_ONEAPI = '1'，将TensorFlow配置为使用oneAPI加速。然后，使用tf.device('/CPU:0')将推理操作指定在CPU上进行，以实现加速推理。

import tensorflow as tf
import os
 
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'  # 防止显示不必要的警告信息
 
# 设置TensorFlow为使用oneAPI加速
os.environ['TF_ENABLE_ONEAPI'] = '1'
 
# 加载已训练好的模型
model = tf.keras.models.load_model('./model/model_train.h5')
 
# 设置批量推理
batch_size = 128
 
# 使用oneAPI加速推理
with tf.device('/CPU:0'):
    predictions = model.predict(val_generator, batch_size=batch_size)
# 将预测结果转换为类别标签
# 保存模型
model.save('./model/model_oneAPI.h5')
 
predicted_classes = np.array([int(prediction > 0.5) for prediction in predictions])
 
# 计算并输出 F1 分数
true_labels = val_generator.classes
f1 = f1_score(true_labels, predicted_classes)
print("F1 score:", f1)

运行结果 

169秒完成预测，f1值为0.93左右

1.2 使用oneAPI组件加速后的模型对测试集进行预测并计算f1值

from sklearn.metrics import f1_score
import numpy as np
import tensorflow as tf
# 加载保存的模型并进行预测
loaded_model = tf.keras.models.load_model('./model/oneAPI_model.h5')
 
predictions = loaded_model.predict(test_generator, steps=len(test_generator))
 
# 将预测结果转换为类别标签
predicted_classes = np.array([int(prediction > 0.5) for prediction in predictions])
 
# 计算并输出 F1 分数
true_labels = test_generator.classes
f1 = f1_score(true_labels, predicted_classes)
print("F1 score:", f1)

运行结果

27秒得出预测结果，f1值提升至0.96，加速效果显著

四、总结

        该代码主要实现了一个基于VGG16模型的猫狗分类器。首先通过构造训练集和测试集，然后使用ImageDataGenerator进行数据增强，生成训练集数据生成器、验证集数据生成器和测试集数据生成器。然后加载预训练的VGG16模型，冻结其权重，添加全连接层，编译模型并进行训练。通过回调函数ModelCheckpoint保存每个epoch的最佳模型。接着对验证集进行预测，计算F1-score指标。最后使用oneAPI加速推理，对测试集进行预测，并计算F1-score指标。