def download_model():
export_dir = "./simple_tensorflow_serving/models/use/001"
with tf.Session(graph=tf.Graph()) as sess:
module = hub.Module(
"https://tfhub.dev/google/universal-sentence-encoder-multilingual-large/1"
)
text_input = tf.placeholder(dtype=tf.string, shape=[None])
sess.run([tf.global_variables_initializer(), tf.tables_initializer()])
embeddings = module(text_input)
simple_save(
sess,
export_dir,
inputs={"text": text_input},
outputs={"embeddings": embeddings},
legacy_init_op=tf.tables_initializer(),
)
def save_h5_pb(path_pb: str, path_json='', path_h5='', model=None, **kwargs):
'''
Восстанавливает архитектуру модели, используя .json.
Создаёт keras модель в формате .h5
Конвертирует keras модель из формата .h5 в формат .pb (для TFServ)
:param model: object. tf.keras
:param path_json: string
:param path_h5: string
:param path_pb: string
:param kwargs: dict. При использовании custom_objects в tf.keras model
'''
if int(__version__.split('.')[0]) == 2:
if path_json:
print('load structure.json')
model = load_structure(path_json, **kwargs)
if path_h5:
print('load weights.h5')
filename = os.path.join(path_h5, 'weights.h5')
model.load_weights(filename)
model.save(path_pb)
else:
if path_json:
print('load structure.json')
model = load_structure(path_json, **kwargs)
if path_h5:
print('load weights.h5')
filename = os.path.join(path_h5, 'weights.h5')
model.load_weights(filename)
filename = os.path.join(path_h5, 'model.h5')
model.save(filename)
assert len(
os.listdir(path_pb)) == 0, (f'Директория {path_pb} не пуста')
with get_session() as sess:
simple_save(sess,
path_pb,
inputs={'input_image': model.input},
outputs={t.name: t
for t in model.outputs})
clear_session()
print(f'\nУспешно сохранены данные в {os.path.dirname(path_pb)}')
def add_string():
tf.reset_default_graph()
sess = tf.Session()
input1 = tf.placeholder(tf.string, name="input1")
input2 = tf.placeholder(tf.string, name="input2")
sum = input1 + input2
output = tf.identity(sum, "output")
print(input1)
print(input2)
print(sum)
print(output)
dict = {input1: "hello", input2: "world"}
result = sess.run(output, dict).decode() # decode the bytestring
print(result)
saved_model.simple_save(sess,
'add_string',
inputs={
"input1": input1,
"input2": input2
},
outputs={"output": output})
def boolean_logic():
tf.reset_default_graph()
sess = tf.Session()
input1 = tf.placeholder(tf.bool, name="input1")
input2 = tf.placeholder(tf.bool, name="input2")
output_and = tf.identity(input1 & input2, "output_and")
output_or = tf.identity(input1 | input2, "output_or")
output_not_and = tf.identity(~(input1 & input2), "output_not_and")
output_not_or = tf.identity(~(input1 | input2), "output_not_or")
output_xor = tf.identity(input1 ^ input2, "output_xor")
print(input1)
print(input2)
print(output_and)
print(output_or)
print(output_not_and)
print(output_not_or)
print(output_xor)
dict = {input1: True, input2: False}
result = sess.run(
[output_and, output_or, output_not_and, output_not_or, output_xor],
dict)
print(result)
saved_model.simple_save(sess,
'boolean_logic',
inputs={
"input1": input1,
"input2": input2
},
outputs={
"and": output_and,
"or": output_or,
"not_and": output_not_and,
"not_or": output_not_or,
"xor": output_xor
})
# This scripts show you how to download and setup the universal-sentence-encoder to be served by
# Tensorflow Serving over a REST API
import tensorflow as tf
import tensorflow_hub as hub
from tensorflow.saved_model import simple_save
export_dir = "./use/00000001"
with tf.Session(graph=tf.Graph()) as sess:
module = hub.Module(
"https://tfhub.dev/google/universal-sentence-encoder/2")
input_params = module.get_input_info_dict()
text_input = tf.placeholder(name='text',
dtype=input_params['text'].dtype,
shape=input_params['text'].get_shape())
sess.run([tf.global_variables_initializer(), tf.tables_initializer()])
embeddings = module(text_input)
simple_save(sess,
export_dir,
inputs={'text': text_input},
outputs={'embeddings': embeddings},
legacy_init_op=tf.tables_initializer())
stop_on_nan], #, reduce_lr], #, lr, reduce_lr],
# callbacks=[early_stopping, reduce_lr], #, lr, reduce_lr],
use_multiprocessing=True,
workers=8,
validation_data=gen_x_test)
# ## Plot performance
# Here, we plot the history of the training and the performance in a ROC curve
plot_history(history)
plt.savefig(f'{path}/history.pdf', bbox_inches='tight')
model.save(f'{path}/model.h5')
from tensorflow import saved_model
saved_model.simple_save(K.get_session(),
f'{path}/saved_model',
inputs={t.name: t
for t in model.input},
outputs={t.name: t
for t in model.outputs})
from tensorflow.python.framework import graph_util
frozen_graph = graph_util.convert_variables_to_constants(
K.get_session(),
K.get_session().graph_def, ['output/BiasAdd'])
# train.write_graph(graph_or_graph_def=K.get_session().graph_def, logdir=f'{path}', name='saved_model.pb', as_text=False)
train.write_graph(graph_or_graph_def=frozen_graph,
logdir=f'{path}',
name='saved_model.pb',
as_text=False)
# Print info about weights
names = [weight.name for layer in model.layers for weight in layer.weights]
def save_pretrained_model(sess, outputs, feeds, out_dir, model_name="pretrained"):
"""Save pretrained model and config"""
try:
import os
import sys
import tensorflow as tf
import subprocess
to_onnx_path = "{}/to_onnx".format(out_dir)
if not os.path.isdir(to_onnx_path):
os.makedirs(to_onnx_path)
saved_model = "{}/saved_model".format(to_onnx_path)
inputs_path = "{}/inputs.npy".format(to_onnx_path)
pretrained_model_yaml_path = "{}/pretrained.yaml".format(to_onnx_path)
envars_path = "{}/environment.txt".format(to_onnx_path)
pip_requirement_path = "{}/requirements.txt".format(to_onnx_path)
print("===============Save Saved Model========================")
if os.path.exists(saved_model):
print("{} already exists, SKIP".format(saved_model))
return
print("Save tf version, python version and installed packages")
tf_version = tf.__version__
py_version = sys.version
pip_packages = subprocess.check_output([sys.executable, "-m", "pip", "freeze", "--all"])
pip_packages = pip_packages.decode("UTF-8")
with open(envars_path, "w") as fp:
fp.write(tf_version + os.linesep)
fp.write(py_version)
with open(pip_requirement_path, "w") as fp:
fp.write(pip_packages)
print("Save model for tf2onnx: {}".format(to_onnx_path))
# save inputs
inputs = {}
for inp, value in feeds.items():
if isinstance(inp, str):
inputs[inp] = value
else:
inputs[inp.name] = value
np.save(inputs_path, inputs)
print("Saved inputs to {}".format(inputs_path))
# save graph and weights
from tensorflow.saved_model import simple_save
# pylint: disable=unnecessary-comprehension
simple_save(sess, saved_model,
{n: i for n, i in zip(inputs.keys(), feeds.keys())},
{op.name: op for op in outputs})
print("Saved model to {}".format(saved_model))
# generate config
pretrained_model_yaml = '''
{}:
model: ./saved_model
model_type: saved_model
input_get: get_ramp
'''.format(model_name)
pretrained_model_yaml += " inputs:\n"
for inp, _ in inputs.items():
pretrained_model_yaml += \
" \"{input}\": np.array(np.load(\"./inputs.npy\")[()][\"{input}\"])\n".format(input=inp)
outputs = [op.name for op in outputs]
pretrained_model_yaml += " outputs:\n"
for out in outputs:
pretrained_model_yaml += " - {}\n".format(out)
with open(pretrained_model_yaml_path, "w") as f:
f.write(pretrained_model_yaml)
print("Saved pretrained model yaml to {}".format(pretrained_model_yaml_path))
print("=========================================================")
except Exception as ex: # pylint: disable=broad-except
print("Error: {}".format(ex))
def train(dataset_path: str = None, batch_size=256, epochs=100, use_horovod=False,
output_path=None, model_name='keras_cifar100_trained_model.h5'):
x_train, y_train, x_test, y_test = load_data(dataset_path)
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
num_classes = 100
if not output_path:
output_path = os.path.join(os.getcwd(), 'saved_models')
# Convert class vectors to binary class matrices.
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
model = create_model(input_shape=x_train.shape[1:], num_classes=num_classes)
if use_horovod:
import horovod.keras as hvd
hvd.init()
opt = keras.optimizers.rmsprop(lr=0.0001 * hvd.size(), decay=1e-6)
opt = hvd.DistributedOptimizer(opt)
with tf.Graph().as_default():
inference_model = create_model(input_shape=x_train.shape[1:], num_classes=num_classes)
inference_dummy_opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
inference_model.compile(loss='categorical_crossentropy', optimizer=inference_dummy_opt,
metrics=['accuracy'])
else:
opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
inference_model = model
# Compile and export inference model graph
serve_graph_file = f'{output_path}/servegraph.meta'
tf.train.export_meta_graph(serve_graph_file, as_text=True)
model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
model.summary()
callbacks = []
if use_horovod:
callbacks.append(hvd.callbacks.BroadcastGlobalVariablesCallback(0))
# Save checkpoints/metrics only on first worker
if not use_horovod or hvd.rank() == 0:
callbacks.append(TensorflowModelCheckpoint(f'{output_path}/checkpoint-{{epoch}}.h5'))
callbacks.append(NautaExperimentMetricsCallback())
callbacks.append(keras.callbacks.TensorBoard(log_dir=f'{output_path}/tensorboard', update_freq=1000,
histogram_freq=0, write_graph=True))
model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(x_test, y_test),
shuffle=True, callbacks=callbacks)
# Save model and weights
if not os.path.isdir(output_path):
os.makedirs(output_path)
model_path = os.path.join(output_path, model_name)
model.save(model_path)
print(f'Saved trained model at {model_path}')
# Save model in Tensorflow Serving compatible format
# https://gist.github.com/dmwendt/ed2779f07aa849eda2e1756cd3b9fcb0
if not use_horovod or hvd.rank() == 0:
# Now save the model for inference.
# First, load the parameters from the latest checkpoint file.
checkpoint_file = tf.train.latest_checkpoint(output_path)
tf_model_export_dir = f'{output_path}/cifar100_tf_model/1'
# Create a new graph to import the previously exported one.
with tf.Graph().as_default():
# Import the saved graph.
restorer = tf.train.import_meta_graph(serve_graph_file)
with tf.Session() as sess:
restorer.restore(sess, checkpoint_file)
saved_model.simple_save(session=sess, export_dir=tf_model_export_dir,
inputs={'x': inference_model.layers[0].input},
outputs={'y': inference_model.layers[-1].output})
print(f'Saved trained model in TF format at {tf_model_export_dir}')
# Score trained model.
scores = model.evaluate(x_test, y_test, verbose=1)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])
