在Tensorflow中训练模型后：

您如何保存经过训练的模型？
您以后如何还原此保存的模型？

#1楼

对于TensorFlow版本<0.11.0RC1：

保存的检查点包含模型中Variable的值，而不是模型/图形本身，这意味着在还原检查点时，图形应相同。

这是线性回归的示例，其中存在一个训练循环，该循环保存变量检查点，而评估部分将恢复先前运行中保存的变量并计算预测。当然，您也可以根据需要恢复变量并继续训练。

x = tf.placeholder(tf.float32)
y = tf.placeholder(tf.float32)w = tf.Variable(tf.zeros([1, 1], dtype=tf.float32))
b = tf.Variable(tf.ones([1, 1], dtype=tf.float32))
y_hat = tf.add(b, tf.matmul(x, w))...more setup for optimization and what not...saver = tf.train.Saver()  # defaults to saving all variables - in this case w and bwith tf.Session() as sess:sess.run(tf.initialize_all_variables())if FLAGS.train:for i in xrange(FLAGS.training_steps):...training loop...if (i + 1) % FLAGS.checkpoint_steps == 0:saver.save(sess, FLAGS.checkpoint_dir + 'model.ckpt',global_step=i+1)else:# Here's where you're restoring the variables w and b.# Note that the graph is exactly as it was when the variables were# saved in a prior training run.ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)if ckpt and ckpt.model_checkpoint_path:saver.restore(sess, ckpt.model_checkpoint_path)else:...no checkpoint found...# Now you can run the model to get predictionsbatch_x = ...load some data...predictions = sess.run(y_hat, feed_dict={x: batch_x})

这是Variable的文档，其中包括保存和还原。这是Saver的文档。

#2楼

模型分为两部分：模型定义（由Supervisor保存为模型目录中的graph.pbtxt和张量的数值（保存至诸如model.ckpt-1003418类的检查点文件中）。

可以使用tf.import_graph_def还原模型定义，并使用Saver还原权重。

但是， Saver使用了特殊的集合保存列表，该列表包含附加到模型Graph上的变量，并且此集合未使用import_graph_def初始化，因此您目前无法将两者一起使用（正在修复中）。现在，您必须使用Ryan Sepassi的方法-手动构造具有相同节点名称的图，然后使用Saver将权重加载到其中。

（或者，您可以使用import_graph_def ，手动创建变量，并对每个变量使用tf.add_to_collection(tf.GraphKeys.VARIABLES, variable) ，然后使用Saver来破解它）

#3楼

正如Yaroslav所说，您可以通过导入图形，手动创建变量然后使用Saver来从graph_def和检查点恢复。

我将其实现为个人使用，因此尽管我在这里共享了代码。

链接： https ： //gist.github.com/nikitakit/6ef3b72be67b86cb7868

（当然，这是黑客，不能保证以此方式保存的模型在TensorFlow的未来版本中仍可读取。）

#4楼

您还可以在TensorFlow / skflow中检出示例，该示例提供了save和restore方法，可帮助您轻松管理模型。它具有一些参数，您还可以控制备份模型的频率。

#5楼

如果是内部保存的模型，则只需为所有变量指定一个还原器即可

restorer = tf.train.Saver(tf.all_variables())

并使用它来还原当前会话中的变量：

restorer.restore(self._sess, model_file)

对于外部模型，您需要指定从其变量名到变量名的映射。您可以使用以下命令查看模型变量名称

python /path/to/tensorflow/tensorflow/python/tools/inspect_checkpoint.py --file_name=/path/to/pretrained_model/model.ckpt

可以在Tensorflow源的'./tensorflow/python/tools'文件夹中找到inspect_checkpoint.py脚本。

要指定映射，您可以使用我的Tensorflow-Worklab ，其中包含一组用于训练和重新训练不同模型的类和脚本。它包含一个重新训练ResNet模型的示例，位于此处

#6楼

在TensorFlow版本0.11.0RC1中（及之后），您可以根据https://www.tensorflow.org/programmers_guide/meta_graph调用tf.train.export_meta_graph和tf.train.import_meta_graph直接保存和恢复模型。

保存模型

w1 = tf.Variable(tf.truncated_normal(shape=[10]), name='w1')
w2 = tf.Variable(tf.truncated_normal(shape=[20]), name='w2')
tf.add_to_collection('vars', w1)
tf.add_to_collection('vars', w2)
saver = tf.train.Saver()
sess = tf.Session()
sess.run(tf.global_variables_initializer())
saver.save(sess, 'my-model')
# `save` method will call `export_meta_graph` implicitly.
# you will get saved graph files:my-model.meta

恢复模型

