python - 具有 98% 测试准确率的 ConvNet，总是预测错误

Question

我目前正在构建一个卷积神经网络来区分清晰的 ECG 图像和有噪声的 ECG 图像。

有噪音:

没有噪音:

我的问题

所以我确实在 tensorflow 之上使用 keras 构建了一个 convnet 并对其进行了多次训练，但一直以来，它都具有 99% 的训练准确度、99% 的验证准确度和 98% 的测试准确度。但是当我预测图像时，它总是给我 [0]。

大多数时候，我的模型在第 3 轮或第 4 轮提前停止，训练和验证的准确率为 99%。它几乎总是在第一个纪元或第二个纪元中给出 98% 或 99% 的准确率。

我的模型

from keras.models import Sequential
from keras.datasets import mnist
from keras.layers import Conv2D, MaxPooling2D
from keras.layers import Activation,Dropout,Flatten,Dense
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import TensorBoard
from keras.layers import ZeroPadding2D
from keras.optimizers import Adam
from keras.callbacks import EarlyStopping

tensorboard = TensorBoard(log_dir="./logs",histogram_freq=0,write_graph=True,write_images=True)
earlystop = EarlyStopping(monitor='val_loss',patience=2,verbose=1)

# Variables
batchSize = 15
num_of_samples = 15000
num_of_testing_samples = 3750
num_of_val_samples = 2000

training_imGenProp = ImageDataGenerator(rescale = 1./255,
                                width_shift_range=0.02,
                                height_shift_range=0.02,
                                horizontal_flip=False,
                                fill_mode='nearest'
                                )   

testing_imGenProp = ImageDataGenerator(
                                rotation_range=5,
                                horizontal_flip=False,
                                fill_mode='nearest'
                                )

val_imGenProp = ImageDataGenerator(rescale = 1./255,
                                rotation_range=5,
                                zoom_range=0.2,
                                horizontal_flip=False,
                                fill_mode='nearest'
                                )                                    



# Create the model                                    
classifier = Sequential()
classifier.add(ZeroPadding2D(padding=(374,0),input_shape=(74,448,3)))
classifier.add(Conv2D(32, (3, 3), activation = 'relu'))

classifier.add(MaxPooling2D(pool_size = (2, 2)))
classifier.add(Conv2D(32, (3, 3), activation = 'relu'))
classifier.add(MaxPooling2D(pool_size = (2, 2)))

classifier.add(Flatten())
classifier.add(Dense(units = 128, activation = 'relu'))
classifier.add(Dropout(0.8))
classifier.add(Dense(units = 1, activation = 'sigmoid'))
classifier.summary()

adam = Adam(lr=0.00005)
classifier.compile(loss='binary_crossentropy',optimizer=adam,metrics=['accuracy'])

training_imGen = training_imGenProp.flow_from_directory(
                                'Directory\Training',
                                target_size=(74,448),
                                batch_size=batchSize,
                                class_mode='binary',

                                )

testing_imGen = testing_imGenProp.flow_from_directory(
                                'Directory\Testing',
                                target_size=(74,448),
                                batch_size=batchSize,
                                class_mode='binary',

                                )   

val_imGen = testing_imGenProp.flow_from_directory(
                                'Directory\Validation', 
                                target_size=(74,448),
                                batch_size=batchSize,
                                class_mode='binary',

                                )                                   

classifier.fit_generator(
                            training_imGen,
                            callbacks = [tensorboard,earlystop], 
                            steps_per_epoch=num_of_samples // batchSize,
                            epochs=30, 
                            validation_data = val_imGen,
                            validation_steps = num_of_val_samples // batchSize
                         ) 

score, acc = classifier.evaluate_generator(
                        testing_imGen,
                        num_of_testing_samples // batchSize,
                        verbose = 0
                    )     
print('Test score:', score)
print('Test accuracy:', acc)
classifier.save('Directory\Config_10_Model.h5')

注意事项

我使用 0.0005 学习率来阻止该模型在第 2 或第 3 个时期提前停止。此外，我将用于训练、测试和验证的图像分开放在三个文件夹下，分别有 1020,375,200 张图像用于训练、测试和验证(这意味着单独的训练文件夹有 2040 张图像，因为我有两个类(class)。每个类(class)都有相同数量的图像).因此在任何情况下都不会重复使用任何图像。

此外，在我在 ImageDataGenerator 中将图像按 1./255 重新缩放之前，我的模型在训练、验证和测试中的准确率为 50% 和 54%。但在使用 rescaling 后，这种提前停止的情况频繁发生，准确率几乎始终为 99%。

我没有故意对测试图像使用重新缩放。但仍然获得 98% 的准确率，但在预测时却拼命失败。因为我在训练文件夹下有 with noise 和 without noise 文件夹，所以我的输出类应该有噪声或没有噪声。由于 with Noise 按字母顺序排在第一位，我相信 [0] 类说 With Noise 而 [1] 应该是 Without噪声。但是如果我输入没有噪声的图像到模型中，它仍然给我 [0]。

下面是我用来预测训练模型的代码。

from keras.models import load_model
import numpy as np
from keras.preprocessing import image

model = load_model('Directory\Config_10_Model.h5')

test_image = image.load_img('Path_to_Without_Noise_Image\image3452.png', target_size = (74, 448))
test_image = image.img_to_array(test_image)
test_image = test_image/255
test_image = np.expand_dims(test_image, axis = 0)
result = model.predict(test_image)
y_classes = result.argmax(axis=-1)
print(y_classes)

我不知道为什么会发生这种情况，尽管我从未使用相同的图像进行测试、验证或训练。有人可以帮我弄这个吗？我尝试了所有方法并使用不同的超参数训练了模型，但每次该模型输出 [0]。

Answer 1

您正在进行二元分类。 result 的形状为 [batch_size,1]。因此，如果您执行 argmax()，您将始终得到 0。

>>> import numpy as np
>>> result = np.random.rand(5,1)
>>> result
array([[ 0.54719484],
       [ 0.31675804],
       [ 0.55151251],
       [ 0.25014937],
       [ 0.00724972]])
>>> result.argmax(axis=-1)
array([0, 0, 0, 0, 0])
>>> (result > 0.5).astype(int)
array([[1],
       [0],
       [1],
       [0],
       [0]])
>>>