def make_prediction(self):
K.reset_uids()
model = ""
weights = ""
classes = {
'TRAIN': ['GRADE 0', 'GRADE 1', 'GRADE 2', 'GRADE 3', 'GRADE 4'],
'VALIDATION': ['GRADE 0', 'GRADE 1', 'GRADE 2', 'GRADE 3', 'GRADE 4'],
'TEST': ['GRADE 0', 'GRADE 1', 'GRADE 2', 'GRADE 3', 'GRADE 4'],
}
with CustomObjectScope({'GlorotUniform': glorot_uniform()}):
with open(model, 'r') as f:
model = model_from_json(f.read())
model.load_weights(weights)
xray_image = image.load_img(self.img, target_size=(224, 224))
x = image.img_to_array(xray_image)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
model.compile(loss="categorical_crossentropy", metrics=[
"accuracy"], optimizer="adam")
result = model.predict(x)
pred_name = classes['TRAIN'][np.argmax(result)]
messages.success(result, f"The osteoarthritis is predicted to be {pred_name}".format(pred_name))
return pred_name
def __init__(self, maxlen=85, step=1, batch_size=128):
"""
:param maxlen:
:param step:
:param batch_size:
"""
# os.chdir('./')
# learning hyper-parameters
self.maxlen = maxlen
self.step = step
self.batch_size = batch_size
self.text_all = ''
self.text_training = ''
self.text_validation = ''
self.text_test = ''
self.chars = None
self.char_indices = None
self.indices_char = None
# self.model = None
K.reset_uids()
K.clear_session()
self.load_dataset()
def loadRNN(model_file_name, weight_file_name):
K.reset_uids()
with open(model_file_name + '.json', 'r') as f:
model = model_from_json(f.read())
model.load_weights(weight_file_name + '.h5')
print("Red Neuronal Cargada desde Archivo")
return model
def running(options):
fold = 1
dt = Dataset(options.dataset)
# load data
train_datas, train_labels, val_datas, val_labels, test_datas, test_labels \
= dt.load_data(nevents=options.num_events, nsamples=options.num_samples, fold=fold)
sequential_test_datas = dt.sequentialize_data(test_datas,
timestep=options.time_step)
random.shuffle(sequential_test_datas)
# build model and load weights
att_s_beta_vae = AttSBetaVAE(options)
K.reset_uids()
sbvae = att_s_beta_vae.build_model(options)
sbvae.load_weights(options.result_path + sbvae.name + '/fold_' +
str(fold) + '_last_weight.h5')
# get the bottleneck features
h_out = np.empty((1, 15))
num_to_plot = 300
for i in range(options.num_events):
h_fnc = K.Function([sbvae.input], [sbvae.layers[15 + i].output])
h = h_fnc([sequential_test_datas[:num_to_plot]])[0]
h_out = np.concatenate([h_out, h])
# visualization
dt.visualization(datas=h_out[1:], name='Att_s_beta_VAE')
def objective(**X):
print('New configuration: {}'.format(X))
model = build_custom_model(hidden=X["hidden_layers"],
nodes=X["initial_nodes"],
lrate=X["learning_rate"],
regulator=X["regulator"],
pattern=X["node_pattern"],
activation=X["activation_function"])
model.save(modelName)
model.summary()
batchSize = str(2**X["batch_power"])
commandString = "python TMVAClassification_Optimization.py -o {} -b {} -e {} -w {} -y {} -d {}".format(
outf_key, batchSize, epochs, where, year, dataset)
os.system(commandString)
temp_name = dataset + "/temp_file.txt"
ROC = float(open(temp_name, "r").read())
# Reset the session
del model
backend.clear_session()
backend.reset_uids()
# Record the optimization iteration
logFile.write('{:7}, {:7}, {:7}, {:7}, {:9}, {:14}, {:10}, {:7}\n'.format(
str(X["hidden_layers"]), str(X["initial_nodes"]),
str(np.around(X["learning_rate"], 5)), str(batchSize),
str(X["node_pattern"]), str(X["regulator"]),
str(X["activation_function"]), str(np.around(ROC, 5))))
opt_metric = (1.0 - ROC)
print("Optimization metric value obtained = {:.5f}".format(opt_metric))
os.system("rm dataset/temp_file.txt")
return opt_metric # since the optimizer tries to minimize this function and we want a larger ROC value
def predict(self):
K.reset_uids()
classes = ['Normal', 'Neumonia']
modelo = 'neumonia/model/model_neumonia_v41.json'
pesos = 'neumonia/model/weights_neumonia_v41.h5'
with CustomObjectScope({'GlorotUniform': glorot_uniform()}):
with open(modelo, 'r') as f:
model = model_from_json(f.read())
model.load_weights(pesos)
img = image.load_img(self.img, target_size=(150, 150))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
resultado = preds[0] #solo una dimension
porcentaje = np.round(resultado * 100, 2)
porcentaje = list(porcentaje)
respuesta = np.argmax(resultado) # el valor mas alto de resultado
for i in range(len(classes)):
res = classes[i]
if i == respuesta:
return 'Resultado: {:.4}% {}'.format(round(max(porcentaje), 2),
res)
def cargar_rnn(nombreArchivoModelo, nombreArchivoPesos):
k.reset_uids()
# Cargar la Arquitectura desde el archivo JSON
with open(nombreArchivoModelo + '.json', 'r') as f:
model = model_from_json(f.read())
# Cargar Pesos (weights) en el nuevo modelo
model.load_weights(nombreArchivoPesos + '.h5')
return model
def cargarRNN(nombreArchivoModelo, nombreArchivoPesos):
K.reset_uids()
# Cargar la Arquitectura desde el archivo JSON
with open(nombreArchivoModelo + '.json', 'r') as f:
model = model_from_json(f.read())
# Cargar Pesos (weights) en el nuevo modelo
model.load_weights(nombreArchivoPesos + '.h5')
print("Red Neuronal Cargada desde Archivo")
return model
def __init__(self, image_size, B, n_classes, is_learning_phase=False):
K.set_learning_phase(int(is_learning_phase))
K.reset_uids()
self.image_size = image_size
self.n_cells = self.image_size // 32
self.B = B
self.n_classes = n_classes
self.m = self.buildModel()
def cargar_modelo(url_modelo, url_pesos):
k.reset_uids()
with open(url_modelo, 'r') as f:
print('INTENTA LEER <<___ ' * 5)
model = model_from_json(f.read())
print('FINALIZA EL LEER <----' * 10)
# Cargar Pesos (weights) en el nuevo modelo.json
model.load_weights(url_pesos)
print("Red Neuronal Cargada desde Archivo")
return model
def running(options):
dt = Dataset(options.dataset)
folds = options.nfolds
# 1.First construct polyphonic datasets by mixing single event sound, and extract MFCCs features.
if options.mix_data:
dt.mix_data(nevents=options.num_events, nsamples=options.num_samples)
f1_list, er_list, fold_list = [], [], []
att_s_beta_vae = AttSBetaVAE(options)
for k in range(1, folds + 1):
# 2.Load data.
train_datas, train_labels, test_datas, test_labels \
= dt.load_data(nevents=options.num_events, nsamples=options.num_samples, fold=k)
sequential_train_datas = dt.sequentialize_data(
train_datas, timestep=options.time_step)
sequential_test_datas = dt.sequentialize_data(
test_datas, timestep=options.time_step)
# 3.Create attention-based supervised beta-VAE model and train it.
K.reset_uids()
model = att_s_beta_vae.build_model(options)
att_s_beta_vae.train_model(model,
x_train=sequential_train_datas,
y_train=train_labels,
fold=k)
# 4.Evaluate the performance on F1 and ER
# Param: supervised is set to 'False' default. 'True' for supervised beta-VAE and 'False' for others.
# This function evaluate the segment-based F1 score and ER.
f1_score, error_rate = att_s_beta_vae.metric_model(
model,
sequential_test_datas,
test_labels,
supervised=True,
new_weight_path='fold_' + str(k) + '_last_weight.h5')
print(
'Fold {fold}, nevents {nevents}, nsamples {nsamples} ==> error_rate: {error_rate}, f1_score: {f1_score}'
.format(fold=k,
nevents=options.num_events,
nsamples=options.num_samples,
error_rate=error_rate,
f1_score=f1_score))
f1_list.append(f1_score)
er_list.append(error_rate)
fold_list.append(k)
del model
f1_list.append(np.mean(f1_list))
er_list.append(np.mean(er_list))
fold_list.append('AVER')
result_df = pd.DataFrame({'F1': f1_list, 'ER': er_list}, index=fold_list)
result_df.to_csv(options.result_path + options.name + '_' +
str(options.num_events) + '/K_Folds_results.csv')
return result_df
def cargar_rnn(nombreArchivoModelo, nombreArchivoPesos):
print('INICIA PROCES CARGA <---------------------------------------------------')
k.reset_uids()
# Cargar la Arquitectura desde el archivo JSON
with open(nombreArchivoModelo + '.json', 'r') as f:
print('INTENTA LEER <<___ '*5)
model = model_from_json(f.read())
print('FINALIZA EL LEER <----'*10)
# Cargar Pesos (weights) en el nuevo modelo
model.load_weights(nombreArchivoPesos + '.h5')
print("Red Neuronal Cargada desde Archivo")
return model
def train(self, data, verbose=True):
""" Train all models and return the best one.
Models are evaluated and ranked according to their ROC-AUC on a validation data set.
Parameters
----------
data: pysster.Data
A Data object providing training and validation data sets.
verbose: bool
If True, progress information (train/val loss) will be printed throughout the training.
Returns
-------
results: tuple(pysster.Model, str)
The best performing model and an overview table of all models are returned.
"""
best_model_path = "{}/{}".format(
gettempdir(),
''.join(random.choice(string.ascii_uppercase) for _ in range(20)))
aucs = []
max_auroc = -1
for i, candidate in enumerate(self.candidates):
model = Model(candidate, data)
model.train(data, verbose)
predictions = model.predict(data, "val")
labels = data.get_labels("val")
report = utils.performance_report(labels, predictions)
roc_auc = np.sum(report[:, 0:-1] * report[:, -1, np.newaxis],
axis=0)
roc_auc = (roc_auc / np.sum(report[:, -1]))[3]
aucs.append(roc_auc)
if aucs[-1] > max_auroc:
max_auroc = aucs[-1]
utils.save_model(model, best_model_path)
K.clear_session()
K.reset_uids()
if not verbose: continue
print("\n=== Summary ===")
print("Model {}/{} = {:.5f} weighted avg roc-auc".format(
i + 1, len(self.candidates), aucs[i]))
for param in candidate:
if not param in ["input_shape"]:
print(" - {}: {}".format(param, candidate[param]))
# load the best model (and remove it from disc)
model = utils.load_model(best_model_path)
remove(best_model_path)
remove("{}.h5".format(best_model_path))
# save a formatted summary of all trained models
table = self._grid_search_table(aucs)
return model, table
def predict(self):
K.reset_uids()
ixtoword = load(open("pickle_files/ixtoword.pkl", "rb"))
wordtoix = load(open("pickle_files/wordtoix.pkl", "rb"))
inc_model = InceptionV3(weights='imagenet')
model_new = Model(inc_model.input, inc_model.layers[-2].output)
# model = loadModel("final_model")
model_file_name = "final_model"
weights_file_name = None
if weights_file_name is None:
weights_file_name = model_file_name
# load json and create model
json_file = open('model_weights/{}.json'.format(model_file_name), 'r')
loaded_model_json = json_file.read()
json_file.close()
model = model_from_json(loaded_model_json)
# load weights into new model
model.load_weights("model_weights/{}.h5".format(weights_file_name))
model.load_weights('./model_weights/{}'.format("model_7.h5"))
# Preprocess
img = image.load_img(self.media, target_size=(299, 299))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
# Imagenet Feature Vector
fea_vec = model_new.predict(x)
fea_vec = np.reshape(fea_vec, (1,2048))
# Getting Caption
in_text = 'startseq'
max_length = 34
for i in range(max_length):
sequence = [wordtoix[w] for w in in_text.split() if w in wordtoix]
sequence = pad_sequences([sequence], maxlen=max_length)
yhat = model.predict([fea_vec,sequence], verbose=0)
yhat = np.argmax(yhat)
word = ixtoword[yhat]
in_text += ' ' + word
if word == 'endseq':
break
final = in_text.split()
final = final[1:-1]
final = ' '.join(final)
return final
def objectDetect():
K.reset_uids()
tb._SYMBOLIC_SCOPE.value = True
print("called")
dir = os.path.join(settings.MEDIA_ROOT, "hello.jpeg")
img = load_img(dir, target_size=(197, 197))
x = img_to_array(img)
x = x.reshape(1, 197, 197, 3).astype('float')
ans = model.predict(x)
print(ans)
f = 0
for i in range(3):
if ans[0][i] >= 0.8:
f = 1
return i + 1
if f == 0:
return -1
def _modify_graph(self, name):
g = tf.get_default_graph()
with g.gradient_override_map({'Relu': name}):
# get layers that have an activation
layer_dict = [
layer for layer in self.model.layers[1:]
if hasattr(layer, 'activation')
]
# replace relu activation
for layer in layer_dict:
if layer.activation == keras.activations.relu:
layer.activation = tf.nn.relu
# re-instanciate a new model
K.reset_uids()
new_model = self.model_func(weights='imagenet')
return new_model
def reset_layer_names(args):
'''In case of transfer learning, it's important that the names of the weights match
between the different networks (e.g. 2X and 4X). This function loads the lower-lever
SR network from a reset keras session (thus forcing names to start from naming index 0),
loads the weights onto that network, and saves the weights again with proper names'''
# Find lower-upscaling model results
BASE = os.path.join(args.weight_path,
args.modelname + '_' + str(args.scaleFrom) + 'X.h5')
assert os.path.isfile(BASE), 'Could not find ' + BASE
# Load previous model with weights, and re-save weights so that name ordering will match new model
prev_model = ESPCN(upscaling_factor=args.scaleFrom, channels=args.channels)
prev_model.load_weights(BASE)
prev_model.save_weights(args.weight_path + args.modelname)
#del prev_model
K.reset_uids()
gc.collect()
return BASE
def reset_layer_names(args):
'''In case of transfer learning, it's important that the names of the weights match
between the different networks (e.g. 2X and 4X). This function loads the lower-lever
SR network from a reset keras session (thus forcing names to start from naming index 0),
loads the weights onto that network, and saves the weights again with proper names'''
# Find lower-upscaling model results
BASE_G = os.path.join(args.weight_path, 'SRGAN_'+args.dataname+'_generator_'+str(args.scaleFrom)+'X.h5')
BASE_D = os.path.join(args.weight_path, 'SRGAN_'+args.dataname+'_discriminator_'+str(args.scaleFrom)+'X.h5')
assert os.path.isfile(BASE_G), 'Could not find '+BASE_G
assert os.path.isfile(BASE_D), 'Could not find '+BASE_D
# Load previous model with weights, and re-save weights so that name ordering will match new model
prev_gan = SRGAN(upscaling_factor=args.scaleFrom)
prev_gan.load_weights(BASE_G, BASE_D)
prev_gan.save_weights(args.weight_path+'SRGAN_'+args.dataname)
del prev_gan
K.reset_uids()
gc.collect()
return BASE_G, BASE_D
def predict(self):
K.reset_uids()
model = 'face_classifier/model/short_arc_model_arc.json'
weights = 'face_classifier/model/short_arc_model_weights.h5'
with CustomObjectScope({'GlorotUniform': glorot_uniform()}):
with open(model, 'r') as f:
model = model_from_json(f.read())
model.load_weights(weights)
img = image.load_img(self.img, target_size=(64, 64), grayscale=True)
x = image.img_to_array(img)
x = x/255.0
x = np.expand_dims(x, axis=0)
y_prob = model.predict(x)
person_profile_id = y_prob.argmax(axis=-1)
with open('face_classifier/model/map_person.json', 'r') as f:
mapper = json.load(f)
return mapper['people'][str(person_profile_id[0])]
def classify(self):
K.reset_uids() # reset graph identifiers
model = VGG16(weights='imagenet',
include_top=True) # use keras pretrained model VGG16
img = image.load_img(
'/home/grh/Desktop/webProgramming/django-apps/imageInterpretation/media/cat.jpeg',
target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
result_features = model.predict(x)
result0 = imagenet_utils.decode_predictions(result_features)
result = ""
#result['content']=""
for (i, (predID, pred, probability)) in enumerate(result0[0]):
result = result + "\n" + "{}.- {}: {:.2f}%".format(
i + 1, pred, probability * 100)
#result['content'] = result['content'] + "\n" + "{}.- {}: {:.2f}%".format(i+1, pred, probability*100)
return result
def predict(self):
K.reset_uids()
model = 'cnn/model/model_mobilenet.json'
weights = 'cnn/model/weights_mobilenet.h5'
with CustomObjectScope({'GlorotUniform': glorot_uniform()}):
with open(model, 'r') as f:
model = model_from_json(f.read())
model.load_weights(weights)
img = image.load_img(self.img, target_size=(224,224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
result = model.predict(x)
result_decode = imagenet_utils.decode_predictions(result)
for (i, (predId, pred, prob)) in enumerate(result_decode[0]):
return "{}.- {}: {:.2f}%".format(i + 1, pred, prob * 100)
def predict(self):
K.reset_uids()
model = 'cnn_counting_leaf/model/model.json'
weights = 'cnn_counting_leaf/model/weights_model.h5'
with CustomObjectScope({'GlorotUniform': glorot_uniform()}):
with open(model, 'r') as f:
model = model_from_json(f.read())
model.load_weights(weights)
img = image.load_img(self.img, target_size=(299, 299))
img = image.img_to_array(img)
img /= 255
img = np.expand_dims(img, axis=0)
result = model.predict(img)
return "{}".format(int(result.flatten()[0]))
def running(options):
dt = Dataset(options.dataset)
# 1.First construct polyphonic datasets by mixing single event sound, and extract MFCCs features.
if options.mix_data:
dt.mix_data(nevents=options.num_events,
nsamples=options.num_samples,
isUnbalanced=True)
f1_list, er_list, fold_list = [], [], []
att_s_beta_vae = AttSBetaVAE(options)
# 2.Load data.
train_datas, train_labels, test_datas, test_labels \
= dt.load_data(nevents=options.num_events, nsamples=options.num_samples, fold=1, isUnbalanced=True)
sequential_train_datas = dt.sequentialize_data(train_datas,
timestep=options.time_step)
sequential_test_datas = dt.sequentialize_data(test_datas,
timestep=options.time_step)
# 3.Create attention-based supervised beta-VAE model and train it with unbalanced datas.
K.reset_uids()
model = att_s_beta_vae.build_model(options)
att_s_beta_vae.train_model(model,
x_train=sequential_train_datas,
y_train=train_labels,
fold=1,
new_weights=options.result_path + model.name +
'/fold_1_last_weight_DA.h5')
# 4.Evaluate the performance on F1 and ER
# Param: supervised is set to 'False' default. 'True' for supervised beta-VAE and 'False' for others.
# This function evaluate the segment-based F1 score and ER.
f1_score, error_rate = att_s_beta_vae.metric_model(
model,
sequential_test_datas,
test_labels,
supervised=True,
new_weight_path='fold_1_last_weight_DA.h5')
print(
'Before data augmentation '
'>>> nevents {nevents}, nsamples {nsamples} ==> error_rate: {error_rate}, f1_score: {f1_score}'
.format(nevents=options.num_events,
nsamples=options.num_samples,
error_rate=error_rate,
f1_score=f1_score))
# 5.define the function to get z^*, here the inefficient category is the first events.
z_star_fnc = K.Function([model.input], [model.layers[14].output])
# here x are the input raw features extracted the first category
x = []
index = []
y_addition = []
for idx in range(len(train_labels)):
y = train_labels[idx]
if (y == [1, 0, 0, 0, 0]).all():
index.append(idx)
x.append(sequential_train_datas[idx])
y_addition.append(y)
z_star = z_star_fnc([x])[0]
# 6.define the decoder
decoder_fnc = K.Function([model.layers[6].output], [model.output[0]])
generated_data = decoder_fnc([z_star])[0]
# 7.augment the training set with generated data
sequential_train_datas = np.concatenate(
[sequential_train_datas, generated_data])
train_labels = np.concatenate([train_labels, y_addition])
# 8.retrain the model
K.reset_uids()
model = att_s_beta_vae.build_model(options)
att_s_beta_vae.train_model(model,
x_train=sequential_train_datas,
y_train=train_labels,
fold=1,
new_weights=options.result_path + model.name +
'/fold_1_last_weight_DA_after.h5')
f1_score_DA, error_rate_DA = att_s_beta_vae.metric_model(
model,
sequential_test_datas,
test_labels,
supervised=True,
new_weight_path='fold_1_last_weight_DA_after.h5')
print(
'nevents {nevents}, nsamples {nsamples} ==> error_rate: {error_rate}, f1_score: {f1_score}'
.format(nevents=options.num_events,
nsamples=options.num_samples,
error_rate=error_rate_DA,
f1_score=f1_score_DA))
fold_list.append('AVER')
result_df = pd.DataFrame({'F1': f1_list, 'ER': er_list}, index=fold_list)
result_df.to_csv(options.result_path + options.name + '_' +
str(options.num_events) + '/K_Folds_results.csv')
return result_df
def train(self, data, pr_auc=False, verbose=True):
""" Train all models and return the best one.
Models are evaluated and ranked according to their ROC-AUC or PR-AUC (precision-recall)
on a validation data set.
Parameters
----------
data: pysster.Data
A Data object providing training and validation data sets.
pr_auc: bool
If True, the area under the precision-recall curve will be maximized instead of the area under the ROC curve
verbose: bool
If True, progress information (train/val loss) will be printed throughout the training.
Returns
-------
results: tuple(pysster.Model, str)
The best performing model and an overview table of all models are returned.
"""
best_model_path = "{}/{}".format(
gettempdir(),
''.join(random.choice(string.ascii_uppercase) for _ in range(20)))
if True == pr_auc:
metric_idx = 4
metric_name = "pre-auc"
else:
metric_idx = 3
metric_name = "roc-auc"
metric = []
max_metric = -1
for i, candidate in enumerate(self.candidates):
model = Model(candidate, data)
model.train(data, verbose)
predictions = model.predict(data, "val")
labels = data.get_labels("val")
report = utils.performance_report(labels, predictions)
metric_val = np.sum(report[:, 0:-1] * report[:, -1, np.newaxis],
axis=0)
metric_val = (metric_val / np.sum(report[:, -1]))[metric_idx]
metric.append(metric_val)
if metric[-1] > max_metric:
max_metric = metric[-1]
utils.save_model(model, best_model_path)
K.clear_session()
K.reset_uids()
if not verbose: continue
print("\n=== Summary ===")
print("Model {}/{} = {:.5f} weighted avg {}".format(
i + 1, len(self.candidates), metric[i], metric_name))
for param in candidate:
if not param in ["input_shape"]:
print(" - {}: {}".format(param, candidate[param]))
# load the best model (and remove it from disc)
model = utils.load_model(best_model_path)
remove(best_model_path)
remove("{}.h5".format(best_model_path))
# save a formatted summary of all trained models
table = self._grid_search_table(metric, metric_name)
return model, table
def wrapped(*args, **kwargs):
K.clear_session()
K.reset_uids()
return func(*args, **kwargs)
model.add(Conv1D(filters=40,kernel_size=6,padding='same', activation='relu'))
model.add(Conv1D(filters=50,kernel_size=5,padding='same', activation='relu'))
model.add(Conv1D(filters=50,kernel_size=5,padding='same', activation='relu'))
model.add(Dense(1024,activation='relu'))
#model.add(GlobalAveragePooling1D())
model.add(Dense(1))
# try using different optimizers and different optimizer configs
# Compile Model
print('Compile model...')
model.compile(loss='mean_squared_error',
optimizer='rmsprop',
metrics=['mean_absolute_error', disag_error])
# Train model ...
early_stopping = EarlyStopping(monitor='val_loss', patience=2)
print('Train...')
model.fit(input_train, output_train,
batch_size=batch_size,
epochs=epochs,
validation_split=0.2,
callbacks=[early_stopping])
model.save('convmodel/convz_b{}.h5'.format(i))
gc.collect()
K.reset_uids()
K.clear_session()
import numpy as np
import streamlit as st
from keras import backend as keras_backend
from keras.applications.mobilenet import preprocess_input
from keras.applications import imagenet_utils
from keras.preprocessing import image
from keras.utils import CustomObjectScope
from tensorflow.keras.models import model_from_json
from tensorflow.keras.initializers import glorot_uniform
keras_backend.reset_uids()
model = "app/model/model_json.json"
weights = "app/model/mobilenet_imagenet.h5"
with CustomObjectScope({"GlorotUniform": glorot_uniform()}):
with open(model, "r") as file:
model = model_from_json(file.read())
model.load_weights(weights)
@st.cache
def predict(img):
img = image.load_img(img, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
result = model.predict(x)
result_decode = imagenet_utils.decode_predictions(result)