sess = tf.Session()
new_saver = tf.train.import_meta_graph('my-model.meta')
new_saver.restore(sess, tf.train.latest_checkpoint('./'))
all_vars = tf.get_collection('vars')
for v in all_vars:v_ = sess.run(v)print(v_)

#7楼

如问题6255中所述：

use '**./**model_name.ckpt'
saver.restore(sess,'./my_model_final.ckpt')

代替

saver.restore('my_model_final.ckpt')

#8楼

您也可以采用这种更简单的方法。

步骤1：初始化所有变量

W1 = tf.Variable(tf.truncated_normal([6, 6, 1, K], stddev=0.1), name="W1")
B1 = tf.Variable(tf.constant(0.1, tf.float32, [K]), name="B1")Similarly, W2, B2, W3, .....

步骤2：将会话保存在Model `Saver`并保存

model_saver = tf.train.Saver()# Train the model and save it in the end
model_saver.save(session, "saved_models/CNN_New.ckpt")

步骤3：还原模型

with tf.Session(graph=graph_cnn) as session:model_saver.restore(session, "saved_models/CNN_New.ckpt")print("Model restored.") print('Initialized')

第4步：检查您的变量

W1 = session.run(W1)
print(W1)

在其他python实例中运行时，请使用

with tf.Session() as sess:# Restore latest checkpointsaver.restore(sess, tf.train.latest_checkpoint('saved_model/.'))# Initalize the variablessess.run(tf.global_variables_initializer())# Get default graph (supply your custom graph if you have one)graph = tf.get_default_graph()# It will give tensor objectW1 = graph.get_tensor_by_name('W1:0')# To get the value (numpy array)W1_value = session.run(W1)

#9楼

在大多数情况下，使用tf.train.Saver从磁盘保存和还原是最佳选择：

... # build your model
saver = tf.train.Saver()with tf.Session() as sess:... # train the modelsaver.save(sess, "/tmp/my_great_model")with tf.Session() as sess:saver.restore(sess, "/tmp/my_great_model")... # use the model

您也可以保存/恢复图形结构本身（有关详细信息，请参见MetaGraph文档）。默认情况下， Saver将图形结构保存到.meta文件中。您可以调用import_meta_graph()进行还原。它还原图结构并返回一个Saver ，您可以使用该Saver还原模型的状态：

saver = tf.train.import_meta_graph("/tmp/my_great_model.meta")with tf.Session() as sess:saver.restore(sess, "/tmp/my_great_model")... # use the model

但是，在某些情况下，您需要更快的速度。例如，如果实施提前停止，则希望在训练过程中每次模型改进时都保存检查点（以验证集为准），然后如果一段时间没有进展，则希望回滚到最佳模型。如果您在每次改进时都将模型保存到磁盘，则会极大地减慢训练速度。诀窍是将变量状态保存到内存中 ，然后稍后再恢复它们：

... # build your model# get a handle on the graph nodes we need to save/restore the model
graph = tf.get_default_graph()
gvars = graph.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)
assign_ops = [graph.get_operation_by_name(v.op.name + "/Assign") for v in gvars]
init_values = [assign_op.inputs[1] for assign_op in assign_ops]with tf.Session() as sess:... # train the model# when needed, save the model state to memorygvars_state = sess.run(gvars)# when needed, restore the model statefeed_dict = {init_value: valfor init_value, val in zip(init_values, gvars_state)}sess.run(assign_ops, feed_dict=feed_dict)

快速说明：创建变量X ，TensorFlow自动创建一个赋值操作X/Assign来设置变量的初始值。与其创建占位符和额外的分配操作（这只会使图形混乱），我们仅使用这些现有的分配操作。每个赋值op的第一个输入是对应该初始化的变量的引用，第二个输入（ assign_op.inputs[1] ）是初始值。因此，为了设置所需的任何值（而不是初始值），我们需要使用feed_dict并替换初始值。是的，TensorFlow允许您为任何操作提供值，而不仅仅是占位符，因此可以正常工作。

#10楼

这是我针对两种基本情况的简单解决方案，不同之处在于您是要从文件中加载图形还是在运行时构建图形。

该答案适用于Tensorflow 0.12+（包括1.0）。

在代码中重建图形

保存

graph = ... # build the graph
saver = tf.train.Saver()  # create the saver after the graph
with ... as sess:  # your session objectsaver.save(sess, 'my-model')

载入中

graph = ... # build the graph
saver = tf.train.Saver()  # create the saver after the graph
with ... as sess:  # your session objectsaver.restore(sess, tf.train.latest_checkpoint('./'))# now you can use the graph, continue training or whatever

还从文件加载图形

使用此技术时，请确保所有图层/变量均已明确设置唯一名称。 否则，Tensorflow将使名称本身具有唯一性，因此它们将与文件中存储的名称不同。在以前的技术中这不是问题，因为在加载和保存时都以相同的方式“混合”了名称。

