def test_music_generation(self): K.clear_session() model, time_model, note_model = build_models() batch_size = 2 data_notes = np.random.rand(batch_size, SEQ_LEN, NUM_NOTES, NOTE_UNITS).astype(np.float32) data_beat = np.random.rand(batch_size, SEQ_LEN, NOTES_PER_BAR).astype(np.float32) data_style = np.random.rand(batch_size, SEQ_LEN, NUM_STYLES).astype(np.float32) data_chosen = np.random.rand(batch_size, SEQ_LEN, NUM_NOTES, NOTE_UNITS).astype(np.float32) expected = model.predict( [data_notes, data_chosen, data_beat, data_style]) onnx_model = keras2onnx.convert_keras(model, model.name) self.assertTrue( run_keras_and_ort( onnx_model.graph.name, onnx_model, model, { model.input_names[0]: data_notes, model.input_names[1]: data_chosen, model.input_names[2]: data_beat, model.input_names[3]: data_style }, expected, self.model_files)) expected = time_model.predict([data_notes, data_beat, data_style]) onnx_model = keras2onnx.convert_keras(time_model, time_model.name) self.assertTrue( run_keras_and_ort( onnx_model.graph.name, onnx_model, time_model, { time_model.input_names[0]: data_notes, time_model.input_names[1]: data_beat, time_model.input_names[2]: data_style }, expected, self.model_files)) data_notes = np.random.rand(batch_size, 1, NUM_NOTES, TIME_AXIS_UNITS).astype(np.float32) data_chosen = np.random.rand(batch_size, 1, NUM_NOTES, NOTE_UNITS).astype(np.float32) data_style = np.random.rand(batch_size, 1, NUM_STYLES).astype(np.float32) expected = note_model.predict([data_notes, data_chosen, data_style]) onnx_model = keras2onnx.convert_keras(note_model, note_model.name) self.assertTrue( run_keras_and_ort( onnx_model.graph.name, onnx_model, note_model, { note_model.input_names[0]: data_notes, note_model.input_names[1]: data_chosen, note_model.input_names[2]: data_style }, 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_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_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 test_DPPG_actor(self): K.clear_session() env_dim = (2, 3) act_dim = 5 act_range = 4 inp = Input(shape=env_dim) # x = Dense(256, activation='relu')(inp) x = GaussianNoise(1.0)(x) # x = Flatten()(x) x = Dense(128, activation='relu')(x) x = GaussianNoise(1.0)(x) # out = Dense(act_dim, activation='tanh', kernel_initializer=RandomUniform())(x) out = Lambda(lambda i: i * act_range)(out) # keras_model = Model(inp, out) data = np.random.rand(1000, 2, 3).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_name_entity_recognition(self): K.clear_session() words_input = Input(shape=(None,), dtype='int32', name='words_input') words = Embedding(input_dim=10, output_dim=20, weights=None, trainable=False)(words_input) casing_input = Input(shape=(None,), dtype='int32', name='casing_input') casing = Embedding(output_dim=20, input_dim=12, weights=None, trainable=False)(casing_input) character_input = Input(shape=(None, 52,), name='char_input') embed_char_out = TimeDistributed( Embedding(26, 20), name='char_embedding')(character_input) dropout = Dropout(0.5)(embed_char_out) conv1d_out = TimeDistributed(Conv1D(kernel_size=3, filters=30, padding='same', activation='tanh', strides=1))( dropout) maxpool_out = TimeDistributed(MaxPooling1D(52))(conv1d_out) char = TimeDistributed(Flatten())(maxpool_out) char = Dropout(0.5)(char) output = concatenate([words, casing, char]) output = Bidirectional(LSTM(200, return_sequences=True, dropout=0.50, recurrent_dropout=0.25))(output) output = TimeDistributed(Dense(35, activation='softmax'))(output) keras_model = Model(inputs=[words_input, casing_input, character_input], outputs=[output]) batch_size = 100 data1 = np.random.randint(5, 10, size=(batch_size, 6)).astype(np.int32) data2 = np.random.randint(5, 10, size=(batch_size, 6)).astype(np.int32) data3 = np.random.rand(batch_size, 6, 52).astype(np.float32) expected = keras_model.predict([data1, data2, data3]) onnx_model = mock_keras2onnx.convert_keras(keras_model, keras_model.name) self.assertTrue( run_keras_and_ort(onnx_model.graph.name, onnx_model, keras_model, {keras_model.input_names[0]: data1, keras_model.input_names[1]: data2, keras_model.input_names[2]: data3}, expected, self.model_files))
def test_NBeats(self): K.clear_session() num_samples, time_steps, input_dim, output_dim = 50_000, 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_DDQN(self): K.clear_session() state_dim = (2, 3) action_dim = 5 inp = Input(shape=(state_dim)) # Determine whether we are dealing with an image input (Atari) or not if (len(state_dim) > 2): inp = Input((state_dim[1:])) x = conv_block(inp, 32, (2, 2), 8) x = conv_block(x, 64, (2, 2), 4) x = conv_block(x, 64, (2, 2), 3) x = Flatten()(x) x = Dense(256, activation='relu')(x) else: x = Flatten()(inp) x = Dense(64, activation='relu')(x) x = Dense(64, activation='relu')(x) x = Dense(action_dim + 1, activation='linear')(x) x = Lambda(lambda i: K.expand_dims(i[:,0],-1) + i[:,1:] - K.mean(i[:,1:], keepdims=True), output_shape=(action_dim,))(x) keras_model = Model(inp, x) data = np.random.rand(1000, 2, 3).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, rtol=1e-2, atol=2e-2))
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_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_keras_and_ort(onnx_model.graph.name, onnx_model, model, data, 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 test_NASNetMobile(self): K.clear_session() keras_model = NASNetMobile() data = np.random.rand(2, 224, 224, 3).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_Deeplab_v3(self): K.clear_session() keras_model = Deeplabv3(weights=None) data = np.random.rand(2, 512, 512, 3).astype(np.float32) expected = keras_model.predict(data) onnx_model = mock_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_PRN_Separate(self): K.clear_session() keras_model = PRN_Seperate(28, 18, 15) data = np.random.rand(2, 28, 18, 17).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_SE_InceptionResNetV2(self): K.clear_session() keras_model = SEInceptionResNetV2() data = np.random.rand(2, 128, 128, 3).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_DeepSpeaker(self): K.clear_session() keras_model = DeepSpeakerModel(batch_input_shape=(None, 32, 64, 4), include_softmax=True, num_speakers_softmax=10).keras_model() data = np.random.rand(2, 32, 64, 4).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_wide_residual_network(self): K.clear_session() keras_model = create_wide_residual_network(input_dim=(32, 32, 3)) data = np.random.rand(200, 32, 32, 3).astype(np.float32) expected = keras_model.predict(data) onnx_model = mock_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_series_net(self): K.clear_session() keras_model = DC_CNN_Model(20) data = np.random.rand(2000, 20, 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, compare_perf=True))
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))
def test_PlainNet(self): K.clear_session() keras_model = PlainNet(100) data = np.random.rand(200, 32, 32, 3).astype(np.float32) expected = keras_model.predict(data) onnx_model = mock_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_non_local_nets(self): K.clear_session() for keras_model in [NonLocalResNet18((128, 160, 3), classes=10), NonLocalResNet50((128, 160, 3), classes=10)]: data = np.random.rand(2, 128, 160, 3).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_chatbot(self): K.clear_session() vocabulary_size = 1085 embedding_dim = int(pow(vocabulary_size, 1.0 / 4)) latent_dim = embedding_dim * 40 encoder_inputs = Input(shape=(None, ), name='encoder_input') encoder_embedding = Embedding(vocabulary_size, embedding_dim, mask_zero=True, name='encoder_Embedding')(encoder_inputs) encoder = Bidirectional(LSTM(latent_dim, return_sequences=True, return_state=True, dropout=0.5), name='encoder_BiLSTM') encoder_outputs, fw_state_h, fw_state_c, bw_state_h, bw_state_c = encoder( encoder_embedding) state_h = Concatenate(axis=-1, name='encoder_state_h')([fw_state_h, bw_state_h]) state_c = Concatenate(axis=-1, name='encoder_state_c')([fw_state_c, bw_state_c]) encoder_states = [state_h, state_c] decoder_inputs = Input(shape=(None, ), name='decoder_input') decoder_embedding = Embedding(vocabulary_size, embedding_dim, mask_zero=True, name='decoder_embedding')(decoder_inputs) decoder_lstm = LSTM(latent_dim * 2, return_sequences=True, return_state=True, name='decoder_LSTM', dropout=0.5) decoder_outputs, _, _ = decoder_lstm(decoder_embedding, initial_state=encoder_states) attention = Dense(1, activation='tanh')(encoder_outputs) attention = Flatten()(attention) attention = Activation('softmax')(attention) attention = RepeatVector(latent_dim * 2)(attention) attention = Permute([2, 1])(attention) sent_dense = Multiply()([decoder_outputs, attention]) decoder_dense = Dense(vocabulary_size, activation='softmax', name='dense_layer') decoder_outputs = decoder_dense(sent_dense) keras_model = Model([encoder_inputs, decoder_inputs], decoder_outputs) data1 = np.random.rand(2, 12).astype(np.float32) data2 = np.random.rand(2, 12).astype(np.float32) expected = keras_model.predict([data1, data2]) onnx_model = mock_keras2onnx.convert_keras(keras_model, keras_model.name) self.assertTrue( run_keras_and_ort(onnx_model.graph.name, onnx_model, keras_model, [data1, data2], expected, self.model_files))
def test_DistilledResNetSR(self): K.clear_session() model_type = DistilledResNetSR(2.0) keras_model = model_type.create_model() data = np.random.rand(2, 32, 32, 3).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_DPN92(self): K.clear_session() keras_model = DPN92(input_shape=(224, 224, 3)) data = np.random.rand(2, 224, 224, 3).astype(np.float32) expected = keras_model.predict(data) onnx_model = mock_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_GANImageSuperResolutionModel(self): K.clear_session() model_type = GANImageSuperResolutionModel(2.0) keras_model = model_type.create_model() data = np.random.rand(2, 32, 32, 3).astype(np.float32) expected = keras_model.predict(data) onnx_model = mock_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_DeepLabV3Plus(self): K.clear_session() keras_model = DeeplabV3_plus(input_height=224, input_width=224) data = np.random.rand(1, 224, 224, 3).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_ENet(self): K.clear_session() keras_model = ENet(80) data = np.random.rand(1, 256, 256, 3).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_deep_speech(self): K.clear_session() input_dim = 20 output_dim = 10 context = 7 units = 1024 dropouts = (0.1, 0.1, 0) # 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) # Fill zeros around time dimension x = layers.ZeroPadding2D(padding=(context, 0))(x) # Convolve signal in time dim receptive_field = (2 * context + 1, input_dim) x = layers.Conv2D(filters=units, kernel_size=receptive_field)(x) # Squeeze into 3rd dim array x = layers.Lambda(keras.backend.squeeze, arguments=dict(axis=2))(x) # Add non-linearity x = layers.ReLU(max_value=20)(x) # Use dropout as regularization x = layers.Dropout(rate=dropouts[0])(x) # 2nd and 3rd FC layers do a feature extraction base on a narrow # context of convolutional layer x = layers.TimeDistributed(layers.Dense(units))(x) x = layers.ReLU(max_value=20)(x) x = layers.Dropout(rate=dropouts[1])(x) x = layers.TimeDistributed(layers.Dense(units))(x) x = layers.ReLU(max_value=20)(x) x = layers.Dropout(rate=dropouts[2])(x) # Use recurrent layer to have a broader context x = layers.Bidirectional(layers.LSTM(units, return_sequences=True), merge_mode='sum')(x) # Return at each time step logits along characters. Then CTC # computation is more stable, in contrast to the softmax. output_tensor = layers.TimeDistributed(layers.Dense(output_dim))(x) model = keras.Model(input_tensor, output_tensor, name='DeepSpeech') data = np.random.rand(2, 3, input_dim).astype(np.float32) expected = model.predict(data) onnx_model = mock_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_tcn(self): from tcn import TCN batch_size, timesteps, input_dim = None, 20, 1 actual_batch_size = 3 i = Input(batch_shape=(batch_size, timesteps, input_dim)) np.random.seed(1000) # set the random seed to avoid the output result discrepancies. for return_sequences in [True, False]: o = TCN(return_sequences=return_sequences)(i) # The TCN layers are here. o = Dense(1)(o) model = keras.models.Model(inputs=[i], outputs=[o]) onnx_model = keras2onnx.convert_keras(model, model.name) data = np.random.rand(actual_batch_size, timesteps, input_dim).astype(np.float32).reshape((actual_batch_size, timesteps, input_dim)) expected = model.predict(data) self.assertTrue(run_keras_and_ort(onnx_model.graph.name, onnx_model, model, data, expected, self.model_files))
def test_Multi_Channel_CNN(self): K.clear_session() embedding_size = 100 cnn_filter_size = 32 length = 20 vocab_size = 50 inputs1 = Input(shape=(length, )) embedding1 = Embedding(vocab_size, embedding_size)(inputs1) conv1 = Conv1D(filters=cnn_filter_size, kernel_size=4, activation='relu')(embedding1) drop1 = Dropout(0.5)(conv1) pool1 = MaxPooling1D(pool_size=2)(drop1) flat1 = Flatten()(pool1) inputs2 = Input(shape=(length, )) embedding2 = Embedding(vocab_size, embedding_size)(inputs2) conv2 = Conv1D(filters=cnn_filter_size, kernel_size=6, activation='relu')(embedding2) drop2 = Dropout(0.5)(conv2) pool2 = MaxPooling1D(pool_size=2)(drop2) flat2 = Flatten()(pool2) inputs3 = Input(shape=(length, )) embedding3 = Embedding(vocab_size, embedding_size)(inputs3) conv3 = Conv1D(filters=cnn_filter_size, kernel_size=8, activation='relu')(embedding3) drop3 = Dropout(0.5)(conv3) pool3 = MaxPooling1D(pool_size=2)(drop3) flat3 = Flatten()(pool3) merged = concatenate([flat1, flat2, flat3]) # interpretation dense1 = Dense(10, activation='relu')(merged) outputs = Dense(units=30, activation='softmax')(dense1) model = Model(inputs=[inputs1, inputs2, inputs3], outputs=outputs) batch_size = 2 data0 = np.random.rand(batch_size, length).astype(np.float32) data1 = np.random.rand(batch_size, length).astype(np.float32) data2 = np.random.rand(batch_size, length).astype(np.float32) expected = model.predict([data0, data1, data2]) onnx_model = keras2onnx.convert_keras(model, model.name) self.assertTrue( run_keras_and_ort(onnx_model.graph.name, onnx_model, model, [data0, data1, data2], expected, self.model_files))