Tensorflow: как сохранить/восстановить модель?
после обучения модели в Tensorflow:
- как вы сохраняете обученную модель?
- как вы позже восстановить сохраненную модель?
16 ответов
новый и более короткий путь: simple_save
много хорошего ответа, для полноты добавлю свои 2 цента:simple_save. Также пример автономного кода с использованием tf.data.Dataset
API-интерфейс.
Python 3; Tensorflow 1.7
import tensorflow as tf
from tensorflow.python.saved_model import tag_constants
with tf.Graph().as_default():
with tf.Session as sess:
...
# Saving
inputs = {
"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
. Мы хватаем заполнители и логиты с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_constants
def model(graph, input_tensor):
"""Create the model which consists of
a bidirectional rnn (GRU(10)) followed by a dense classifier
Args:
graph (tf.Graph): Tensors' graph
input_tensor (tf.Tensor): Tensor fed as input to the model
Returns:
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 dense
def get_opt_op(graph, logits, labels_tensor):
"""Create optimization operation from model's logits and labels
Args:
graph (tf.Graph): Tensors' graph
logits (tf.Tensor): The model's output without activation
labels_tensor (tf.Tensor): Target labels
Returns:
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_op
if __name__ == '__main__':
# Set random seed for reproducibility
# and create synthetic data
np.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 reproducibility
tf.set_random_seed(0)
# Placeholders
batch_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')
# Dataset
dataset = 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()
# Model
logits = model(graph1, input_tensor)
# Optimization
opt_op = get_opt_op(graph1, logits, labels_tensor)
with tf.Session(graph=graph1) as sess:
# Initialize variables
tf.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 += 1
else:
# Final inference
values.append(sess.run(logits))
print('Epoch {}, batch {} | Final inference | Sample value: {}'.format(epoch, batch, values[-1][0]))
batch += 1
except tf.errors.OutOfRangeError:
break
# Save model state
print('\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')
# Restoring
graph2 = tf.Graph()
with graph2.as_default():
with tf.Session(graph=graph2) as sess:
# Restore saved values
print('\nRestoring...')
tf.saved_model.loader.load(
sess,
[tag_constants.SERVING],
path
)
print('Ok')
# Get restored placeholders
labels_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 output
restored_logits = graph2.get_tensor_by_name('dense/BiasAdd:0')
# Get dataset initializing operation
dataset_init_op = graph2.get_operation_by_name('dataset_init')
# Initialize restored dataset
sess.run(
dataset_init_op,
feed_dict={
features_data_ph: features,
labels_data_ph: labels,
batch_size_ph: 32
}
)
# Compute inference for both batches in dataset
restored_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 equal
valid = all((v == rv).all() for v, rv in zip(values, restored_values))
print('\nInferences match: ', valid)
это будет печатать:
$ python3 save_and_restore.py
Epoch 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'
Ok
Restoring...
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
я улучшаю свой ответ, чтобы добавить больше деталей для сохранения и восстановления моделей.
В(и после) 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 tf
sess=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 data
graph = 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
В (и после) TensorFlow версии 0.11.0RC1, вы можете сохранить и восстановить модель напрямую, позвонив tf.train.export_meta_graph
и tf.train.import_meta_graph
согласно https://www.tensorflow.org/programmers_guide/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_)
для версии TensorFlow
сохраненные контрольные точки содержат значения для Variable
s в вашей модели, а не сама модель/график, что означает, что график должен быть одинаковым при восстановлении контрольной точки.
вот пример линейной регрессии, где есть цикл обучения, который сохраняет контрольные точки переменных и раздел оценки, который восстановит переменные, сохраненные в предыдущем запуске, и вычислит прогнозы. Конечно, вы также можете восстановите переменные и продолжите обучение, если хотите.
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 b
with 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 predictions
batch_x = ...load some data...
predictions = sess.run(y_hat, feed_dict={x: batch_x})
здесь docs на Variable
s, которые охватывают сохранение и восстановление. А вот и docs на Saver
.
в модели есть две части, определение модели, сохраненное Supervisor
as graph.pbtxt
в каталоге модели и числовые значения тензоров, сохраненные в файлах контрольных точек, таких как model.ckpt-1003418
.
определение модели может быть восстановлено с помощью tf.import_graph_def
, и веса восстанавливаются с помощью Saver
.
однако, Saver
использует специальный список хранения коллекции переменных, прикрепленных к графу модели, и эта коллекция не инициализируется с помощью import_graph_def, поэтому вы не можете использовать их вместе на данный момент (это на нашей Дорожной карте, чтобы исправить). Теперь вам нужно использовать подход Райана Сепасси -- вручную построить график с идентичными именами узлов и использовать Saver
для загрузки весов в это.
(кроме того, вы можете взломать его с помощью import_graph_def
, создание переменных вручную и использование tf.add_to_collection(tf.GraphKeys.VARIABLES, variable)
для каждой переменной, а затем использовать Saver
)
моя среда: Python 3.6, Tensorflow 1.3.0
хотя было много решений, большинство из них основано на tf.train.Saver
. Когда мы загружаем .ckpt
спас Saver
, мы должны либо переопределить сеть 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_def
x_tensor_name = signature[signature_key].inputs[input_key].name
y_tensor_name = signature[signature_key].outputs[output_key].name
x = 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})
вы также можете принять этот более простой способ.
Шаг 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: сохраните сеанс внутри модели 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 checkpoint
saver.restore(sess, tf.train.latest_checkpoint('saved_model/.'))
# Initalize the variables
sess.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 object
W1 = graph.get_tensor_by_name('W1:0')
# To get the value (numpy array)
W1_value = session.run(W1)
в большинстве случаев, сохранение и восстановление с диска с помощью tf.train.Saver
- Это ваш лучший вариант:
... # build your model
saver = tf.train.Saver()
with tf.Session() as sess:
... # train the model
saver.save(sess, "/tmp/my_great_model")
with tf.Session() as sess:
saver.restore(sess, "/tmp/my_great_model")
... # use the model
вы также можете сохранить/восстановить саму структуру графа (см. Метаграфа документации для деталей). По умолчанию Saver
сохраняет структуру графика в . Вы можете позвонить import_meta_graph()
восстановить его. Он восстанавливает структуру графа и возвращает 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 memory
gvars_state = sess.run(gvars)
# when needed, restore the model state
feed_dict = {init_value: val
for 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 позволяет подавать значение для любого op, а не только для заполнителей, поэтому это работает нормально.
Как сказал Ярослав, вы можете взломать восстановление из graph_def и checkpoint, импортировав график, вручную создав переменные, а затем используя Saver.
я реализовал это для личного использования, поэтому я бы поделился кодом здесь.
ссылка:https://gist.github.com/nikitakit/6ef3b72be67b86cb7868
(Это, конечно, Хак, и нет никакой гарантии, что модели, сохраненные таким образом, останутся читаемыми в будущих версиях TensorFlow.)
Если это внутренне сохраненная модель, вы просто указываете реставратор для всех переменных как
restorer = tf.train.Saver(tf.all_variables())
и используйте его для восстановления переменных в текущем сеансе:
restorer.restore(self._sess, model_file)
для внешней модели вам нужно указать сопоставление имен переменных its с именами ваших переменных. Имена переменных модели можно просмотреть с помощью команды
python /path/to/tensorflow/tensorflow/python/tools/inspect_checkpoint.py --file_name=/path/to/pretrained_model/model.ckpt
inspect_checkpoint.py скрипт можно найти в './TensorFlow / python / папка инструментов Tensorflow источник.
чтобы указать отображение, вы можете использовать my Tensorflow-Worklab, который содержит набор классов и скриптов для обучения и переподготовки различных моделей. Он включает в себя пример переподготовки моделей ResNet, расположенных здесь
вот мое простое решение для двух основных случаев, отличающихся от того, хотите ли вы загрузить график из файла или построить его во время выполнения.
этот ответ справедлив для Tensorflow 0.12+ (включая 1.0).
восстановление графика в коде
экономия
graph = ... # build the graph
saver = tf.train.Saver() # create the saver after the graph
with ... as sess: # your session object
saver.save(sess, 'my-model')
загрузка
graph = ... # build the graph
saver = tf.train.Saver() # create the saver after the graph
with ... as sess: # your session object
saver.restore(sess, tf.train.latest_checkpoint('./'))
# now you can use the graph, continue training or whatever
загрузка графа из файла
при использовании этого метода, убедитесь, что все ваши слои/переменные заданы явно уникальное имя. в противном случае Tensorflow сделает имена уникальными, и они будут отличаться от имен, хранящихся в файле. Это не проблема в предыдущей технике, потому что имена "искажены" одинаково как при загрузке, так и при сохранении.
экономия
graph = ... # build the graph
for op in [ ... ]: # operators you want to use after restoring the model
tf.add_to_collection('ops_to_restore', op)
saver = tf.train.Saver() # create the saver after the graph
with ... as sess: # your session object
saver.save(sess, 'my-model')
загрузка
with ... as sess: # your session object
saver = 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
вы также можете проверить примеры на TensorFlow / skflow, который расположен save
и restore
методы, которые могут помочь вам легко управлять своей модели. Он имеет параметры, которые вы также можете контролировать, как часто вы хотите создать резервную копию модели.
Если вы используете tf.поезд.MonitoredTrainingSession в качестве сеанса по умолчанию вам не нужно добавлять дополнительный код для сохранения / восстановления. Просто передайте имя контрольной точки в конструктор MonitoredTrainingSession, он будет использовать крючки сеанса для их обработки.
как описано в вопросе 6255:
use '**./**model_name.ckpt'
saver.restore(sess,'./my_model_final.ckpt')
вместо
saver.restore('my_model_final.ckpt')
все ответы здесь отличные, но я хочу добавить две вещи.
во-первых, чтобы уточнить ответ @user7505159,"./ "может быть важно добавить в начало имени файла, который вы восстанавливаете.
например, вы можете сохранить график без "./ "в имени файла так:
# Some graph defined up here with specific names
saver = tf.train.Saver()
save_file = 'model.ckpt'
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
saver.save(sess, save_file)
но для того, чтобы восстановить график, вам может понадобиться добавить "./ "к имени файла:
# Same graph defined up here
saver = tf.train.Saver()
save_file = './' + 'model.ckpt' # String addition used for emphasis
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
saver.restore(sess, save_file)
вам не всегда будут нужны "./", но это может вызвать проблемы в зависимости от вашей среды и версии TensorFlow.
Он также хочет упомянуть, что sess.run(tf.global_variables_initializer())
может быть важно перед восстановлением сессии.
если вы получаете ошибку относительно неинициализированных переменных при попытке восстановить сохраненный сеанс, убедитесь, что вы включаете sess.run(tf.global_variables_initializer())
до saver.restore(sess, save_file)
линии. Это избавит вас от головной боли.
нетерпеливый режим также является нерешенным вопросом сохранения / восстановления, на который никто не ответил даже на документацию, хотя документы, безусловно, претендуют на ответ. Вот нерабочий код, который я написал, который пытается использовать класс Saver внутри tensorflow.ВНО.стремятся как СФП. Мой код определенно сохранен на диске... кое-что было спасено. Проблема в восстановлении. Я даже добавил явный код, чтобы сначала вручную воссоздать все, а затем загрузить изученные параметры:
optimizer = tf.train.AdamOptimizer() #ga
global_step = tf.train.get_or_create_global_step() # what is a global_step?
model = tf.keras.Sequential([
tf.keras.layers.Dense(10, activation=tf.nn.relu, input_shape=(4,)), # input shape required
tf.keras.layers.Dense(10, activation=tf.nn.relu, kernel_initializer='glorot_uniform'),
tf.keras.layers.Dense(3)
])
#s = tfe.Saver([optimizer, model, global_step])
s = tfe.Saver([model])
s.restore(file_prefix="/tmp/iris-1")
Это восстанавливает что-то, затем бросает ValueError:
INFO:tensorflow:Restoring parameters from /tmp/iris-1
---------------------------------------------------------------------------
ValueError...
--> names, slices, dtypes = zip(*restore_specs)