保存

graph = ... # build the graphfor op in [ ... ]:  # operators you want to use after restoring the modeltf.add_to_collection('ops_to_restore', op)saver = tf.train.Saver()  # create the saver after the graph
with ... as sess:  # your session objectsaver.save(sess, 'my-model')

载入中

with ... as sess:  # your session objectsaver = tf.train.import_meta_graph('my-model.meta')saver.restore(sess, tf.train.latest_checkpoint('./'))ops = tf.get_collection('ops_to_restore')  # here are your operators in the same order in which you saved them to the collection

#11楼

我正在改善我的答案，以添加更多有关保存和还原模型的详细信息。

在Tensorflow版本0.11中 （及之后）：

保存模型：

import tensorflow as tf#Prepare to feed input, i.e. feed_dict and placeholders
w1 = tf.placeholder("float", name="w1")
w2 = tf.placeholder("float", name="w2")
b1= tf.Variable(2.0,name="bias")
feed_dict ={w1:4,w2:8}#Define a test operation that we will restore
w3 = tf.add(w1,w2)
w4 = tf.multiply(w3,b1,name="op_to_restore")
sess = tf.Session()
sess.run(tf.global_variables_initializer())#Create a saver object which will save all the variables
saver = tf.train.Saver()#Run the operation by feeding input
print sess.run(w4,feed_dict)
#Prints 24 which is sum of (w1+w2)*b1 #Now, save the graph
saver.save(sess, 'my_test_model',global_step=1000)

还原模型：

import tensorflow as tfsess=tf.Session()
#First let's load meta graph and restore weights
saver = tf.train.import_meta_graph('my_test_model-1000.meta')
saver.restore(sess,tf.train.latest_checkpoint('./'))# Access saved Variables directly
print(sess.run('bias:0'))
# This will print 2, which is the value of bias that we saved# Now, let's access and create placeholders variables and
# create feed-dict to feed new datagraph = tf.get_default_graph()
w1 = graph.get_tensor_by_name("w1:0")
w2 = graph.get_tensor_by_name("w2:0")
feed_dict ={w1:13.0,w2:17.0}#Now, access the op that you want to run.
op_to_restore = graph.get_tensor_by_name("op_to_restore:0")print sess.run(op_to_restore,feed_dict)
#This will print 60 which is calculated

这里和一些更高级的用例已经很好地解释了。

快速完整的教程，用于保存和恢复Tensorflow模型

#12楼

如果您将tf.train.MonitoredTrainingSession用作默认会话，则无需添加额外的代码即可保存/还原内容。只需将检查点目录名传递给MonitoredTrainingSession的构造函数，它将使用会话挂钩来处理这些。

#13楼

这里的所有答案都很好，但我想补充两点。

首先，要详细说明@ user7505159的答案，将“ ./”添加到要还原的文件名的开头很重要。

例如，您可以保存一个图形，文件名中不包含“ ./”，如下所示：

# Some graph defined up here with specific namessaver = tf.train.Saver()
save_file = 'model.ckpt'with tf.Session() as sess:sess.run(tf.global_variables_initializer())saver.save(sess, save_file)

但是为了还原图形，您可能需要在file_name前面加上“ ./”：

# Same graph defined up heresaver = tf.train.Saver()
save_file = './' + 'model.ckpt' # String addition used for emphasiswith tf.Session() as sess:sess.run(tf.global_variables_initializer())saver.restore(sess, save_file)

您不一定总是需要“ ./”，但是根据您的环境和TensorFlow的版本，它可能会引起问题。

还需要提及的是，在恢复会话之前， sess.run(tf.global_variables_initializer())很重要。

如果在尝试还原保存的会话时收到关于未初始化变量的错误，请确保在saver.restore(sess, save_file)行之前包括sess.run(tf.global_variables_initializer()) 。它可以节省您的头痛。

#14楼

我的环境：Python 3.6，Tensorflow 1.3.0

尽管有很多解决方案，但是大多数解决方案都是基于tf.train.Saver 。当我们加载由Saver保存的.ckpt ，我们必须重新定义tensorflow网络或使用一些怪异而难以记住的名称，例如'placehold_0:0' ， 'dense/Adam/Weight:0' 。在这里，我建议使用tf.saved_model ，这是下面给出的一个最简单的示例，您可以从服务TensorFlow模型中了解更多信息：

保存模型：

