def load_model_from_file(model_path):
json_file = open(model_path, 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
print("Loaded model from disk")
return loaded_model
def restore_model_config(self, compile=True):
"""
restores model config from ``model_path``.
Parameters
----------
compile: bool
if ``True`` will compile model after restoring its config.
Returns
-------
``True`` if the model config has been successfully restored.
``False`` if `model_path` is invalid or the model config couldn't be found in the specified ``model_path``.
"""
if os.path.exists(os.path.join(self.model_path, f"{self.model_name}.json")):
json_file = open(os.path.join(self.model_path, f"{self.model_name}.json"), 'rb')
loaded_model_json = json_file.read()
self.cvae_model = model_from_json(loaded_model_json)
self.encoder_model = self.cvae_model.get_layer("encoder")
self.decoder_model = self.cvae_model.get_layer("decoder")
if compile:
self.compile_models()
print(f"{self.model_name}'s network's config has been successfully restored!")
return True
else:
return False
def up_down_test():
json_file = open(model_path + 'lstm_model.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
model = model_from_json(loaded_model_json)
model.load_weights(model_path + "lstm_model.h5")
print("=======Loaded model ok========")
predicted = model.predict(test_x)
print("===========test==========")
# max_error = [0.2, 0.15, 0.1, 0.08, 0.05, 0.03, 0.02, 0.01]
max_error = [0.08]
for error_rate in max_error:
c = 0
a = 0
print("===========test==========", error_rate)
for i in range(len(predicted)):
if (predicted[i] - test_y[i]) / test_y[i] < error_rate:
c += 1
a += 1
print("=====accuracy=====", str(c / a))
fig = plt.figure()
plt.plot(predicted[0:100], color='r', label='predicted_data')
plt.plot(test_y[0:100], color='b', label='real_data')
plt.legend()
plt.show()
fig.savefig('temp.png')
def __init__(self):
"""Implementation of initialization"""
# load json and create model
self.model = None
if os.path.exists('Models/BiLSTM_Glove_de_identification_model.json'):
json_file = open(
'Models/BiLSTM_Glove_de_identification_model.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
self.model = model_from_json(loaded_model_json)
self.GLOVE_DIR = "Resources/"
if os.path.isdir(self.GLOVE_DIR) == False or os.path.isfile(
self.GLOVE_DIR + "glove.840B.300d.txt") == False:
if os.path.exists(self.GLOVE_DIR) == False:
os.mkdir(self.GLOVE_DIR)
print('Beginning file download with urllib2...')
url = 'http://nlp.stanford.edu/data/glove.840B.300d.zip'
urllib.request.urlretrieve(url,
self.GLOVE_DIR + 'glove.840B.300d.zip')
with ZipFile(self.GLOVE_DIR + 'glove.840B.300d.zip',
'r') as zipObj:
# Extract all the contents of zip file in current directory
zipObj.extractall(self.GLOVE_DIR)
os.remove(self.GLOVE_DIR + "glove.840B.300d.zip")
# load weights into new model
self.model.load_weights(
"Models/BiLSTM_Glove_de_identification_model.h5")
print("Loaded model from disk")
self.model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
self.word_index = pickle.load(open("Models/word_index.pkl", "rb"))
self.MAX_SEQUENCE_LENGTH = 200
self.EMBEDDING_DIM = 300
self.MAX_NB_WORDS = 2200000
def test_process():
modelname_text = open("model.json").read()
json_strings = modelname_text.split('##########')
textlist = json_strings[1].replace("[",
"").replace("]",
"").replace("\'",
"").split()
model = model_from_json(json_strings[0])
model.load_weights("last.hdf5") # best.hdf5 で損失最小のパラメータを使用
x_test, y_test, filenames = load_images(TEST_DIR)
preds = model.predict(x_test, batch_size=1, verbose=0)
collect = 0
for i, pred in enumerate(preds):
result = np.argmax(pred)
if y_test[i][result] == 1:
collect += 1
print(filenames[i])
print(str(pred))
print(">> 「" + CLASSES[result] + "」")
print(f"試験数: {len(y_test)}")
print(f"正解数: {collect}")
print(f"正解率: {collect / len(y_test)}")
return result
def image2vect():
json_file = open(datadir + 'ckplus.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
ckplus = model_from_json(loaded_model_json)
# load weights into new model
ckplus.load_weights(datadir + 'ckplus.h5')
# ckplus.summary()
layer_name = 'flatten_1'
intermediate_layer_model = Model(
input=ckplus.input, output=ckplus.get_layer(layer_name).output)
print(ckplus.input)
x_fname = datadir + 'x_train.npy'
x_train = np.load(x_fname)
videos = []
i = 0
for video in x_train:
print(i)
images = []
for image in video:
resized = (np.moveaxis(image, -1, 0)).reshape((1, 1, 48, 48))
# print(resized.shape)
vector = intermediate_layer_model.predict(resized)
# print(vector.shape)
images.append(vector.reshape(4608))
videos.append(images)
# print(np.copy(videos).shape)
i = i + 1
videos = np.copy(videos)
print(videos.shape)
np.save(datadir + 'x_train_vec', videos)
def load_from_file(name):
json_file = open(name + ".json", 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights(name + ".h5")
print("Loaded model from disk")
def load(self, model_path, type='json'):
if type == 'json':
# save as JSON
self.model = model_from_json(open(model_path + ".json").read())
# model_main.trainable = False
self.model.load_weights(model_path + ".h5")
else:
self.model.load_model(model_path + ".h5")
def load_models():
json = open('MobileNet.json', 'r')
model = json.read()
json.close()
model = model_from_json(model)
model.load_weights('DMNfullmodel.h5')
model_emotions = load_model('distilled_model.h5', compile=False)
return model, model_emotions
def loadModel(name):
json_file = open(name + '.json', '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(name + ".h5")
return model
def load_model():
json_file = open("model.json", 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights("weights.h5")
loaded_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
return loaded_model
def load_model():
json_file = open('model/embedding_v3.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights("model/embedding_v3.h5")
print("Loaded model from disk")
return loaded_model
def load_model_from_file(name):
with open(name + ".json", 'r') as f:
model = model_from_json(f.read())
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.load_weights(name + ".h5")
return model
def test(test_img_path, test_dm_path):
test_x = gen_var_from_paths(test_img_path[:], unit_len=None)
test_y = gen_var_from_paths(test_dm_path[:], stride=8, unit_len=None)
test_x = norm_by_imagenet(test_x)
dataset = 'A'
net = 'CSRNet'
dis_idx = 16 if dataset == 'B' else 0
weights_dir_neo = 'D:/Crowd Web/crowd_web/upload/weights_A_MSE_bestMAE294.332_Sun-Jul-14'
model = model_from_json(open('models/{}.json'.format(net), 'r').read())
model.load_weights(os.path.join(weights_dir_neo, '{}_best.hdf5'.format(net)))
ct_preds = []
ct_gts = []
for i in range(len(test_x[:])):
if i % 100 == 0:
print('{}/{}'.format(i, len(test_x)))
i += 0
test_x_display = np.squeeze(test_x[i])
test_y_display = np.squeeze(test_y[i])
path_test_display = test_img_path[i]
pred = np.squeeze(model.predict(np.expand_dims(test_x_display, axis=0)))
ct_pred = np.sum(pred)
ct_gt = round(np.sum(test_y_display))
ct_preds.append(ct_pred)
ct_gts.append(ct_gt)
plt.plot(ct_preds, 'r>')
plt.plot(ct_gts, 'b+')
plt.legend(['ct_preds', 'ct_gts'])
plt.title('Pred vs GT')
plt.show()
error = np.array(ct_preds) - np.array(ct_gts)
plt.plot(error)
plt.title('Pred - GT, mean = {}, MAE={}'.format(
str(round(np.mean(error), 3)),
str(round(np.mean(np.abs(error)), 3))
))
plt.show()
idx_max_error = np.argsort(np.abs(error))[::-1]
# Show the 5 worst samples
for worst_idx in idx_max_error[:5].tolist() + [dis_idx]:
test_x_display = np.squeeze(test_x[worst_idx])
test_y_display = np.squeeze(test_y[worst_idx])
path_test_display = test_img_path[worst_idx]
pred = np.squeeze(model.predict(np.expand_dims(test_x_display, axis=0)))
fg, (ax_x_ori, ax_y, ax_pred) = plt.subplots(1, 3, figsize=(20, 4))
ax_x_ori.imshow(cv2.cvtColor(cv2.imread(path_test_display), cv2.COLOR_BGR2RGB))
ax_x_ori.set_title('Original Image')
ax_y.imshow(test_y_display, cmap=plt.cm.jet)
ax_y.set_title('Ground_truth: ' + str(np.sum(test_y_display)))
ax_pred.imshow(pred, cmap=plt.cm.jet)
ax_pred.set_title('Prediction: ' + str(np.sum(pred)))
plt.show()
def define_models(num_encoder_tokens, num_decoder_tokens):
# Define an input sequence and process it.
encoder_inputs = Input(
shape=(None, num_encoder_tokens)) # num_encoder_tokens = 300
encoder = LSTM(latent_dim, return_state=True)
encoder_outputs, state_h, state_c = encoder(encoder_inputs)
# We discard `encoder_outputs` and only keep the states.
encoder_states = [state_h, state_c]
# Set up the decoder, using `encoder_states` as initial state.
decoder_inputs = Input(shape=(None, num_decoder_tokens)) # 3000
# We set up our decoder to return full output sequences,
# and to return internal states as well. We don't use the
# return states in the training model, but we will use them in inference.
decoder_lstm = LSTM(latent_dim, return_sequences=True, return_state=True)
decoder_outputs, _, _ = decoder_lstm(decoder_inputs,
initial_state=encoder_states)
decoder_dense = Dense(num_decoder_tokens, activation='softmax')
decoder_outputs = decoder_dense(decoder_outputs)
# Define the model that will turn
# `encoder_input_data` & `decoder_input_data` into `decoder_target_data`
model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
# Run training
try:
json_file = open('check-points/model.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
model = model_from_json(loaded_model_json)
model.load_weights("check-points/best-epoch.hdf5")
except:
print('No saved model')
try:
model = multi_gpu_model(model, cpu_relocation=True)
print("Training using multiple GPUs..")
except:
print("Training using single GPU or CPU..")
with open("check-points/model.json", "w") as json_file:
json_file.write(model.to_json())
# Define sampling models
encoder_model = Model(encoder_inputs, encoder_states)
decoder_state_input_h = Input(shape=(latent_dim, ))
decoder_state_input_c = Input(shape=(latent_dim, ))
decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]
decoder_outputs, state_h, state_c = decoder_lstm(
decoder_inputs, initial_state=decoder_states_inputs)
decoder_states = [state_h, state_c]
decoder_outputs = decoder_dense(decoder_outputs)
decoder_model = Model([decoder_inputs] + decoder_states_inputs,
[decoder_outputs] + decoder_states)
return model, encoder_model, decoder_model
def load_model(project_path, model_name):
# load json and create model
json_file = open(os.path.join(project_path, '%s.json' % model_name), 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights(os.path.join(project_path, '%s.h5' % model_name))
print("Loaded model from disk")
return loaded_model
def load_model(path_src):
json_file = open(path_src + ".json", 'r')
model_json = json_file.read()
model = model_from_json(model_json)
model.load_weights(path_src + ".h5")
model._make_predict_function()
model.compile(loss='categorical_crossentropy',
optimizer='adadelta',
metrics=['accuracy'])
return model
def predict(self, test_x):
test_x = self.getData(test_x)
if not self.model:
json_file = open('lstm_model.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
self.model = model_from_json(loaded_model_json)
self.model.load_weights("lstm_model.h5")
predicted = self.model.predict(test_x)
return predicted
def decoder_hook(d):
if d.get('__enum__'):
name, member = d["__enum__"].split(".")
return getattr(PUBLIC_ENUMS[name], member)
if d.get('__sequential__'):
return model_from_json(d["__sequential__"])
if d.get('__sequential__'):
return dp.parse(d.get('__isoformat__'))
else:
return d
def readModelFromJSON():
json_file = open('./model.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
model = model_from_json(loaded_model_json)
model.load_weights("./model.h5")
model.summary()
print("Model okundu.")
return model
def load_model(model_name):
save_dir = config.MODEL_SAVE_DIR
json_file = open('{}/{}.json'.format(save_dir, model_name), 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights("{}/{}.h5".format(save_dir, model_name))
return loaded_model
def test_lstm(x):
json_file = open('lstm_model.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
model = model_from_json(loaded_model_json)
model.load_weights("lstm_model.h5")
print("=======Loaded model ok========")
predicted = model.predict(x)
print("=====predict as======", predicted)
print("=====previous =======", x[-1][-1])
def plot_weight(crime_type):
# 学習済みのモデルを読み込み
model_2014 = model_from_json(
open('result/' + crime_type + '2014.json', 'r').read())
model_2015 = model_from_json(
open('result/' + crime_type + '2015.json', 'r').read())
model_2016 = model_from_json(
open('result/' + crime_type + '2016.json', 'r').read())
model_2017 = model_from_json(
open('result/' + crime_type + '2017.json', 'r').read())
model_2018 = model_from_json(
open('result/' + crime_type + '2018.json', 'r').read())
# 重みを読み込む
model_2014.load_weights('result/' + crime_type + '2014.hdf5')
model_2015.load_weights('result/' + crime_type + '2015.hdf5')
model_2016.load_weights('result/' + crime_type + '2016.hdf5')
model_2017.load_weights('result/' + crime_type + '2017.hdf5')
model_2018.load_weights('result/' + crime_type + '2018.hdf5')
# 入力層の重みを抽出
w_2014 = model_2014.layers[0].get_weights()[0]
w_2015 = model_2015.layers[0].get_weights()[0]
w_2016 = model_2016.layers[0].get_weights()[0]
w_2017 = model_2017.layers[0].get_weights()[0]
w_2018 = model_2018.layers[0].get_weights()[0]
# 入力層の重みをプロットする
fp = FontProperties(fname=r'C:\WINDOWS\Fonts\msgothic.ttc', size=14)
fig = pyplot.figure(figsize=(12, 6))
pyplot.plot((w_2014**2).mean(axis=1), 'o-', label='2014')
pyplot.plot((w_2015**2).mean(axis=1), '^-', label='2015')
pyplot.plot((w_2016**2).mean(axis=1), 's-', label='2016')
pyplot.plot((w_2017**2).mean(axis=1), 'x-', label='2017')
pyplot.plot((w_2018**2).mean(axis=1), 'D-', label='2018')
pyplot.xlabel('入力ユニット', fontproperties=fp)
pyplot.ylabel('重みの平均値', fontproperties=fp)
pyplot.legend(prop=fp)
pyplot.show()
fig.savefig('result/weight.svg',
dpi=300,
facecolor='None',
edgecolor='None',
transparent=True,
format='svg')
def init(model):
json = 'models/bin/' + model + '.json'
h5 = 'models/bin/' + model + '.h5'
json_file = open(json, 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
loaded_model.load_weights(h5)
loaded_model.compile(loss='mean_squared_error', optimizer='adam')
graph = get_default_graph()
return loaded_model, graph
def load_model(self, model_json_file, model_weights_file):
json_file = open(model_json_file, 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
loaded_model.load_weights(model_weights_file)
optimizer = RMSprop(lr=0.0001, clipvalue=1.0)
loaded_model.compile(loss='categorical_crossentropy',
optimizer=optimizer)
loaded_model.summary()
return loaded_model
def build_model():
# load json
json_file = open(BACKUP_PATH + "/" + filename + '.json', 'r')
model_json = json_file.read()
json_file.close()
# load weights
new_model = model_from_json(model_json)
new_model.load_weights(BACKUP_PATH + "/" + filename + ".h5")
return new_model
def load_model(self, object_class, core_width, core_height):
file_name = "class" + str(object_class) + str(core_width) + str(
core_height)
json_file = open(
'networks/' + self.data_folder + "/" + file_name + '.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
loaded_model.load_weights('networks/' + self.data_folder + "/" +
file_name + '.h5')
return loaded_model
def load_model(file_name="model"):
# load json and create model
json_file = open(file_name + '.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights(file_name + '.h5')
print("Loaded model from disk")
return loaded_model
def import_model(path="model.json", path_weights="model.h5", path_history="history.json"):
# load json and create model
json_file = open(path, 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights(path_weights)
loaded_model_history = json.load(open(path_history, 'r'))
print("Loaded model from disk")
return loaded_model, loaded_model_history
def load(self):
model_structure_path = os.path.join(self.path_to_weights_folder, 'model.json')
model_weights_path = os.path.join(self.path_to_weights_folder, 'weights.hd5')
scaler_path = os.path.join(self.path_to_weights_folder, 'scaler.pkl')
with open(model_structure_path, 'r') as f:
model_json = json.load(f)
self.model = model_from_json(model_json)
self.model.load_weights(model_weights_path)
self.model.compile(loss='mean_squared_error', optimizer='adam')
with open(scaler_path, 'rb') as f:
self.scaler = pickle.load(f)
