TensorFlow 模型保存与加载
TensorFlow中总共有两种保存和加载模型的方法。第一种是利用 tf.train.Saver() 来保存，第二种就是利用 SavedModel 来保存模型，接下来以自己项目中的代码为例。
项目中模型的代码：
class TensorFlowDKT(object):
def __init__(self, config, batch_size):
# 导入配置好的参数
self.hiddens = hiddens = config.modelConfig.hidden_layers
self.num_skills = num_skills = config.num_skills
self.input_size = input_size = config.input_size
self.keep_prob_value = config.modelConfig.dropout_keep_prob # 定义需要喂给模型的参数
self.max_steps = tf.placeholder(tf.int32, name="max_steps") # 当前batch中最大序列长度
self.input_data = tf.placeholder(tf.float32, [None, None, input_size], name="input_x") self.sequence_len = tf.placeholder(tf.int32, [None], name="sequence_len")
self.keep_prob = tf.placeholder(tf.float32, name="keep_prob") # dropout keep prob self.target_id = tf.placeholder(tf.int32, [None, None], name="target_id")
self.target_correctness = tf.placeholder(tf.float32, [None, None], name="target_correctness")
self.flat_target_correctness = None
self.batch_size = tf.placeholder(tf.int32, name="batch_size") # 构建lstm模型结构
hidden_layers = []
for idx, hidden_size in enumerate(hiddens):
lstm_layer = tf.nn.rnn_cell.LSTMCell(num_units=hidden_size, state_is_tuple=True)
hidden_layer = tf.nn.rnn_cell.DropoutWrapper(cell=lstm_layer,
output_keep_prob=self.keep_prob)
hidden_layers.append(hidden_layer)
self.hidden_cell = tf.nn.rnn_cell.MultiRNNCell(cells=hidden_layers, state_is_tuple=True) # 采用动态rnn，动态输入序列的长度
outputs, self.current_state = tf.nn.dynamic_rnn(cell=self.hidden_cell,
inputs=self.input_data,
sequence_length=self.sequence_len,
dtype=tf.float32) # 隐层到输出层的权重系数[最后隐层的神经元数量，知识点数]
output_w = tf.get_variable("W", [hiddens[-1], num_skills])
output_b = tf.get_variable("b", [num_skills]) self.output = tf.reshape(outputs, [-1, hiddens[-1]])
# 因为权值共享的原因，对生成的矩阵[batch_size * self.max_steps, num_skills]中的每一行都加上b
self.logits = tf.matmul(self.output, output_w) + output_b self.mat_logits = tf.reshape(self.logits, [-1, self.max_steps, num_skills]) # 对每个batch中每个序列中的每个时间点的输出中的每个值进行sigmoid计算，这里的值表示对某个知识点的掌握情况，
# 每个时间点都会输出对所有知识点的掌握情况
self.pred_all = tf.sigmoid(self.mat_logits, name="pred_all") # 计算损失loss
flat_logits = tf.reshape(self.logits, [-1]) flat_target_correctness = tf.reshape(self.target_correctness, [-1])
self.flat_target_correctness = flat_target_correctness flat_base_target_index = tf.range(self.batch_size * self.max_steps) * num_skills # 因为flat_logits的长度为batch_size * num_steps * num_skills，我们要根据每一步的target_id将其长度变成batch_size * num_steps
flat_base_target_id = tf.reshape(self.target_id, [-1]) flat_target_id = flat_base_target_id + flat_base_target_index
# gather是从一个tensor中切片一个子集
flat_target_logits = tf.gather(flat_logits, flat_target_id) # 对切片后的数据进行sigmoid转换
self.pred = tf.sigmoid(tf.reshape(flat_target_logits, [-1, self.max_steps]), name="pred")
# 将sigmoid后的值表示为0或1
self.binary_pred = tf.cast(tf.greater_equal(self.pred, 0.5), tf.float32, name="binary_pred") # 定义损失函数
with tf.name_scope("loss"):
# flat_target_logits_sigmoid = tf.nn.log_softmax(flat_target_logits)
# self.loss = -tf.reduce_mean(flat_target_correctness * flat_target_logits_sigmoid)
self.loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=flat_target_correctness,
logits=flat_target_logits))
在之后的预测时，我需要输入的参数有 input_data，max_steps，sequence_len，keep_prob，target_id，batch_size。输出的值有pred_all。
首先来看第一种模型保存的方法：
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1.0)
session_conf = tf.ConfigProto(
allow_soft_placement=True,
log_device_placement=False,
gpu_options=gpu_options
)
sess = tf.Session(config=session_conf)
...... saver = tf.train.Saver(tf.global_variables())
sess.run(tf.global_variables_initializer()) print("初始化完毕，开始训练")
for i in range(config.trainConfig.epochs):
np.random.shuffle(train_seqs)
for params in dataGen.next_batch(train_seqs):
# 批次获得训练集，训练模型
self.train_step(params, train_op) current_step = tf.train.global_step(sess, global_step)
# train_step.run(feed_dict={x: batch_train[0], y_actual: batch_train[1], keep_prob: 0.5})
# 对结果进行记录
if current_step % config.trainConfig.evaluate_every == 0:
print("\nEvaluation:")
# 获得测试数据 losses = []
accuracys = []
aucs = []
for params in dataGen.next_batch(test_seqs):
loss, accuracy, auc = self.dev_step(params)
losses.append(loss)
accuracys.append(accuracy)
aucs.append(auc) time_str = datetime.datetime.now().isoformat()
print("dev: {}, step: {}, loss: {}, acc: {}, auc: {}".
format(time_str, current_step, mean(losses), mean(accuracys), mean(aucs))) if current_step % config.trainConfig.checkpoint_every == 0:
path = saver.save(sess, "model/my-model", global_step=current_step)
print("Saved model checkpoint to {}\n".format(path))
利用 tf.train.Saver() 保存模型非常简单，就只要上述代码中标红的两句就行了。
模型加载的代码：
graph = tf.Graph()
with graph.as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)
session_conf = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False, gpu_options=gpu_options)
sess = tf.Session(config=session_conf) with sess.as_default():
checkpoint_file = tf.train.latest_checkpoint("model/")
saver = tf.train.import_meta_graph("{}.meta".format(checkpoint_file))
saver.restore(sess, checkpoint_file) # 获得需要喂给模型的参数，输出的结果依赖的输入值
input_x = graph.get_operation_by_name("test/dkt/input_x").outputs[0]
target_id = graph.get_operation_by_name("test/dkt/target_id").outputs[0]
keep_prob = graph.get_operation_by_name("test/dkt/keep_prob").outputs[0]
max_steps = graph.get_operation_by_name("test/dkt/max_steps").outputs[0]
sequence_len = graph.get_operation_by_name("test/dkt/sequence_len").outputs[0]
batch_size = graph.get_operation_by_name("test/dkt/batch_size").outputs[0] # 获得输出的结果
pred_all = graph.get_tensor_by_name("test/dkt/pred_all:0") for params in dataGen.next_batch(train_seqs):
print("step: {}".format(step)) target_correctness = params['target_correctness'] pred_all_1 = sess.run([pred_all], feed_dict={input_x: params["input_x"],
target_id: params["target_id"],
keep_prob: 1.0,
max_steps: params["max_len"],
sequence_len: params["seq_len"],
batch_size: len(params["seq_len"])})
print(params["seq_len"])
sequence_lens.append(params["seq_len"])
studentSkillMasterProbs.append(pred_all_1)
studentTargetId.append(params["target_id"])
studentTargetCorrectness.append(params["target_correctness"])
加载模型时要把我们需要的输入参数和输出结果的 tensor 读出来，利用get_tensor_by_name() 的方法，方法中需要传入tensor 的名称，所以在定义模型类时需要为这些 tensor 指定 name 参数。之后就是直接 sess.run() 去运行模型进行预测。
这种方法会保存四个文件 xxx.checkpoint，xxx.index，xxx.meta和 xxx.data_00000_of_00001
第二种模型保存的方法：
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1.0)
session_conf = tf.ConfigProto(
allow_soft_placement=True,
log_device_placement=False,
gpu_options=gpu_options
)
sess = tf.Session(config=session_conf)
self.sess = sess with sess.as_default():
# 实例化dkt模型对象
...... builder = tf.saved_model.builder.SavedModelBuilder("./builder") sess.run(tf.global_variables_initializer()) print("初始化完毕，开始训练")
for i in range(config.trainConfig.epochs):
...... inputs = {"input_x": tf.saved_model.utils.build_tensor_info(self.train_dkt.input_data),
"target_id": tf.saved_model.utils.build_tensor_info(self.train_dkt.target_id),
"max_steps": tf.saved_model.utils.build_tensor_info(self.train_dkt.max_steps),
"sequence_len": tf.saved_model.utils.build_tensor_info(self.train_dkt.sequence_len),
"keep_prob": tf.saved_model.utils.build_tensor_info(self.train_dkt.keep_prob),
"batch_size": tf.saved_model.utils.build_tensor_info(self.train_dkt.batch_size)} outputs = {"pred_all": tf.saved_model.utils.build_tensor_info(self.train_dkt.pred_all)} prediction_signature = tf.saved_model.signature_def_utils.build_signature_def(inputs=inputs, outputs=outputs,
method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME)
legacy_init_op = tf.group(tf.tables_initializer(), name="legacy_init_op")
builder.add_meta_graph_and_variables(sess, [tf.saved_model.tag_constants.SERVING],
signature_def_map={"predict": prediction_signature}, legacy_init_op=legacy_init_op) builder.save()
利用 saved_model 也可以把整个模型中的变量全部保存起来，但更一般的形式是指定 输入参数和输出结果来进行保存，而且除了可以保存predict之外，还可以保存training，classify等等。
模型加载的代码：
graph = tf.Graph()
with graph.as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)
session_conf = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False, gpu_options=gpu_options)
sess = tf.Session(config=session_conf) signature_key = "predict" # 这里的值是要和保存模型中的 builder.add_meta_graph_and_variables（）方法里面的 signature_def_map={"predict": prediction_signature} 对应上的。
with tf.Session(graph=graph) as sess:
meta_graph_def = tf.saved_model.loader.load(sess, [tf.saved_model.tag_constants.SERVING], "./builder")
signature = meta_graph_def.signature_def
input_x = sess.graph.get_tensor_by_name(signature[signature_key].inputs["input_x"].name)
keep_prob = sess.graph.get_tensor_by_name(signature[signature_key].inputs["keep_prob"].name)
target_id = sess.graph.get_tensor_by_name(signature[signature_key].inputs["target_id"].name)
max_steps = sess.graph.get_tensor_by_name(signature[signature_key].inputs["max_steps"].name)
sequence_len = sess.graph.get_tensor_by_name(signature[signature_key].inputs["sequence_len"].name)
batch_size = sess.graph.get_tensor_by_name(signature[signature_key].inputs["batch_size"].name) pred_all = sess.graph.get_tensor_by_name(signature[signature_key].outputs["pred_all"].name)
for params in dataGen.next_batch(train_seqs):
print("step: {}".format(step)) target_correctness = params['target_correctness'] pred_all_1 = sess.run([pred_all], feed_dict={input_x: params["input_x"],
target_id: params["target_id"],
keep_prob: 1.0,
max_steps: params["max_len"],
sequence_len: params["seq_len"],
batch_size: len(params["seq_len"])})
print(params["seq_len"])
sequence_lens.append(params["seq_len"])
studentSkillMasterProbs.append(pred_all_1)
studentTargetId.append(params["target_id"])
studentTargetCorrectness.append(params["target_correctness"]) step += 1
模型加载和 tf.train.Saver() 保存的模型差不多，不过不需要指定在模型图中的全名。
这种方法会保存一个文件 xxx.pb 和一个文件夹 variables，variables中有两个文件 variables.data_00000_of_00001（数字可能会有所不同，不确定）和variables.index。
TensorFlow serving 服务布署
利用上面第二种保存的模型可以构建TensorFlow serving 服务，具体的是利用docker来构建TensorFlow serving 的服务端。然后在客户端通过grpc来连接。整个步骤如下：
服务器系统：Ubuntu16.04
1，安装docker-ce
具体的安装流程见官网
2，拉取官方的TensorFlow serving 仓库，可以直接拉取最新版的，也可以自己选择版本
docker pull tensorflow/serving:latest-devel
3，启动容器，选择grpc的端口
docker run -p 8500:8500 --name grpc -it tensorflow/serving:latest-devel
8500端口：grpc的端口
8501端口：restful api的端口
除了grpc调用服务，也可以用restful api调用服务
4，将自己的model文件复制到容器中
本地模型路径：~/builder/00000123 。模型名称为builder，00000123为版本号（必须需要），00000123文件夹下面就是xxx.pb 文件和variables文件夹
docker cp ~/model grpc:/online_model 。grpc 是我们的容器名称，将本地的模型copy到容器中的根路径下的online_model文件夹下
5，在docker中启动TensorFlow serving服务
进入到容器中：docker exec -it grpc bash
启动TensorFlow serving服务：tensorflow_model_server --port=8500 --model_name=builder --model_base_path=/online_model/builder/
这样服务端的TensorFlow serving就启动了
6，客户端代码
import grpc
import numpy as np
import tensorflow as tf
from tensorflow_serving.apis import predict_pb2
from tensorflow_serving.apis import prediction_service_pb2_grpc
from tensorflow_serving.apis import prediction_service_pb2
from grpc.beta import implementations dataGen = DataGenerator(fileName, config) # 数据预处理的类
dataGen.gen_attr()
test_seqs = dataGen.test_seqs
params = dataGen.format_data(test_seqs)
input_x = params["input_x"][:1]
max_steps = params["max_len"]
batch_size = 1
keep_prob = 1.0
target_id = params["target_id"][:1]
sequence_len = params["seq_len"][:1] # 利用grpc 进行连接
channel = implementations.insecure_channel("192.168.39.39", 8500)
stub = prediction_service_pb2.beta_create_PredictionService_stub(channel)
request = predict_pb2.PredictRequest()
# 模型的名称
request.model_spec.name = "builder"
# 签名的名称
request.model_spec.signature_name = "predict" # 每次只支持传入一条数据进行预测，传入数据时要注意数据格式和模型定义时的格式一致
request.inputs['input_x'].CopyFrom(tf.contrib.util.make_tensor_proto(input_x, dtype=tf.float32, shape=[input_x.shape[0], input_x.shape[1], input_x.shape[2]]))
request.inputs['target_id'].CopyFrom(tf.contrib.util.make_tensor_proto(target_id, dtype=tf.int32, shape=[target_id.shape[0], target_id.shape[1]]))
request.inputs['max_steps'].CopyFrom(tf.contrib.util.make_tensor_proto(max_steps, dtype=tf.int32))
request.inputs['keep_prob'].CopyFrom(tf.contrib.util.make_tensor_proto(keep_prob, dtype=tf.float32))
request.inputs["sequence_len"].CopyFrom(tf.contrib.util.make_tensor_proto(sequence_len, dtype=tf.int32, shape=[1]))
request.inputs["batch_size"].CopyFrom(tf.contrib.util.make_tensor_proto(batch_size, dtype=tf.int32)) # response返回的是protobuff的格式
response = stub.Predict.future(request) # 去除预测的数值，对于many to many 的LSTM，输出的结果是多个，读取成列表的形式
res_list = response.result().outputs["pred_all"].float_val
利用TensorFlow serving搭建服务的具体流程就这么些，另外还支持gpu版的TensorFlow serving。但是需要安装nvidia-docker ，还需要启动nvidia-container-runtime等，总之很复杂，对于NLP中的任务，预测时用CPU也是完全可以的。