import tensorflow as tf# define the tensorflow network and do some trains
x = tf.placeholder("float", name="x")
w = tf.Variable(2.0, name="w")
b = tf.Variable(0.0, name="bias")h = tf.multiply(x, w)
y = tf.add(h, b, name="y")
sess = tf.Session()
sess.run(tf.global_variables_initializer())# save the model
export_path =  './savedmodel'
builder = tf.saved_model.builder.SavedModelBuilder(export_path)tensor_info_x = tf.saved_model.utils.build_tensor_info(x)
tensor_info_y = tf.saved_model.utils.build_tensor_info(y)prediction_signature = (tf.saved_model.signature_def_utils.build_signature_def(inputs={'x_input': tensor_info_x},outputs={'y_output': tensor_info_y},method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME))builder.add_meta_graph_and_variables(sess, [tf.saved_model.tag_constants.SERVING],signature_def_map={tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY:prediction_signature },)
builder.save()

加载模型：

import tensorflow as tf
sess=tf.Session()
signature_key = tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY
input_key = 'x_input'
output_key = 'y_output'export_path =  './savedmodel'
meta_graph_def = tf.saved_model.loader.load(sess,[tf.saved_model.tag_constants.SERVING],export_path)
signature = meta_graph_def.signature_defx_tensor_name = signature[signature_key].inputs[input_key].name
y_tensor_name = signature[signature_key].outputs[output_key].namex = sess.graph.get_tensor_by_name(x_tensor_name)
y = sess.graph.get_tensor_by_name(y_tensor_name)y_out = sess.run(y, {x: 3.0})

#15楼

文件

他们构建了详尽且有用的教程-> https://www.tensorflow.org/guide/saved_model

从文档：

保存

# Create some variables.
v1 = tf.get_variable("v1", shape=[3], initializer = tf.zeros_initializer)
v2 = tf.get_variable("v2", shape=[5], initializer = tf.zeros_initializer)inc_v1 = v1.assign(v1+1)
dec_v2 = v2.assign(v2-1)# Add an op to initialize the variables.
init_op = tf.global_variables_initializer()# Add ops to save and restore all the variables.
saver = tf.train.Saver()# Later, launch the model, initialize the variables, do some work, and save the
# variables to disk.
with tf.Session() as sess:sess.run(init_op)# Do some work with the model.inc_v1.op.run()dec_v2.op.run()# Save the variables to disk.save_path = saver.save(sess, "/tmp/model.ckpt")print("Model saved in path: %s" % save_path)

恢复

tf.reset_default_graph()# Create some variables.
v1 = tf.get_variable("v1", shape=[3])
v2 = tf.get_variable("v2", shape=[5])# Add ops to save and restore all the variables.
saver = tf.train.Saver()# Later, launch the model, use the saver to restore variables from disk, and
# do some work with the model.
with tf.Session() as sess:# Restore variables from disk.saver.restore(sess, "/tmp/model.ckpt")print("Model restored.")# Check the values of the variablesprint("v1 : %s" % v1.eval())print("v2 : %s" % v2.eval())

Tensorflow 2

这仍然是beta版，因此我建议不要使用。如果您仍然想走这条路，这里是tf.saved_model使用指南

Tensorflow <2

`simple_save`

为了完整起见，我给出了很多好答案，我将添加2美分： simple_save 。也是使用tf.data.Dataset API的独立代码示例。

Python 3; Tensorflow 1.14

import tensorflow as tf
from tensorflow.saved_model import tag_constantswith tf.Graph().as_default():with tf.Session() as sess:...# Savinginputs = {"batch_size_placeholder": batch_size_placeholder,"features_placeholder": features_placeholder,"labels_placeholder": labels_placeholder,}outputs = {"prediction": model_output}tf.saved_model.simple_save(sess, 'path/to/your/location/', inputs, outputs)

恢复：

graph = tf.Graph()
with restored_graph.as_default():with tf.Session() as sess:tf.saved_model.loader.load(sess,[tag_constants.SERVING],'path/to/your/location/',)batch_size_placeholder = graph.get_tensor_by_name('batch_size_placeholder:0')features_placeholder = graph.get_tensor_by_name('features_placeholder:0')labels_placeholder = graph.get_tensor_by_name('labels_placeholder:0')prediction = restored_graph.get_tensor_by_name('dense/BiasAdd:0')sess.run(prediction, feed_dict={batch_size_placeholder: some_value,features_placeholder: some_other_value,labels_placeholder: another_value})

独立示例

原始博客文章

为了演示，以下代码生成随机数据。

我们首先创建占位符。它们将在运行时保存数据。根据它们，我们创建Dataset ，然后创建其Iterator 。我们得到迭代器生成的张量，称为input_tensor ，它将用作模型的输入。
该模型本身是由input_tensor构建的：基于GRU的双向RNN，后跟密集分类器。因为为什么不。
损失是softmax_cross_entropy_with_logits ，使用Adam优化。经过2个时期（每个批次2个批次）后，我们将tf.saved_model.simple_save保存为“训练过的”模型。如果按原样运行代码，则模型将保存在当前工作目录中名为simple/的文件夹中。
在新图中，然后使用tf.saved_model.loader.load恢复保存的模型。我们抢占位符和logits与graph.get_tensor_by_name和Iterator与初始化操作graph.get_operation_by_name 。
最后，我们对数据集中的两个批次进行推断，并检查保存和恢复的模型是否产生相同的值。他们是这样！

