Keras возвращает разные результаты на удаленном сервере

Question

Я обучил модель keras и сохранил ее в файле h5. Когда я обычно предсказываю только с помощью load_weights и генератора предсказания, он возвращает высокий auc и различные прогнозы.

import numpy as np
from keras.preprocessing.image import ImageDataGenerator
from keras.layers.core import Dense, Dropout, Activation, Flatten
from keras.layers.convolutional import Conv2D, SeparableConv2D
from keras.layers.pooling import MaxPooling2D, GlobalAveragePooling2D
from keras import backend as K
from keras.layers import Input
from keras.models import Model
import keras
from keras.layers.normalization import BatchNormalization
from keras.optimizers import Adam
import tensorflow as tf
valid_datagen = ImageDataGenerator(rescale=1./255.)
test_datagen = ImageDataGenerator(rescale=1./255.)

valid_generator = valid_datagen.flow_from_directory(
    directory="./valid/",
    target_size=(50, 50),
    color_mode="rgb",
    batch_size=32,
    class_mode="binary",
    shuffle=True,
    seed=42
)
test_generator = test_datagen.flow_from_directory(
    directory="./test/",
    target_size=(50, 50),
    color_mode="rgb",
    batch_size=1,
    class_mode=None,
    shuffle=False,
    seed=42
)

K.clear_session()
K.set_image_dim_ordering('tf')
reg = keras.regularizers.l1_l2(1e-5, 0.0)
def conv_layer(channels, kernel_size, input):
    output = SeparableConv2D(channels, kernel_size, padding='same',kernel_regularizer=reg)(input)
    output = BatchNormalization()(output)
    output = Activation('relu')(output)
    output = Dropout(0)(output)
    return output

input1 = Input(shape=(50, 50, 3))
output = conv_layer(32, (3,  3), input1)
output = MaxPooling2D(pool_size=(2, 2))(output)
output = conv_layer(64, (3,  3), output)
output = MaxPooling2D(pool_size=(2, 2))(output)
output = conv_layer(128, (5,  5), output)
output = MaxPooling2D(pool_size=(2, 2))(output)
output = conv_layer(256, (5,  5), output)
output = MaxPooling2D(pool_size=(2, 2))(output)
output = conv_layer(512, (7,  7), output)
output = MaxPooling2D(pool_size=(2, 2))(output)
output = conv_layer(1024, (7,  7), output)
output = GlobalAveragePooling2D()(output)
output = Dense(1)(output)
output = Activation('sigmoid')(output)

model = Model(inputs=input1, outputs=output)


def auc(y_true, y_pred):
    auc = tf.metrics.auc(y_true, y_pred)[1]
    K.get_session().run(tf.local_variables_initializer())
    return auc

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


STEP_SIZE_VALID=valid_generator.n/valid_generator.batch_size
STEP_SIZE_TEST=test_generator.n/test_generator.batch_size

model.load_weights('model.h5')
model.evaluate_generator(generator=valid_generator, steps = STEP_SIZE_VALID
)

test_generator.reset()
model._make_predict_function()
pred=model.predict_generator(test_generator,steps = STEP_SIZE_TEST, verbose=1)
np.set_printoptions(threshold=np.nan)
print(pred)
print(test_generator.filenames)
f = open("demofile.txt", "a")
f.write(str(pred))
f.write(str(test_generator.filenames))

Однако, когда я сохраняю этот файл h5 на удаленном сервере и пытаюсь получить прогнозы, все запросы возвращаются как 1.0.

import flask
import pandas as pd
import tensorflow as tf
import keras
from keras.models import load_model
from keras.preprocessing.image import img_to_array
from keras.applications import imagenet_utils
from PIL import Image
import numpy as np
import flask
import io
import sys

# instantiate flask
app = flask.Flask(__name__)
def prepare_image(image, target):
    # if the image mode is not RGB, convert it
    if image.mode != "RGB":
        image = image.convert("RGB")

    # resize the input image and preprocess it
    image = image.resize(target)
    image = img_to_array(image)
    image = np.expand_dims(image, axis=0)
    image = imagenet_utils.preprocess_input(image)

    # return the processed image
    return image
# we need to redefine our metric function in order
# to use it when loading the model
def auc(y_true, y_pred):
   auc = tf.metrics.auc(y_true, y_pred)[1]
   keras.backend.get_session().run(tf.local_variables_initializer())
   return auc

# load the model, and pass in the custom metric function

global graph
graph = tf.get_default_graph()
model = load_model('new.h5', custom_objects={'auc': auc})

# define a predict function as an endpoint
@app.route("/predict", methods=["GET","POST"])
def predict():
    data = {"success": False}
    params = flask.request.files["image"].read()
    if (params == None):
        params = flask.request.args

    # if parameters are found, return a prediction
    if (params != None):
        image = params
        image = Image.open(io.BytesIO(image))

        # preprocess the image and prepare it for classification
        image = prepare_image(image, target=(50, 50))

        # classify the input image and then initialize the list
        # of predictions to return to the client
        print(image)

        with graph.as_default():
            preds = model.predict(image)
            data["prediction"] = str(preds[0][0])
            data["success"] = True

    # return a response in json format
    return flask.jsonify(data)

# start the flask app, allow remote connections
app.debug=True
app.run(host='0.0.0.0')

У вас есть идеи, почему это происходит?