Keras Inception V3 predict image not working

Question

Learnt from Jerry Kurata on Pluralsight, I'm trying to recognize birds:

my dataset structure is:

My model training code is:

import glob
import matplotlib.pyplot as plt

from keras import backend as K
import tensorflow as tf
with K.tf.device("/device:GPU:0"):
    config = tf.ConfigProto(intra_op_parallelism_threads=4,
           inter_op_parallelism_threads=4, allow_soft_placement=True,
           device_count = {'CPU' : 1, 'GPU' : 1})
    session = tf.Session(config=config)
    K.set_session(session)

from keras.callbacks import EarlyStopping
from keras.applications.inception_v3 import InceptionV3, preprocess_input
from keras.preprocessing.image import ImageDataGenerator
from keras.optimizers import SGD
from keras.models import Model
from keras.layers import Dense, GlobalAveragePooling2D
# "/device:GPU:0"
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

def get_num_files(path):
    if not os.path.exists(path):
        return 0
    return sum([len(files) for r, d, files in os.walk(path)])

def get_num_subfolders(path):
    if not os.path.exists(path):
        return 0
    return sum([len(d) for r, d, files in os.walk(path)])

def create_img_generator():
    return ImageDataGenerator(
        preprocessing_function=preprocess_input,
        rotation_range=30,
        width_shift_range=0.2,
        height_shift_range=0.2,
        shear_range=0.2,
        zoom_range=0.2,
        horizontal_flip=True
    )

Image_width, Image_height = 299, 299
Training_Epochs = 1
Batch_Size = 32
Number_FC_Neurons = 1024

train_dir = '.../birds/train'
validate_dir = '.../birds/validation'

num_train_samples = get_num_files(train_dir)
num_classes = get_num_subfolders(train_dir)
num_validate_samples = get_num_files(validate_dir)

num_epoch = Training_Epochs
batch_size = Batch_Size

train_image_gen = create_img_generator()
test_image_gen = create_img_generator()

train_generator = train_image_gen.flow_from_directory(
    train_dir,
    target_size=(Image_width, Image_height),
    batch_size = batch_size,
    seed = 42
)

validation_generator = test_image_gen.flow_from_directory(
    validate_dir,
    target_size=(Image_width, Image_height),
    batch_size=batch_size,
    seed=42
)

Inceptionv3_model = InceptionV3(weights='imagenet', include_top=False)
print('Inception v3 model without last FC loaded')

x = Inceptionv3_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(Number_FC_Neurons, activation='relu')(x)
predictions = Dense(num_classes, activation='softmax')(x)

model = Model(inputs=Inceptionv3_model.input, outputs=predictions)
print(model.summary())

print('\nFine tuning existing model')

Layers_To_Freeze = 172
for layer in model.layers[:Layers_To_Freeze]:
    layer.trainable = False
for layer in model.layers[Layers_To_Freeze:]:
    layer.trainable = True

model.compile(optimizer=SGD(lr=0.0001, momentum=0.9), loss='binary_crossentropy', metrics=['accuracy'])

cbk_early_stopping = EarlyStopping(monitor='val_acc', mode='max')

history_transfer_learning = model.fit_generator(
    train_generator,
    steps_per_epoch = num_train_samples,
    epochs=num_epoch,
    validation_data=validation_generator,
    validation_steps = num_validate_samples,
    class_weight='auto',
    callbacks=[cbk_early_stopping]
)

model.save('incepv3_transfer.h5', overwrite=True, include_optimizer=True)

My detector is

from keras.models import load_model
from keras.optimizers import SGD
from keras.preprocessing import image
from keras.applications.inception_v3 import preprocess_input
import matplotlib.pyplot as plt
import numpy as np
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

class Detector:
    def __init__(self, model_path):
        self.model = load_model(model_path)
        print('input shape')   # output is always (None, None, None, 3), this should be wrong
        print(self.model.layers[0].input_shape)
        # self.model.summary()
        # self.model.compile(loss='binary_crossentropy', optimizer=SGD(lr=0.0001, momentum=0.9), metrics=['accuracy'])

    def preprocess_input(self, x):
        y = np.copy(x)
        y /= 255.
        y -= 0.5
        y *= 2.
        return y

    def load_image(self, img_path, show=False):
        img = image.load_img(img_path, target_size=(299,299))
        img_tensor = image.img_to_array(img)                    # (height, width, channels)
        img_tensor = np.expand_dims(img, axis=0)         # (1, height, width, channels), add a dimension because the model expects this shape: (batch_size, height, width, channels)
        # img_tensor /= 255.                                      # imshow expects values in the range [0, 1]
        img_tensor = preprocess_input(img_tensor)

        if show:
            plt.imshow(img_tensor[0])
            plt.axis('off')
            plt.show()

        return img_tensor

    def detect(self, img_path):
        img = self.load_image(img_path, True)
        classes = self.model.predict(img)
        return classes

from this link

And here is how I use them to predict whether an image has a bird or not:

from keras.models import Model
from detector import Detector
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

model_path = 'incepv3_transfer.h5'
detective = Detector(model_path)

bird_img = 'b1.jpeg'
classes = detective.detect(bird_img)

print(classes)


bird_img = 'dog1.jpg'
classes = detective.detect(bird_img)

print(classes)

the output is always:

[[1.]]