码：

import os
import shutil
import numpy as np
import tensorflow as tf
from tensorflow.python.saved_model import tag_constantsdef model(graph, input_tensor):"""Create the model which consists ofa bidirectional rnn (GRU(10)) followed by a dense classifierArgs:graph (tf.Graph): Tensors' graphinput_tensor (tf.Tensor): Tensor fed as input to the modelReturns:tf.Tensor: the model's output layer Tensor"""cell = tf.nn.rnn_cell.GRUCell(10)with graph.as_default():((fw_outputs, bw_outputs), (fw_state, bw_state)) = tf.nn.bidirectional_dynamic_rnn(cell_fw=cell,cell_bw=cell,inputs=input_tensor,sequence_length=[10] * 32,dtype=tf.float32,swap_memory=True,scope=None)outputs = tf.concat((fw_outputs, bw_outputs), 2)mean = tf.reduce_mean(outputs, axis=1)dense = tf.layers.dense(mean, 5, activation=None)return densedef get_opt_op(graph, logits, labels_tensor):"""Create optimization operation from model's logits and labelsArgs:graph (tf.Graph): Tensors' graphlogits (tf.Tensor): The model's output without activationlabels_tensor (tf.Tensor): Target labelsReturns:tf.Operation: the operation performing a stem of Adam optimizer"""with graph.as_default():with tf.variable_scope('loss'):loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels_tensor, name='xent'),name="mean-xent")with tf.variable_scope('optimizer'):opt_op = tf.train.AdamOptimizer(1e-2).minimize(loss)return opt_opif __name__ == '__main__':# Set random seed for reproducibility# and create synthetic datanp.random.seed(0)features = np.random.randn(64, 10, 30)labels = np.eye(5)[np.random.randint(0, 5, (64,))]graph1 = tf.Graph()with graph1.as_default():# Random seed for reproducibilitytf.set_random_seed(0)# Placeholdersbatch_size_ph = tf.placeholder(tf.int64, name='batch_size_ph')features_data_ph = tf.placeholder(tf.float32, [None, None, 30], 'features_data_ph')labels_data_ph = tf.placeholder(tf.int32, [None, 5], 'labels_data_ph')# Datasetdataset = tf.data.Dataset.from_tensor_slices((features_data_ph, labels_data_ph))dataset = dataset.batch(batch_size_ph)iterator = tf.data.Iterator.from_structure(dataset.output_types, dataset.output_shapes)dataset_init_op = iterator.make_initializer(dataset, name='dataset_init')input_tensor, labels_tensor = iterator.get_next()# Modellogits = model(graph1, input_tensor)# Optimizationopt_op = get_opt_op(graph1, logits, labels_tensor)with tf.Session(graph=graph1) as sess:# Initialize variablestf.global_variables_initializer().run(session=sess)for epoch in range(3):batch = 0# Initialize dataset (could feed epochs in Dataset.repeat(epochs))sess.run(dataset_init_op,feed_dict={features_data_ph: features,labels_data_ph: labels,batch_size_ph: 32})values = []while True:try:if epoch < 2:# Training_, value = sess.run([opt_op, logits])print('Epoch {}, batch {} | Sample value: {}'.format(epoch, batch, value[0]))batch += 1else:# Final inferencevalues.append(sess.run(logits))print('Epoch {}, batch {} | Final inference | Sample value: {}'.format(epoch, batch, values[-1][0]))batch += 1except tf.errors.OutOfRangeError:break# Save model stateprint('\nSaving...')cwd = os.getcwd()path = os.path.join(cwd, 'simple')shutil.rmtree(path, ignore_errors=True)inputs_dict = {"batch_size_ph": batch_size_ph,"features_data_ph": features_data_ph,"labels_data_ph": labels_data_ph}outputs_dict = {"logits": logits}tf.saved_model.simple_save(sess, path, inputs_dict, outputs_dict)print('Ok')# Restoringgraph2 = tf.Graph()with graph2.as_default():with tf.Session(graph=graph2) as sess:# Restore saved valuesprint('\nRestoring...')tf.saved_model.loader.load(sess,[tag_constants.SERVING],path)print('Ok')# Get restored placeholderslabels_data_ph = graph2.get_tensor_by_name('labels_data_ph:0')features_data_ph = graph2.get_tensor_by_name('features_data_ph:0')batch_size_ph = graph2.get_tensor_by_name('batch_size_ph:0')# Get restored model outputrestored_logits = graph2.get_tensor_by_name('dense/BiasAdd:0')# Get dataset initializing operationdataset_init_op = graph2.get_operation_by_name('dataset_init')# Initialize restored datasetsess.run(dataset_init_op,feed_dict={features_data_ph: features,labels_data_ph: labels,batch_size_ph: 32})# Compute inference for both batches in datasetrestored_values = []for i in range(2):restored_values.append(sess.run(restored_logits))print('Restored values: ', restored_values[i][0])# Check if original inference and restored inference are equalvalid = all((v == rv).all() for v, rv in zip(values, restored_values))print('\nInferences match: ', valid)

