如何保存Tensorflow编码器解码器模型？

Question

我跟随this tutorial构建了一个编码器-解码器语言转换模型，并为我的母语构建了一个模型。

现在我想保存它，部署到云ML引擎上，并使用HTTP请求进行预测。

我找不到一个明确的例子来说明如何保存这个模型，

我是ML的新手，发现TF save guide v令人困惑。

有没有一种方法可以使用像tf.keras.models.save_model这样的工具保存这个模型

Answer 1

在打开会话后创建列车保护程序，并在完成培训后保存模型：

with tf.Session() as sess:
     saver = tf.train.Saver()
     # Training of the model
     save_path = saver.save(sess, "logs/encoder_decoder")
     print(f"Model saved in path {save_path}")

Answer 2

可以将Keras模型保存为Keras的HDF5格式，请参见：

https://keras.io/getting-started/faq/#how-can-i-save-a-keras-model

您将希望执行以下操作：

import tf.keras
model = tf.keras.Model(blah blah)
model.save('my_model.h5')

如果迁移到TF2.0，则在tf.keras中构建模型并使用TF SavedModel格式进行部署会更加简单。本2.0教程展示了如何使用预先训练好的tf.keras模型，将模型保存为SavedModel格式，部署到云中，然后执行HTTP请求进行预测：

https://www.tensorflow.org/beta/guide/saved_model

Answer 3

我知道我来晚了一点，但我也遇到了同样的问题(更多细节请参见How do I save an encoder-decoder model with TensorFlow? )，并找到了解决方案。这是有点老生常谈，但它是有效的！

第1步-保存模型

保存您的令牌器(如果适用)。然后分别保存你用来训练数据的模型的权重(在这里命名你的层很有用)。

# Save the tokenizer
with open('tokenizer.pickle', 'wb') as handle:
    pickle.dump(tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)

# save the weights individually
for layer in model.layers:
    weights = layer.get_weights()
    if weights != []:
        np.savez(f'{layer.name}.npz', weights)

步骤2-重新加载权重

您需要重新加载记号赋予器(如果适用)，然后加载刚刚保存的权重。加载的权重是npz格式的，因此不能直接使用，但是非常简短的文档将告诉您关于此文件类型https://numpy.org/doc/stable/reference/generated/numpy.savez.html需要了解的所有内容

# load the tokenizer
with open('tokenizer.pickle', 'rb') as handle:
    tokenizer = pickle.load(handle)

# load the weights
w_encoder_embeddings = np.load('encoder_embeddings.npz', allow_pickle=True)
w_decoder_embeddings = np.load('decoder_embeddings.npz', allow_pickle=True)
w_encoder_lstm = np.load('encoder_lstm.npz', allow_pickle=True)
w_decoder_lstm = np.load('decoder_lstm.npz', allow_pickle=True)
w_dense = np.load('dense.npz', allow_pickle=True)

步骤3-重新创建训练模型并应用权重

您需要重新运行用于创建模型的代码。在我的例子中，这是：

encoder_inputs = Input(shape=(None,), name="encoder_inputs")
encoder_embeddings = Embedding(vocab_size, embedding_size, mask_zero=True, name="encoder_embeddings")(encoder_inputs)

# Encoder lstm
encoder_lstm = LSTM(512, return_state=True, name="encoder_lstm")
encoder_outputs, state_h, state_c = encoder_lstm(encoder_embeddings)

# 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,), name="decoder_inputs")

# target word embeddings
decoder_embeddings = Embedding(vocab_size, embedding_size, mask_zero=True, name="decoder_embeddings")
training_decoder_embeddings = decoder_embeddings(decoder_inputs)

# decoder lstm
decoder_lstm = LSTM(512, return_sequences=True, return_state=True, name="decoder_lstm")
decoder_outputs, _, _ = decoder_lstm(training_decoder_embeddings,
                                     initial_state=encoder_states)

decoder_dense = TimeDistributed(Dense(vocab_size, activation='softmax'), name="dense")
decoder_outputs = decoder_dense(decoder_outputs)

# While training, model takes input and traget words and outputs target strings
loaded_model = Model([encoder_inputs, decoder_inputs], decoder_outputs, name="training_model")

现在你可以将保存的权重应用于这些层了！这需要一点调查，哪个权重分配给哪个层，但通过命名您的层并使用model.layers检查您的模型层，这将变得容易得多。

# set the weights of the model

loaded_model.layers[2].set_weights(w_encoder_embeddings['arr_0'])
loaded_model.layers[3].set_weights(w_decoder_embeddings['arr_0'])
loaded_model.layers[4].set_weights(w_encoder_lstm['arr_0'])
loaded_model.layers[5].set_weights(w_decoder_lstm['arr_0'])
loaded_model.layers[6].set_weights(w_dense['arr_0'])

第4步-创建推理模型

最后，您现在可以基于此训练模型创建推理模型！同样，在我的例子中，这是：

encoder_model = Model(encoder_inputs, encoder_states)

# Redefine the decoder model with decoder will be getting below inputs from encoder while in prediction
decoder_state_input_h = Input(shape=(512,))
decoder_state_input_c = Input(shape=(512,))
decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]
inference_decoder_embeddings = decoder_embeddings(decoder_inputs)

decoder_outputs2, state_h2, state_c2 = decoder_lstm(inference_decoder_embeddings, initial_state=decoder_states_inputs)

decoder_states2 = [state_h2, state_c2]
decoder_outputs2 = decoder_dense(decoder_outputs2)

# sampling model will take encoder states and decoder_input(seed initially) and output the predictions(french word index) We dont care about decoder_states2
decoder_model = Model(
    [decoder_inputs] + decoder_states_inputs,
    [decoder_outputs2] + decoder_states2)

就是这样！现在，您可以使用以前训练过的模型进行推断！