Ответ 1

Документы

Они создали исчерпывающий и полезный учебник → 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 variables
  print("v1 : %s" % v1.eval())
  print("v2 : %s" % v2.eval())

Tensorflow 2

Это все еще бета, поэтому я бы посоветовал против пока. Если вы все еще хотите пойти по этому пути, вот руководство по использованию tf.saved_model

Тензор потока & lt; 2

simple_save

Много хорошего ответа, для полноты я добавлю свои 2 цента: simple_save. Также автономный пример кода с использованием API tf.data.Dataset.

Python 3; Тензорный поток 1,14

import tensorflow as tf
from tensorflow.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
        })

Автономный пример

Оригинальное сообщение в блоге

Следующий код генерирует случайные данные ради демонстрации.

1. Мы начнем с создания заполнителей. Они будут хранить данные во время выполнения. Из них мы создаем Dataset, а затем его Iterator. Мы получаем сгенерированный итератором тензор, называемый input_tensor, который будет служить входом для нашей модели.
2. Сама модель построена из input_tensor: двунаправленного RNN на основе GRU, за которым следует плотный классификатор. Потому что почему бы и нет.
3. Потеря - это softmax_cross_entropy_with_logits, оптимизированная с помощью Adam. После 2 эпох (по 2 партии в каждой) мы сохраняем "обученную" модель с помощью tf.saved_model.simple_save. Если вы запустите код как есть, то модель будет сохранена в папке с именем simple/ в вашем текущем рабочем каталоге.
4. На новом графике мы затем восстанавливаем сохраненную модель с помощью tf.saved_model.loader.load. Мы берем заполнители и логиты с помощью graph.get_tensor_by_name и операции инициализации Iterator с graph.get_operation_by_name.
5. Наконец, мы запускаем логический вывод для обоих пакетов в наборе данных и проверяем, что обе сохраненные и восстановленные модели дают одинаковые значения. Они делают!

Код:

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 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 logits and labels

    Args:
        graph (tf.Graph): Tensors' graph
        logits (tf.Tensor): The model 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

Ответ 2

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

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

Ответ 3

В (и после) версии 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_)

Ответ 4

Для версии 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 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 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.

Ответ 5

Моя среда: 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})

Ответ 6

Есть две части модели: определение модели, сохраненное в Supervisor как graph.pbtxt в каталоге модели и числовые значения тензоров, сохраненные в файлах контрольных точек, таких как model.ckpt-1003418.

Определение модели можно восстановить с помощью tf.import_graph_def, а весы будут восстановлены с помощью Saver.

Однако Saver использует специальный список хранения коллекции, который привязан к графику модели, и эта коллекция не инициализируется с помощью import_graph_def, поэтому вы не можете использовать их вместе в данный момент (это в нашей дорожной карте, чтобы исправить). На данный момент вы должны использовать подход Райана Сепасси - вручную построить граф с идентичными именами node и использовать Saver для загрузки весов в него.

(В качестве альтернативы вы можете взломать его, используя import_graph_def, создавая переменные вручную и используя tf.add_to_collection(tf.GraphKeys.VARIABLES, variable) для каждой переменной, затем используя Saver)

Ответ 7

Вы также можете сделать это проще.

Шаг 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)

Ответ 8

В большинстве случаев сохранение и восстановление с диска с помощью 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

Вы также можете сохранить/восстановить структуру графика (подробнее см. Документация MetaGraph). По умолчанию Saver сохраняет структуру графика в файл .meta. Вы можете вызвать 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, а не только для заполнителей, поэтому это отлично работает.

Ответ 9

Как сказал Ярослав, вы можете взломать восстановление с помощью graph_def и контрольной точки, импортировав график, вручную создав переменные, а затем с помощью Saver.

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

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

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

Ответ 10

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

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

Инспектор_checkpoint.py script может быть найден в папке "./tensorflow/python/tools" источника Tensorflow.

Чтобы указать отображение, вы можете использовать Tensorflow-Worklab, который содержит набор классов и скриптов для обучения и переподготовки различных моделей. Он включает пример переподготовки моделей ResNet, расположенных здесь

Ответ 11

Здесь мое простое решение для двух основных случаев отличается от того, хотите ли вы загрузить график из файла или создать его во время выполнения.

Этот ответ выполняется для 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

Ответ 12