这将打印：

$ python3 save_and_restore.pyEpoch 0, batch 0 | Sample value: [-0.13851789 -0.3087595   0.12804556  0.20013677 -0.08229901]
Epoch 0, batch 1 | Sample value: [-0.00555491 -0.04339041 -0.05111827 -0.2480045  -0.00107776]
Epoch 1, batch 0 | Sample value: [-0.19321944 -0.2104792  -0.00602257  0.07465433  0.11674127]
Epoch 1, batch 1 | Sample value: [-0.05275984  0.05981954 -0.15913513 -0.3244143   0.10673307]
Epoch 2, batch 0 | Final inference | Sample value: [-0.26331693 -0.13013336 -0.12553    -0.04276478  0.2933622 ]
Epoch 2, batch 1 | Final inference | Sample value: [-0.07730117  0.11119192 -0.20817074 -0.35660955  0.16990358]Saving...
INFO:tensorflow:Assets added to graph.
INFO:tensorflow:No assets to write.
INFO:tensorflow:SavedModel written to: b'/some/path/simple/saved_model.pb'
OkRestoring...
INFO:tensorflow:Restoring parameters from b'/some/path/simple/variables/variables'
Ok
Restored values:  [-0.26331693 -0.13013336 -0.12553    -0.04276478  0.2933622 ]
Restored values:  [-0.07730117  0.11119192 -0.20817074 -0.35660955  0.16990358]Inferences match:  True

#16楼

使用tf.train.Saver保存模型，重命名，如果要减小模型大小，则需要指定var_list。 val_list可以是tf.trainable_variables或tf.global_variables。

#17楼

根据新的Tensorflow版本， tf.train.Checkpoint是保存和还原模型的首选方法：

Checkpoint.save和Checkpoint.restore写入和读取基于对象的检查点，而tf.train.Saver则可以写入和读取基于variable.name的检查点。基于对象的检查点保存带有命名边的Python对象（层，优化程序，变量等）之间的依存关系图，该图用于在恢复检查点时匹配变量。它对Python程序中的更改可能更健壮，并有助于在急切执行时支持变量的创建时恢复。 对于新代码， tf.train.Saver使用tf.train.Checkpoint不是tf.train.Saver 。

这是一个例子：

import tensorflow as tf
import ostf.enable_eager_execution()checkpoint_directory = "/tmp/training_checkpoints"
checkpoint_prefix = os.path.join(checkpoint_directory, "ckpt")checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=model)
status = checkpoint.restore(tf.train.latest_checkpoint(checkpoint_directory))
for _ in range(num_training_steps):optimizer.minimize( ... )  # Variables will be restored on creation.
status.assert_consumed()  # Optional sanity checks.
checkpoint.save(file_prefix=checkpoint_prefix)

更多信息和示例在这里。

#18楼

无论您要将模型保存到哪里，

self.saver = tf.train.Saver()
with tf.Session() as sess:sess.run(tf.global_variables_initializer())...self.saver.save(sess, filename)

确保您的所有tf.Variable都有名称，因为您以后可能要使用其名称来还原它们。在您想要预测的地方

saver = tf.train.import_meta_graph(filename)
name = 'name given when you saved the file'
with tf.Session() as sess:saver.restore(sess, name)print(sess.run('W1:0')) #example to retrieve by variable name

确保保护程序在相应的会话中运行。请记住，如果您使用tf.train.latest_checkpoint('./') ，那么将仅使用最新的检查点。

#19楼

您可以使用以下方法将变量保存到网络中

saver = tf.train.Saver()
saver.save(sess, 'path of save/fileName.ckpt')

要还原网络以供以后重复使用或在另一个脚本中使用，请使用：

