я улучшаю свой ответ, чтобы добавить больше деталей для сохранения и восстановления моделей.

In (и после) 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

контрольно-пропускных пунктов, которые сохраняются содержать значения Variables в вашей модели, а не сама модель/график, что означает, что график должен быть таким же, когда вы восстанавливаете контрольную точку.

вот пример для линейной регрессии, где есть цикл обучения, который сохраняет переменные контрольные точки и раздел оценки, который восстановит переменные, сохраненные в предыдущем запуске, и вычислит прогнозы. Конечно, вы также можете восстановите переменные и продолжайте обучение, если хотите.

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 на Variables, которые покрывают сохранение и восстановление. А вот и docs на Saver.

есть две части модели, определение модели, сохраненные Supervisor Как 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 один простой пример, приведенный ниже, вы можете больше узнать от обслуживание модели тензорного потока:

сохранить модель:

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 и контрольной точки, импортировав график, вручную создав переменные, а затем используя заставку.

я реализовал это для моего личного использования, поэтому я бы поделился кодом здесь.

Ссылка:https://gist.github.com/nikitakit/6ef3b72be67b86cb7868

(Это, конечно, Хак, и нет никакой гарантии, что сохраненные таким образом модели останутся читаемыми в будущих версиях Тензорный поток.)

Если это внутренне сохраненная модель, вы просто указываете реставратор для всех переменных как

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

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, the "./ "может быть важно добавить в начало имени файла, который вы восстанавливаете.

например, вы можете сохранить график без "./ "в имени файла вот так:

# 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) линии. Это может избавить вас от головной боли.

режим Eager также является нерешенным вопросом сохранения / восстановления, на который никто не ответил даже на документацию, хотя документы, безусловно, претендуют на ответ. Вот нерабочий код, который я написал, который пытается использовать класс 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")

It восстанавливает что-то затем бросает ValueError:

INFO:tensorflow:Restoring parameters from /tmp/iris-1

---------------------------------------------------------------------------
ValueError...
--> names, slices, dtypes = zip(*restore_specs)