问我们的训练/验证损失曲线很好，但测试性能受到影响

EN

from tensorflow import keras
from keras.applications.mobilenet_v2 import MobileNetV2
from keras.applications.mobilenet_v2 import preprocess_input
from keras.layers import Dense, Flatten
from keras.models import Sequential
from keras.losses import BinaryCrossentropy
from tensorflow.keras.optimizers import Adam
from keras.preprocessing.image import ImageDataGenerator
from datetime import datetime, date
from keras.callbacks import ModelCheckpoint
from sklearn.metrics import confusion_matrix, classification_report
import numpy as np

#Loading a pre-trained model
image_size = 224

base_model = MobileNetV2(input_shape=(image_size,image_size,3), weights='imagenet', include_top=False)

for layer in base_model.layers:
    layer.trainable = False

model = Sequential()
model.add(base_model)
model.add(Flatten())
model.add(Dense(1000, activation='relu'))
model.add(Dense(2, activation="sigmoid"))

loss_func = BinaryCrossentropy()
opt = Adam(learning_rate=0.001)

model.compile(loss=loss_func,
              optimizer=opt,  
              metrics=['accuracy'])

#Training
test_path = '...' 
val_path = '...'

datagen = ImageDataGenerator(rescale = 1./255,horizontal_flip = True, shear_range = 0.2, zoom_range=0.2)

batch_size=32
validation_size=8

train_set = datagen.flow_from_directory(test_path, 
                                        target_size = (image_size, image_size),
                                        batch_size=batch_size,
                                        class_mode = 'categorical')

validation_set = datagen.flow_from_directory(val_path, 
                                             target_size = (image_size, image_size),
                                             batch_size=validation_size,
                                             class_mode = 'categorical')

#Fitting the data to the model
model_name = 'MobileNetV2'
date_today= date.today().strftime('%m_%d_%Y')

checkpoint = ModelCheckpoint(filepath=f'Models/{model_name}_{date_today}.h5',
                             monitor='val_loss',
                             mode='min',
                             verbose=1, 
                             save_best_only=True)

model_history = model.fit(train_set, 
                          validation_data=validation_set,
                          epochs=100,
                          steps_per_epoch=len(train_set)//batch_size,
                          validation_steps=len(validation_set)//validation_size,
                          callbacks=[checkpoint],
                          verbose=1)


#Testing the model on the test set
test_path = '...'

test_datagen = ImageDataGenerator()

test_set = test_datagen.flow_from_directory(test_path,
                                            target_size = (image_size, image_size),
                                            class_mode = 'categorical')

predictions = model.predict(test_set, verbose=1)

y_pred = np.argmax(predictions, axis=1)
class_labels = list(test_set.class_indices.keys())  

print('Classification Report')
clsf = classification_report(test_set.classes, y_pred, target_names=class_labels)
print(clsf)
print('\n')
print('Confusion Matrix')
cfm = confusion_matrix(test_set.classes, y_pred)
print(cfm)