Вы также можете проверить examples в TensorFlow/skflow, который предлагает методы save и restore, которые могут помочь вам легко управлять вашими моделями. У него есть параметры, которые вы также можете контролировать, как часто вы хотите создать резервную копию своей модели.

Ответ 13

Если вы используете tf.train.MonitoredTrainingSession в качестве сеанса по умолчанию, вам не нужно добавлять дополнительный код для сохранения/восстановления вещей, Просто передайте имя контрольного пункта в конструктор MonitoredTrainingSession, он будет использовать сеансовые перехватчики для их обработки.

Ответ 14

Все ответы здесь замечательные, но я хочу добавить две вещи.

Во-первых, чтобы уточнить ответ @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). Это может спасти вам головную боль.

Ответ 15

Как описано в выпуске 6255:

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

вместо

saver.restore('my_model_final.ckpt')

Ответ 16

Согласно новой версии Tensorflow, tf.train.Checkpoint является предпочтительным способом сохранения и восстановления модели:

Checkpoint.save и Checkpoint.restore записывают и читают объектные контрольные точки, в отличие от tf.train.Saver, который записывает и читает контрольные точки на основе variable.name. Объектная контрольная точка сохраняет график зависимостей между объектами Python (Layers, Optimizer, Variables и т.д.) С именованными ребрами, и этот график используется для сопоставления переменных при восстановлении контрольной точки. Он может быть более устойчивым к изменениям в программе Python и помогает поддерживать восстановление при создании переменных при их активном выполнении. Предпочитайте tf.train.Checkpoint tf.train.Saver для нового кода.

Вот пример:

import tensorflow as tf
import os

tf.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)

Больше информации и пример здесь.

Ответ 17

Для tenorflow 2.0 это так же просто, как

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

Чтобы восстановить:

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

Ответ 18

Используйте tf.train.Saver, чтобы сохранить модель, remerber, вам нужно указать var_list, если вы хотите уменьшить размер модели. Val_list может быть tf.trainable_variables или tf.global_variables.

Ответ 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(....) 

Важные моменты:

1. sess должен быть одинаковым между первым и последующим прогонами (связная структура).
2. saver.restore требуется путь к папке с сохраненными файлами, а не отдельный путь к файлу.

Ответ 20

Везде, где вы хотите сохранить модель,

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('./'), то будет использоваться только последняя контрольная точка.

Ответ 21

Я на версии:

tensorflow (1.13.1)
tensorflow-gpu (1.13.1)

Простой способ

Сохранить:

model.save("model.h5")

Восстановить:

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

Ответ 22

tf.keras Сохранение модели с помощью TF2.0

Я вижу отличные ответы для сохранения моделей с использованием TF1.x. Я хочу предоставить еще несколько советов по сохранению моделей tensorflow.keras, что немного сложно, так как существует множество способов сохранить модель.

Здесь я приведу пример сохранения модели tensorflow.keras в папку model_path в текущем каталоге. Это хорошо работает с самым последним тензорным потоком (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 model
  model.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 Model

def my_fun(a):
  out = tf.tile(a, (1, tf.shape(a)[0]))
  return out

a = 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. Однако есть много других способов. Пожалуйста, прокомментируйте ниже, если вы видите, что ваш случай использования не описан выше. Спасибо!

Ответ 23

В новой версии tenorflow 2.0 процесс сохранения/загрузки модели стал намного проще. Из-за реализации API Keras, высокоуровневого API для TensorFlow.

Чтобы сохранить модель: Проверьте документацию для справки: 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)

Ответ 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 layer

get_custom_objects().update({'CustomLayer': CustomLayer})  

Таким образом, после того, как вы выполнили такие коды и сохранили свою модель с обратным вызовом tf.keras.models.save_model или model.save или ModelCheckpoint, вы можете перезагрузить модель без необходимости точных пользовательских объектов, таких простых, как

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

Ответ 25

Режим ожидания также является нерешенным вопросом сохранения/восстановления, на который никто не ответил даже на документацию, хотя документы, безусловно, требуют ответа. Вот неработающий код, который я написал, который пытается использовать класс Saver внутри shadoworflow.contrib.eager как tfe. Мой код определенно сохранен на диске... что-то было сохранено. Проблема заключается в восстановлении. Я даже добавил явный код, чтобы сначала вручную воссоздать все, а затем загрузить полученные параметры:

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)