saver = tf.train.Saver()
saver.restore(sess, tf.train.latest_checkpoint('path of save/')
sess.run(....)

要点：

在初次运行和后续运行之间（连续结构）， sess必须相同。
saver.restore需要已保存文件的文件夹路径，而不是单个文件路径。

#20楼

对于tensorflow 2.0 ，它很简单

 # Save the model model.save('path_to_my_model.h5')

恢复：

new_model = tensorflow.keras.models.load_model('path_to_my_model.h5')

#21楼

我正在使用版本：

tensorflow (1.13.1)
tensorflow-gpu (1.13.1)

简单的方法是

保存：

model.save("model.h5")

恢复：

model = tf.keras.models.load_model("model.h5")

#22楼

在新版本的tensorflow 2.0中，保存/加载模型的过程要容易得多。由于实施了Keras API，因此是TensorFlow的高级API。

保存模型：检查文档以供参考： https : //www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/models/save_model

tf.keras.models.save_model(model_name, filepath, save_format)

加载模型：

https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/models/load_model

model = tf.keras.models.load_model(filepath)

#23楼

tf.keras使用`TF2.0`保存模型

对于使用TF1.x保存模型，我看到了很好的答案。我想在保存tensorflow.keras模型时提供更多的指针，这有点复杂，因为有很多方法可以保存模型。

在这里，我提供一个将tensorflow.keras模型保存到当前目录下的model_path文件夹的示例。这与最新的tensorflow（TF2.0）一起很好地工作。如果近期有任何更改，我将更新此描述。

保存和加载整个模型

import tensorflow as tf
from tensorflow import keras
mnist = tf.keras.datasets.mnist#import data
(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0# create a model
def create_model():model = tf.keras.models.Sequential([tf.keras.layers.Flatten(input_shape=(28, 28)),tf.keras.layers.Dense(512, activation=tf.nn.relu),tf.keras.layers.Dropout(0.2),tf.keras.layers.Dense(10, activation=tf.nn.softmax)])
# compile the modelmodel.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])return model# Create a basic model instance
model=create_model()model.fit(x_train, y_train, epochs=1)
loss, acc = model.evaluate(x_test, y_test,verbose=1)
print("Original model, accuracy: {:5.2f}%".format(100*acc))# Save entire model to a HDF5 file
model.save('./model_path/my_model.h5')# Recreate the exact same model, including weights and optimizer.
new_model = keras.models.load_model('./model_path/my_model.h5')
loss, acc = new_model.evaluate(x_test, y_test)
print("Restored model, accuracy: {:5.2f}%".format(100*acc))

仅保存和加载模型权重

如果您只想保存模型权重，然后再加载权重以恢复模型，那么，

model.fit(x_train, y_train, epochs=5)
loss, acc = model.evaluate(x_test, y_test,verbose=1)
print("Original model, accuracy: {:5.2f}%".format(100*acc))# Save the weights
model.save_weights('./checkpoints/my_checkpoint')# Restore the weights
model = create_model()
model.load_weights('./checkpoints/my_checkpoint')loss,acc = model.evaluate(x_test, y_test)
print("Restored model, accuracy: {:5.2f}%".format(100*acc))

使用keras检查点回调进行保存和还原

# include the epoch in the file name. (uses `str.format`)
checkpoint_path = "training_2/cp-{epoch:04d}.ckpt"
checkpoint_dir = os.path.dirname(checkpoint_path)cp_callback = tf.keras.callbacks.ModelCheckpoint(checkpoint_path, verbose=1, save_weights_only=True,# Save weights, every 5-epochs.period=5)model = create_model()
model.save_weights(checkpoint_path.format(epoch=0))
model.fit(train_images, train_labels,epochs = 50, callbacks = [cp_callback],validation_data = (test_images,test_labels),verbose=0)latest = tf.train.latest_checkpoint(checkpoint_dir)new_model = create_model()
new_model.load_weights(latest)
loss, acc = new_model.evaluate(test_images, test_labels)
print("Restored model, accuracy: {:5.2f}%".format(100*acc))

使用自定义指标保存模型

import tensorflow as tf
from tensorflow import keras
mnist = tf.keras.datasets.mnist(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0# Custom Loss1 (for example)
@tf.function()
def customLoss1(yTrue,yPred):return tf.reduce_mean(yTrue-yPred) # Custom Loss2 (for example)
@tf.function()
def customLoss2(yTrue, yPred):return tf.reduce_mean(tf.square(tf.subtract(yTrue,yPred))) def create_model():model = tf.keras.models.Sequential([tf.keras.layers.Flatten(input_shape=(28, 28)),tf.keras.layers.Dense(512, activation=tf.nn.relu),  tf.keras.layers.Dropout(0.2),tf.keras.layers.Dense(10, activation=tf.nn.softmax)])model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy', customLoss1, customLoss2])return model# Create a basic model instance
model=create_model()# Fit and evaluate model
model.fit(x_train, y_train, epochs=1)
loss, acc,loss1, loss2 = model.evaluate(x_test, y_test,verbose=1)
print("Original model, accuracy: {:5.2f}%".format(100*acc))model.save("./model.h5")new_model=tf.keras.models.load_model("./model.h5",custom_objects={'customLoss1':customLoss1,'customLoss2':customLoss2})

使用自定义操作保存Keras模型

在以下情况下（ tf.tile ）具有自定义操作时，我们需要创建一个函数并包装一个Lambda层。否则，无法保存模型。

import numpy as np
import tensorflow as tf
from tensorflow.keras.layers import Input, Lambda
from tensorflow.keras import Modeldef my_fun(a):out = tf.tile(a, (1, tf.shape(a)[0]))return outa = Input(shape=(10,))
#out = tf.tile(a, (1, tf.shape(a)[0]))
out = Lambda(lambda x : my_fun(x))(a)
model = Model(a, out)x = np.zeros((50,10), dtype=np.float32)
print(model(x).numpy())model.save('my_model.h5')#load the model
new_model=tf.keras.models.load_model("my_model.h5")

我想我已经介绍了许多保存tf.keras模型的方法。但是，还有许多其他方法。如果您发现上面没有涉及用例，请在下面发表评论。谢谢！

#24楼

遵循@Vishnuvardhan Janapati的回答，这是在TensorFlow 2.0.0下使用自定义图层/度量/损耗来保存和重新加载模型的另一种方法

import tensorflow as tf
from tensorflow.keras.layers import Layer
from tensorflow.keras.utils.generic_utils import get_custom_objects# custom loss (for example)
def custom_loss(y_true,y_pred):return tf.reduce_mean(y_true - y_pred)
get_custom_objects().update({'custom_loss': custom_loss}) # custom loss (for example)
class CustomLayer(Layer):def __init__(self, ...):...# define custom layer and all necessary custom operations inside custom layerget_custom_objects().update({'CustomLayer': CustomLayer})

这样，一旦执行了此类代码，并使用tf.keras.models.save_model或model.save或ModelCheckpoint回调保存了模型，就可以重新加载模型，而无需精确的自定义对象，就像

new_model = tf.keras.models.load_model("./model.h5"})

#25楼

对于tensorflow-2.0

这很简单。

import tensorflow as tf

保存

model.save("model_name")

恢复

model = tf.keras.models.load_model('model_name')

Tensorflow：如何保存/恢复模型？相关推荐

Tensorflow |（5）模型保存与恢复、自定义命令行参数
Tensorflow |(1)初识Tensorflow Tensorflow |(2)张量的阶和数据类型及张量操作 Tensorflow |(3)变量的的创建.初始化.保存和加载 Tensorflow ...
Tensorflow：TF模型文件(checkpoint文件夹下ckpt文件之data、index、meta)保存、模型导入、恢复并fine-tuning之详细攻略
Tensorflow:TF模型文件(checkpoint文件夹下ckpt文件之data.index.meta)保存.模型导入.恢复并fine-tuning之详细攻略目录保存TF训练好的模型 1.T ...
Tensorflow保存模型，恢复模型
tensorflow从已经训练好的模型中,恢复(指定)权重(构建新变量.网络)并继续训练(finetuning) https://blog.csdn.net/ying86615791/article/ ...
tensorflow保存和恢复模型saver.restore
1.本文只对一些细节点做补充,大体的步骤就不详述了 2.保存模型 ① 首先我使用的是tensorflow-gpu 1.4.0 ② 这个版本生成的ckpt文件是这样的: 其中.meta存放的是网络模型和 ...
Tensorflow深度学习实战之(五)--保存与恢复模型
文章目录一.保存模型二.恢复模型三.使用模型预测一.保存模型在训练完Tensorflow模型为了方便对新的数据进行预测需要保存该模型,Tensorflow提供 tf.train.Saver( ...
TensorFlow保存和恢复模型的方法总结
使用TensorFlow训练模型的过程中,需要适时对模型进行保存,以及对保存的模型进行restore,以方便后续对模型进行处理.比如进行测试,或者部署:比如拿别的模型进行fine-tune,等等.当然 ...
TensorFlow2 -官方教程 :保存和恢复模型
文章目录准备工作:安装,导入,获取数据集,定义model 在训练期间保存模型(以 checkpoints 形式保存) Checkpoint 回调用法 checkpoint 回调选项这些文件是什么? ...
tensorflow tf.train.Saver.restore() （用于下次训练时恢复模型）
# 保存当前的Session到文件目录tf.train.Saver().save(sess, 'net/my_net.ckpt') # 然后在下次训练时恢复模型: tf.train.Saver().r ...
tensorflow随笔-保存与读取使用模型
1.MNIST是深度学习的经典入门demo,他是由6万张训练图片和1万张测试图片构成的,每张图片都是2828大小(如下图),而且都是黑白色构成(这里的黑色是一个0-1的浮点数,黑色越深表示数值越靠近1 ...

Tensorflow：如何保存/恢复模型？

#1楼

#2楼

#3楼

#4楼

#5楼

#6楼