def save_onnx(self, save_folder, save_name='base_model.onnx'):
os.environ["TF_KERAS"] = '1'
import efficientnet.tfkeras as efn
import keras2onnx
onnx_model = keras2onnx.convert_keras(self.base_model,
self.base_model.name)
keras2onnx.save_model(onnx_model, os.path.join(save_folder, save_name))
def main():
train(train_generator)
# save keras model
model_folder = 'model'
if not os.path.exists(model_folder):
os.mkdir(model_folder)
json_file = os.path.join(model_folder, 'sample.json')
yaml_file = os.path.join(model_folder, 'sample.yaml')
h5_file = os.path.join(model_folder, 'sample.hdf5')
json_string = model.to_json()
open(json_file, 'w').write(json_string)
yaml_string = model.to_yaml()
open(yaml_file, 'w').write(yaml_string)
model.save_weights(h5_file)
onnx_folder = 'onnx'
if not os.path.exists(onnx_folder):
os.mkdir(onnx_folder)
onnx_path = os.path.join(onnx_folder, 'sample.onnx')
onnx_model = keras2onnx.convert_keras(model, 'sample', target_opset=qumico.SUPPORT_ONNX_OPSET)
onnx.save_model(onnx_model, onnx_path)
print(h5_file, "を作成しました。")
print('onnxファイルを生成しました。出力先:', onnx_path)
def test_NBeats(self):
K.clear_session()
num_samples, time_steps, input_dim, output_dim = 50000, 10, 1, 1
# Definition of the model.
keras_model = NBeatsNet(backcast_length=time_steps,
forecast_length=output_dim,
stack_types=(NBeatsNet.GENERIC_BLOCK,
NBeatsNet.GENERIC_BLOCK),
nb_blocks_per_stack=2,
thetas_dim=(4, 4),
share_weights_in_stack=True,
hidden_layer_units=64)
data = np.random.rand(num_samples, time_steps,
input_dim).astype(np.float32)
expected = keras_model.predict(data)
onnx_model = keras2onnx.convert_keras(keras_model, keras_model.name)
self.assertTrue(
run_keras_and_ort(onnx_model.graph.name,
onnx_model,
keras_model,
data,
expected,
self.model_files,
compare_perf=True))
def _test_keras_model(self,
model,
model_name='onnx_conversion',
rtol=1.e-3,
atol=1.e-5,
img_size=224):
img_path = os.path.join(os.path.dirname(__file__), 'data',
'elephant.jpg')
try:
img = image.load_img(img_path, target_size=(img_size, img_size))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
onnx_model = keras2onnx.convert_keras(model, model.name)
self.assertTrue(
self.run_onnx_runtime(model_name,
onnx_model,
x,
preds,
rtol=rtol,
atol=atol))
except FileNotFoundError:
self.assertTrue(False, 'The image data does not exist.')
def convert_tensorflow(nlp: Pipeline, opset: int, output: str):
if not is_tf_available():
raise Exception(
"Cannot convert {} because TF is not installed. Please install torch first."
.format(args.model))
print(
"/!\\ Please note TensorFlow doesn't support exporting model > 2Gb /!\\"
)
try:
import tensorflow as tf
from keras2onnx import convert_keras, save_model, __version__ as k2ov
print("TensorFlow: {}, keras2onnx: {}".format(tf.version.VERSION,
k2ov))
# Build
input_names, output_names, dynamic_axes, tokens = infer_shapes(
nlp, "tf")
# Forward
nlp.model.predict(tokens.data)
onnx_model = convert_keras(nlp.model,
nlp.model.name,
target_opset=opset)
save_model(onnx_model, output)
except ImportError as e:
raise Exception(
"Cannot import {} required to convert TF model to ONNX. Please install {} first."
.format(e.name, e.name))
def test_channel_last(self):
N, C, H, W = 2, 3, 5, 5
x = np.random.rand(N, H, W, C).astype(np.float32, copy=False)
model = keras.models.Sequential()
model.add(
keras.layers.Conv2D(2,
kernel_size=(1, 2),
strides=(1, 1),
padding='valid',
input_shape=(H, W, C),
data_format='channels_last'))
model.add(
keras.layers.MaxPooling2D((2, 2),
strides=(2, 2),
data_format='channels_last'))
model.compile(optimizer='sgd', loss='mse')
onnx_model = keras2onnx.convert_keras(
model, channel_first_inputs=[model.inputs[0].name])
expected = model.predict(x)
self.assertIsNotNone(expected)
self.assertIsNotNone(onnx_model)
x = np.transpose(x.astype(np.float32), [0, 3, 1, 2])
self.assertTrue(
self.run_onnx_runtime('channel_last_input', onnx_model, x,
expected))
def test_recursive_and_shared_model(self):
from keras.layers import Input, Dense, Add, Activation
N, C, D = 2, 3, 3
x = np.random.rand(N, C).astype(np.float32, copy=False)
sub_input1 = Input(shape=(C, ))
sub_mapped1 = Dense(D)(sub_input1)
sub_output1 = Activation('sigmoid')(sub_mapped1)
sub_model1 = keras.Model(inputs=sub_input1, outputs=sub_output1)
sub_input2 = Input(shape=(C, ))
sub_mapped2 = sub_model1(sub_input2)
sub_output2 = Activation('tanh')(sub_mapped2)
sub_model2 = keras.Model(inputs=sub_input2, outputs=sub_output2)
input1 = Input(shape=(D, ))
input2 = Input(shape=(D, ))
mapped1_1 = Activation('tanh')(input1)
mapped2_1 = Activation('sigmoid')(input2)
mapped1_2 = sub_model1(mapped1_1)
mapped1_3 = sub_model1(mapped1_2)
mapped2_2 = sub_model2(mapped2_1)
sub_sum = Add()([mapped1_3, mapped2_2])
keras_model = keras.Model(inputs=[input1, input2], outputs=sub_sum)
onnx_model = keras2onnx.convert_keras(keras_model, keras_model.name)
x = [x, 2 * x]
expected = keras_model.predict(x)
self.assertTrue(
self.run_onnx_runtime('recursive_and_shared', onnx_model, x,
expected))
def convert_model(yolo, model_file_name, target_opset):
yolo.load_model()
onnxmodel = convert_keras(yolo.final_model,
target_opset=target_opset,
channel_first_inputs=['input_1'])
onnx.save_model(onnxmodel, model_file_name)
return onnxmodel
def save_onnx(self, model_dir: str, version: int = 1):
"""Save/Export Critic model in ONNX format"""
critic_model_save_path = os.path.join(model_dir, "critic",
str(version), "model.onnx")
onnx_model = keras2onnx.convert_keras(self.model, self.model.name)
keras2onnx.save_model(onnx_model, critic_model_save_path)
print(f"Critic model saved in ONNX format at:{critic_model_save_path}")
def test_TFGPT2(self):
if enable_full_transformer_test:
from transformers import GPT2Config, TFGPT2Model, TFGPT2LMHeadModel, TFGPT2DoubleHeadsModel
model_list = [
TFGPT2Model, TFGPT2LMHeadModel, TFGPT2DoubleHeadsModel
]
else:
from transformers import GPT2Config, TFGPT2Model
model_list = [TFGPT2Model]
# pretrained_weights = 'gpt2'
tokenizer_file = 'gpt2_gpt2.pickle'
tokenizer = self._get_tokenzier(tokenizer_file)
text, inputs, inputs_onnx = self._prepare_inputs(tokenizer)
config = GPT2Config()
for model_instance_ in model_list:
keras.backend.clear_session()
model = model_instance_(config)
model._set_inputs(inputs)
predictions_original = model(inputs)
predictions = [predictions_original[0]] + list(
v_.numpy() for v_ in predictions_original[1])
onnx_model = keras2onnx.convert_keras(model, model.name)
self.assertTrue(
run_onnx_runtime(onnx_model.graph.name,
onnx_model,
inputs_onnx,
predictions,
self.model_files,
rtol=1.e-2,
atol=1.e-4))
def kconversion():
model = keras.models.load_model('model_keras')
plot_model(model,
to_file="model.png",
show_shapes=True,
show_layer_names=True,
rankdir='TB',
expand_nested=True,
dpi=96)
onnx_model = keras2onnx.convert_keras(model,
'model0.onnx',
debug_mode=True)
output_model_path = "./model0.onnx"
# and save the model in ONNX format
keras2onnx.save_model(onnx_model, output_model_path)
onnx_model = onnx.load("model0.onnx")
s = MessageToJson(onnx_model)
onnx_json = json.loads(s)
# Convert JSON to String
onnx_str = json.dumps(onnx_json)
with open("model1.json", "w") as json_file:
json_file.write(onnx_str)
resp = make_response(onnx_str)
resp.headers['Access-Control-Allow-Origin'] = '*'
return resp
def test_keras_resnet_batchnormalization(self):
N, C, H, W = 2, 3, 120, 120
import keras_resnet
model = Sequential()
model.add(
ZeroPadding2D(padding=((3, 3), (3, 3)),
input_shape=(H, W, C),
data_format='channels_last'))
model.add(
Conv2D(64,
kernel_size=(7, 7),
strides=(2, 2),
padding='valid',
dilation_rate=(1, 1),
use_bias=False,
data_format='channels_last'))
model.add(keras_resnet.layers.BatchNormalization(freeze=True, axis=3))
onnx_model = keras2onnx.convert_keras(model, model.name)
data = np.random.rand(N, H, W, C).astype(np.float32).reshape(
(N, H, W, C))
expected = model.predict(data)
self.assertTrue(
run_onnx_runtime(onnx_model.graph.name, onnx_model, data, expected,
self.model_files))
def test_babi_rnn(self):
# two recurrent neural networks based upon a story and a question.
# from https://github.com/keras-team/keras/blob/master/examples/babi_rnn.py
RNN = keras.layers.recurrent.LSTM
EMBED_HIDDEN_SIZE = 50
SENT_HIDDEN_SIZE = 100
QUERY_HIDDEN_SIZE = 100
BATCH_SIZE = 32
story_maxlen = 15
vocab_size = 27
query_maxlen = 17
sentence = Input(shape=(story_maxlen, ), dtype='int32')
encoded_sentence = Embedding(vocab_size, EMBED_HIDDEN_SIZE)(sentence)
encoded_sentence = RNN(SENT_HIDDEN_SIZE)(encoded_sentence)
question = Input(shape=(query_maxlen, ), dtype='int32')
encoded_question = Embedding(vocab_size, EMBED_HIDDEN_SIZE)(question)
encoded_question = RNN(QUERY_HIDDEN_SIZE)(encoded_question)
merged = concatenate([encoded_sentence, encoded_question])
preds = Dense(vocab_size, activation='softmax')(merged)
model = Model([sentence, question], preds)
onnx_model = keras2onnx.convert_keras(model, model.name)
x = np.random.randint(5, 10,
size=(BATCH_SIZE, story_maxlen)).astype(np.int32)
y = np.random.randint(5, 10,
size=(BATCH_SIZE, query_maxlen)).astype(np.int32)
expected = model.predict([x, y])
self.assertTrue(
run_onnx_runtime(onnx_model.graph.name, onnx_model, {
model.input_names[0]: x,
model.input_names[1]: y
}, expected, self.model_files))
def test_CNN_LSTM(self):
K.clear_session()
max_len = 20
vocab_size = 50
lstm_output_size = 70
embedding_size = 100
model = Sequential()
model.add(
Embedding(input_dim=vocab_size,
input_length=max_len,
output_dim=embedding_size))
model.add(SpatialDropout1D(0.2))
model.add(
Conv1D(filters=256,
kernel_size=5,
padding='same',
activation='relu'))
model.add(MaxPooling1D(pool_size=4))
model.add(LSTM(lstm_output_size))
model.add(Dense(units=30, activation='softmax'))
data = np.random.rand(2, max_len).astype(np.float32)
expected = model.predict(data)
onnx_model = keras2onnx.convert_keras(model, model.name)
self.assertTrue(
run_keras_and_ort(onnx_model.graph.name, onnx_model, model, data,
expected, self.model_files))
def test_MLSTM_FCN(self):
K.clear_session()
ip = Input(shape=(MAX_NB_VARIABLES, MAX_TIMESTEPS))
x = Masking()(ip)
x = LSTM(8)(x)
x = Dropout(0.8)(x)
y = Permute((2, 1))(ip)
y = Conv1D(128, 8, padding='same', kernel_initializer='he_uniform')(y)
y = BatchNormalization()(y)
y = Activation('relu')(y)
y = squeeze_excite_block(y)
y = Conv1D(256, 5, padding='same', kernel_initializer='he_uniform')(y)
y = BatchNormalization()(y)
y = Activation('relu')(y)
y = squeeze_excite_block(y)
y = Conv1D(128, 3, padding='same', kernel_initializer='he_uniform')(y)
y = BatchNormalization()(y)
y = Activation('relu')(y)
y = GlobalAveragePooling1D()(y)
x = concatenate([x, y])
out = Dense(NB_CLASS, activation='softmax')(x)
keras_model = Model(ip, out)
data = np.random.rand(2, MAX_NB_VARIABLES,
MAX_TIMESTEPS).astype(np.float32)
expected = keras_model.predict(data)
onnx_model = keras2onnx.convert_keras(keras_model, keras_model.name)
self.assertTrue(
run_keras_and_ort(onnx_model.graph.name, onnx_model, keras_model,
data, expected, self.model_files))
def test_addition_rnn(self):
# An implementation of sequence to sequence learning for performing addition
# from https://github.com/keras-team/keras/blob/master/examples/addition_rnn.py
DIGITS = 3
MAXLEN = DIGITS + 1 + DIGITS
HIDDEN_SIZE = 128
BATCH_SIZE = 128
CHARS_LENGTH = 12
for RNN in [
keras.layers.LSTM, keras.layers.GRU, keras.layers.SimpleRNN
]:
model = keras.models.Sequential()
model.add(RNN(HIDDEN_SIZE, input_shape=(MAXLEN, CHARS_LENGTH)))
model.add(keras.layers.RepeatVector(DIGITS + 1))
model.add(RNN(HIDDEN_SIZE, return_sequences=True))
model.add(
keras.layers.TimeDistributed(
keras.layers.Dense(CHARS_LENGTH, activation='softmax')))
onnx_model = keras2onnx.convert_keras(model, model.name)
x = np.random.rand(BATCH_SIZE, MAXLEN,
CHARS_LENGTH).astype(np.float32)
expected = model.predict(x)
self.assertTrue(
run_onnx_runtime(onnx_model.graph.name, onnx_model, x,
expected, self.model_files))
def test_ecg_classification(self):
model = Sequential()
model.add(Conv2D(64, (3, 3), strides=(1, 1), input_shape=[128, 128, 3], kernel_initializer='glorot_uniform'))
model.add(keras.layers.ELU())
model.add(BatchNormalization())
model.add(Conv2D(64, (3, 3), strides=(1, 1), kernel_initializer='glorot_uniform'))
model.add(keras.layers.ELU())
model.add(BatchNormalization())
model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Conv2D(128, (3, 3), strides=(1, 1), kernel_initializer='glorot_uniform'))
model.add(keras.layers.ELU())
model.add(BatchNormalization())
model.add(Conv2D(128, (3, 3), strides=(1, 1), kernel_initializer='glorot_uniform'))
model.add(keras.layers.ELU())
model.add(BatchNormalization())
model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Conv2D(256, (3, 3), strides=(1, 1), kernel_initializer='glorot_uniform'))
model.add(keras.layers.ELU())
model.add(BatchNormalization())
model.add(Conv2D(256, (3, 3), strides=(1, 1), kernel_initializer='glorot_uniform'))
model.add(keras.layers.ELU())
model.add(BatchNormalization())
model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Flatten())
model.add(Dense(2048))
model.add(keras.layers.ELU())
model.add(BatchNormalization())
model.add(Dropout(0.5))
model.add(Dense(7, activation='softmax'))
onnx_model = keras2onnx.convert_keras(model, model.name)
data = np.random.rand(2, 128, 128, 3).astype(np.float32)
expected = model.predict(data)
self.assertTrue(
run_keras_and_ort(onnx_model.graph.name, onnx_model, model, data, expected, self.model_files))
def test_mlf(runner):
tf.keras.backend.clear_session()
mlf = MLP()
np_input = tf.random.normal((2, 20))
expected = mlf.predict(np_input)
oxml = keras2onnx.convert_keras(mlf)
assert runner('lenet', oxml, np_input.numpy(), expected)
def test_TFXLNet(self):
if enable_full_transformer_test:
from transformers import XLNetConfig, TFXLNetModel, TFXLNetLMHeadModel, TFXLNetForSequenceClassification, \
TFXLNetForTokenClassification, TFXLNetForQuestionAnsweringSimple, XLNetTokenizer
model_list = [TFXLNetModel, TFXLNetLMHeadModel, TFXLNetForSequenceClassification, \
TFXLNetForTokenClassification, TFXLNetForQuestionAnsweringSimple]
else:
from transformers import XLNetConfig, TFXLNetModel, XLNetTokenizer
model_list = [TFXLNetModel]
# XLNetTokenizer need SentencePiece, so the pickle file does not work here.
tokenizer = XLNetTokenizer.from_pretrained('xlnet-large-cased')
config = XLNetConfig(n_layer=2)
# The model with input mask has MatrixDiagV3 which is not a registered function/op
token = np.asarray(tokenizer.encode(self.text_str,
add_special_tokens=True),
dtype=np.int32)
inputs_onnx = {'input_1': np.expand_dims(token, axis=0)}
inputs = tf.constant(token)[None, :] # Batch size 1
for model_instance_ in model_list:
keras.backend.clear_session()
model = model_instance_(config)
predictions = model.predict(inputs)
onnx_model = keras2onnx.convert_keras(model)
self.assertTrue(
run_onnx_runtime(onnx_model.graph.name,
onnx_model,
inputs_onnx,
predictions,
self.model_files,
rtol=1.e-2,
atol=1.e-4))
def test_lstm_fcn(self):
MAX_SEQUENCE_LENGTH = 176
NUM_CELLS = 8
NB_CLASS = 37
ip = Input(shape=(1, MAX_SEQUENCE_LENGTH))
x = LSTM(NUM_CELLS)(ip)
x = Dropout(0.8)(x)
y = Permute((2, 1))(ip)
y = Conv1D(128, 8, padding='same', kernel_initializer='he_uniform')(y)
y = BatchNormalization()(y)
y = Activation('relu')(y)
y = Conv1D(256, 5, padding='same', kernel_initializer='he_uniform')(y)
y = BatchNormalization()(y)
y = Activation('relu')(y)
y = Conv1D(128, 3, padding='same', kernel_initializer='he_uniform')(y)
y = BatchNormalization()(y)
y = Activation('relu')(y)
y = GlobalAveragePooling1D()(y)
x = concatenate([x, y])
out = Dense(NB_CLASS, activation='softmax')(x)
model = Model(ip, out)
onnx_model = keras2onnx.convert_keras(model, model.name)
batch_size = 2
data = np.random.rand(batch_size, 1, MAX_SEQUENCE_LENGTH).astype(np.float32).reshape(batch_size, 1, MAX_SEQUENCE_LENGTH)
expected = model.predict(data)
self.assertTrue(run_keras_and_ort(onnx_model.graph.name, onnx_model, model, data, expected, self.model_files))
def export_onnx_model(self):
onnx_model = keras2onnx.convert_keras(
self.model,
self.path2model + '/' + self.version + '_' + self.time_scale)
onnx.save_model(
onnx_model,
self.path2onnx_model + '/' + self.version + '_' + self.time_scale)
def main():
"""Converts a keras model into ONNX format."""
# model = alexnet((224, 224, 3))
model = build_model(
NASNetMobile(input_shape=(224, 224, 3),
include_top=False,
weights='imagenet'))
model.load_weights(KERAS_MODEL_PATH)
# If we have not specified explicitly image dimensions when creating
# the model
#
# model = load_model(KERAS_MODEL_PATH)
# model._layers[0].batch_input_shape = (batch_size, image_size, image_size,
# channels)
#
# In order for the input_shape to be saved correctly we have to
# clone the model into a new one
#
# model = clone_model(model)
#
# When cloning we loose the weights, load them again
#
# model.load_weights(KERAS_MODEL_PATH)
onnx_model = keras2onnx.convert_keras(model, model.name)
# target_opset=target_opset,
# debug_mode=True
keras2onnx.save_model(onnx_model, ONNX_MODEL_PATH)
def convert_tensorflow(nlp: Pipeline, opset: int, output: Path):
"""
Export a TensorFlow backed pipeline to ONNX Intermediate Representation (IR)
Args:
nlp: The pipeline to be exported
opset: The actual version of the ONNX operator set to use
output: Path where will be stored the generated ONNX model
Notes: TensorFlow cannot export model bigger than 2GB due to internal constraint from TensorFlow
"""
if not is_tf_available():
raise Exception("Cannot convert because TF is not installed. Please install tensorflow first.")
print("/!\\ Please note TensorFlow doesn't support exporting model > 2Gb /!\\")
try:
import tensorflow as tf
from keras2onnx import __version__ as k2ov
from keras2onnx import convert_keras, save_model
print(f"Using framework TensorFlow: {tf.version.VERSION}, keras2onnx: {k2ov}")
# Build
input_names, output_names, dynamic_axes, tokens = infer_shapes(nlp, "tf")
# Forward
nlp.model.predict(tokens.data)
onnx_model = convert_keras(nlp.model, nlp.model.name, target_opset=opset)
save_model(onnx_model, output.as_posix())
except ImportError as e:
raise Exception(f"Cannot import {e.name} required to convert TF model to ONNX. Please install {e.name} first.")
def test_imdb_cnn_lstm(self):
# A recurrent convolutional network on the IMDB sentiment classification task.
# from https://github.com/keras-team/keras/blob/master/examples/imdb_cnn_lstm.py
max_features = 20000
maxlen = 100
embedding_size = 128
kernel_size = 5
filters = 64
pool_size = 4
lstm_output_size = 70
batch_size = 30
model = Sequential()
model.add(Embedding(max_features, embedding_size, input_length=maxlen))
model.add(Dropout(0.25))
model.add(
Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
model.add(MaxPooling1D(pool_size=pool_size))
model.add(LSTM(lstm_output_size))
model.add(Dense(1))
model.add(Activation('sigmoid'))
onnx_model = keras2onnx.convert_keras(model, model.name)
x = np.random.rand(batch_size, maxlen).astype(np.float32)
expected = model.predict(x)
self.assertTrue(
run_onnx_runtime(onnx_model.graph.name, onnx_model, x, expected,
self.model_files))
def test_deep_speech_2(self):
K.clear_session()
input_dim = 20
output_dim = 10
rnn_units = 800
# Define input tensor [batch, time, features]
input_tensor = layers.Input([None, input_dim], name='X')
# Add 4th dimension [batch, time, frequency, channel]
x = layers.Lambda(keras.backend.expand_dims,
arguments=dict(axis=-1))(input_tensor)
x = layers.Conv2D(filters=32,
kernel_size=[11, 41],
strides=[2, 2],
padding='same',
use_bias=False,
name='conv_1')(x)
x = layers.BatchNormalization(name='conv_1_bn')(x)
x = layers.ReLU(name='conv_1_relu')(x)
x = layers.Conv2D(filters=32,
kernel_size=[11, 21],
strides=[1, 2],
padding='same',
use_bias=False,
name='conv_2')(x)
x = layers.BatchNormalization(name='conv_2_bn')(x)
x = layers.ReLU(name='conv_2_relu')(x)
# We need to squeeze to 3D tensor. Thanks to the stride in frequency
# domain, we reduce the number of features four times for each channel.
x = layers.Reshape([-1, input_dim//4*32])(x)
for i in [1, 2, 3, 4, 5]:
recurrent = layers.GRU(units=rnn_units,
activation='tanh',
recurrent_activation='sigmoid',
use_bias=True,
return_sequences=True,
reset_after=True,
name='gru_'+str(i))
x = layers.Bidirectional(recurrent,
name='bidirectional'+str(i),
merge_mode='concat')(x)
x = layers.Dropout(rate=0.5)(x) if i < 5 else x # Only between
# Return at each time step logits along characters. Then CTC
# computation is more stable, in contrast to the softmax.
x = layers.TimeDistributed(layers.Dense(units=rnn_units*2), name='dense_1')(x)
x = layers.ReLU(name='dense_1_relu')(x)
x = layers.Dropout(rate=0.5)(x)
output_tensor = layers.TimeDistributed(layers.Dense(units=output_dim),
name='dense_2')(x)
model = keras.Model(input_tensor, output_tensor, name='DeepSpeech2')
data = np.random.rand(2, 3, input_dim).astype(np.float32)
expected = model.predict(data)
onnx_model = keras2onnx.convert_keras(model, model.name)
self.assertTrue(
run_keras_and_ort(onnx_model.graph.name, onnx_model, model, data, expected, self.model_files))
def run(self, max_episodes=500, max_timesteps=1000):
"""
Run a Deep RL algorithm (inspired by https://keon.io/deep-q-learning/)
"""
unity_file = self.download_unity_env()
env = self.get_gym_env(unity_file)
# ========================================== #
model = build_model(self.params['observation_size'])
print('Training...')
for episode in range(max_episodes):
print('Running episode {} of {}'.format(episode + 1, max_episodes),
end='\r')
# observation == state
observation = env.reset()
observation = np.reshape(observation,
(1, self.params['observation_size']))
for step in range(max_timesteps):
if np.random.rand() <= self.params['epsilon']:
# The agent acts randomly
action = [env.action_space.sample()]
else:
action = model.predict(observation)
observation, reward, done, info = env.step(action)
action_val = action[0]
targets = np.zeros(len(action_val))
for i in range(len(action_val)):
targets[i] = reward + self.params['gamma'] * action_val[i]
observation = np.reshape(observation,
(1, self.params['observation_size']))
model.fit(observation,
np.asarray([targets]),
epochs=1,
verbose=0)
# if objective reached, no need to continue
if done:
break
# Note: the content of /opt/ml/model and /opt/ml/output is automatically uploaded
# to previously selected bucket (by the estimator) at the end of the execution
# os.environ['SM_MODEL_DIR'] correspongs to /opt/ml/model
model_path = os.path.join(os.environ['SM_MODEL_DIR'], 'tf_rldemo.onnx')
# Note: converting Keras model to ONNX one for being
# later converted into Barracuda format
# In fact, this model can not be directly employed in Unity ml-agents
# More info can be found here: https://github.com/onnx/keras-onnx
onnx_model = keras2onnx.convert_keras(model, model.name)
onnx.save_model(onnx_model, model_path)
print('\nTraining finished!')
# ========================================== #
TfTrainer.close_env(env)
def export_onnx_model_from_tf(model_name, opset_version,
use_external_data_format, model_type,
model_class, cache_dir, onnx_dir, input_names,
use_gpu, precision, optimize_onnx, validate_onnx,
use_raw_attention_mask, overwrite,
model_fusion_statistics):
config = AutoConfig.from_pretrained(model_name, cache_dir=cache_dir)
model = load_pretrained_model(model_name,
config=config,
cache_dir=cache_dir,
custom_model_class=model_class,
if_tf_model=True)
model._saved_model_inputs_spec = None
tokenizer = AutoTokenizer.from_pretrained(model_name, cache_dir=cache_dir)
max_input_size = tokenizer.max_model_input_sizes[
model_name] if model_name in tokenizer.max_model_input_sizes else 1024
example_inputs = tokenizer.encode_plus("This is a sample input",
return_tensors="tf",
max_length=max_input_size,
pad_to_max_length=True,
truncation=True)
example_inputs = filter_inputs(example_inputs, input_names)
example_outputs = model(example_inputs, training=False)
# Flatten is needed for gpt2 and distilgpt2.
example_outputs_flatten = flatten(example_outputs)
example_outputs_flatten = update_flatten_list(example_outputs_flatten, [])
onnx_model_path = get_onnx_file_path(onnx_dir, model_name,
len(input_names), False, use_gpu,
precision, False,
use_external_data_format)
if overwrite or not os.path.exists(onnx_model_path):
logger.info("Exporting ONNX model to {}".format(onnx_model_path))
import keras2onnx
onnx_model = keras2onnx.convert_keras(model,
model.name,
target_opset=opset_version)
keras2onnx.save_model(onnx_model, onnx_model_path)
else:
logger.info(f"Skip export since model existed: {onnx_model_path}")
model_type = model_type + '_keras'
onnx_model_file, is_valid_onnx_model, vocab_size = validate_and_optimize_onnx(
model_name, use_external_data_format, model_type, onnx_dir,
input_names, use_gpu, precision, optimize_onnx, validate_onnx,
use_raw_attention_mask, overwrite, config, model_fusion_statistics,
onnx_model_path, example_inputs, example_outputs_flatten)
return onnx_model_file, is_valid_onnx_model, vocab_size, max_input_size
def test_GAN(self):
keras_model = GAN().combined
x = np.random.rand(5, 100).astype(np.float32)
expected = keras_model.predict(x)
onnx_model = keras2onnx.convert_keras(keras_model, keras_model.name)
self.assertTrue(
run_onnx_runtime(onnx_model.graph.name, onnx_model, x, expected,
self.model_files))
def test_Pix2Pix(self):
keras_model = Pix2Pix().combined
batch = 5
x = np.random.rand(batch, 256, 256, 3).astype(np.float32)
y = np.random.rand(batch, 256, 256, 3).astype(np.float32)
expected = keras_model.predict([x, y])
onnx_model = keras2onnx.convert_keras(keras_model, keras_model.name)
self.assertTrue(run_onnx_runtime(onnx_model.graph.name, onnx_model, {keras_model.input_names[0]: x, keras_model.input_names[1]: y}, expected, self.model_files))
def test_wavenet(self):
K.clear_session()
keras_model = get_basic_generative_model(128)
data = np.random.rand(2, 128, 1).astype(np.float32)
expected = keras_model.predict(data)
onnx_model = keras2onnx.convert_keras(keras_model, keras_model.name)
self.assertTrue(
run_keras_and_ort(onnx_model.graph.name, onnx_model, keras_model, data, expected, self.model_files))
