Tensorflow: how to save / restore a model?

stay Tensorflow After middle training model:

  1. How do you save a trained model?
  2. How do you restore this saved model in the future?

#1 building

For TensorFlow version < 0.11.0rc1:

The saved checkpoint contains the value of the Variable in the model, not the model / drawing itself, which means that when you restore the checkpoint, the drawing should be the same.

This is an example of linear regression, where there is a training cycle that saves variable checkpoints, while the evaluation section restores variables saved in previous runs and calculates predictions. Of course, you can also recover variables and continue training as needed.

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:
    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',
        # 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)
            ...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})

This is Variable File , which includes save and restore. This is Saver's File .

#2 building

The model is divided into two parts: model definition (saved by the Supervisor as graph.pbtxt and tensor value in the model directory (saved in a checkpoint file such as model.ckpt-1003418).

You can use tf.import ABCD graph ABCD def to restore model definitions and use Saver to restore weights.

However, Saver uses a special collection to save the list, which contains variables attached to the model Graph, and the collection is not initialized with import Graph def, so you cannot use both at this time (under repair). Now, you have to use Ryan Sepassi's method - to manually construct a Graph with the same node name, and then use saver to load the weights into it.

(alternatively, you can use import > graph > def to create variables manually and tf.add > collection (tf.graphkeys.variables, variable) for each variable, and then use Saver to crack it.)

#3 building

As Yaroslav said, you can restore from graph def and checkpoint by importing the graph, manually creating variables, and then using Saver.

I implemented it for personal use, so even though I shared the code here.

Links: https : //gist.github.com/nikitakit/6ef3b72be67b86cb7868

(this is a hacker, of course, and there is no guarantee that the model saved in this way will still be readable in future versions of TensorFlow.)

#4 building

You can also TensorFlow / skflow detection Example , the Example The save and restore methods are provided to help you easily manage the model. It has some parameters, and you can also control how often the model is backed up.

#5 building

If it is an internally saved model, you only need to specify a restorer for all variables

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

And use it to restore variables in the current session:

restorer.restore(self._sess, model_file)

For external models, you need to specify the mapping from their variable names to variable names. You can view model variable names using the following command

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

You can find the check point.py script in the '. / tensorflow/python/tools' folder of the Tensorflow source.

To specify a mapping, you can use my Tensorflow-Worklab , which contains a set of classes and scripts for training and retraining different models. It contains an example of retraining the ResNet model at here

#6 building

In TensorFlow version 0.11.0RC1 (and later), you can https://www.tensorflow.org/programmers_guide/meta_graph Call tf.train.export'meta'graph and tf.train.import'meta'graph to save and restore the model directly.

Preservation model

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()
saver.save(sess, 'my-model')
# `save` method will call `export_meta_graph` implicitly.
# you will get saved graph files:my-model.meta

Recovery model

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)

#7 building

Such questions 6255 :

use '**./**model_name.ckpt'



#8 building

You can also take this simpler approach.

Step 1: initialize all variables

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, .....

Step 2: save the call to Model Saver and save it

model_saver = tf.train.Saver()

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

Step 3: restore the model

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

Step 4: check your variables

W1 = session.run(W1)

When running in other python instances, use the

with tf.Session() as sess:
    # Restore latest checkpoint
    saver.restore(sess, tf.train.latest_checkpoint('saved_model/.'))

    # Initalize the variables

    # 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)

#9 building

In most cases, using tf.train.Saver to save and restore from disk is the best choice:

... # 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

You can also save / restore the drawing structure itself (for more information, see MetaGraph document ) By default, Saver saves the drawing structure to a. Meta file. You can call import > meta > graph() to restore. It restores the graph structure and returns a saver, which you can use to restore the state of the model:

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

However, in some cases, you need to be faster. For example, if the implementation stops ahead of time, you want to save checkpoints (subject to the validation set) every time the model improves during the training process, and then if there is no progress over time, you want to roll back to the best model. If you save the model to disk every time you improve, it will greatly slow down your training. The trick is to save the variable states to memory and then restore them later:

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

Quick instructions: create variable x, TensorFlow automatically creates an assignment operation X/Assign to set the initial value of the variable. Instead of creating placeholders and additional assignments (which only clutter the drawing), we use only those existing assignments. The first input of each assigned OP is a reference to the variable that should be initialized, and the second input (assign [op.inputs [1]) is the initial value. Therefore, in order to set any value you want (rather than the initial value), we need to use the feed ﹣ dict and replace the initial value. Yes, TensorFlow allows you to provide values for any operation, not just placeholders, so it works.

#10 building

This is my simple solution for two basic situations, the difference is whether you want to load a drawing from a file or build it at run time.

The answer applies to Tensorflow 0.12 + (including 1.0).

Rebuild drawing in code


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

Also load drawings from files

When using this technique, make sure that all layers / variables have a unique name explicitly set. Otherwise, Tensorflow makes the names themselves unique, so they will be different from the names stored in the file. This was not a problem in previous techniques because names were "mixed" in the same way when they were loaded and saved.


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

#11 building

I'm improving my answers to add more details about saving and restoring models.

In Tensorflow version 0.11 (and later):

Save model:

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()

#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)

Restore model:

import tensorflow as tf

#First let's load meta graph and restore weights
saver = tf.train.import_meta_graph('my_test_model-1000.meta')

# Access saved Variables directly
# 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 

Here and some more advanced use cases are well explained.

A quick and complete tutorial for saving and restoring Tensorflow models

#12 building

If you will tf.train.MonitoredTrainingSession As the default session, you can save / restore content without adding additional code. Simply pass the checkpoint directory name to the monitoredtraining session's constructor, which uses session hooks to handle these.

#13 building

All the answers here are good, but I want to add two.

First, to elaborate on the @ user7505159 answer, it is important to add '. /' to the beginning of the filename to be restored.

For example, you can save a drawing without '. /' in the filename as follows:

# Some graph defined up here with specific names

saver = tf.train.Saver()
save_file = 'model.ckpt'

with tf.Session() as sess:
    saver.save(sess, save_file)

However, in order to restore the drawing, you may need to add '. /' before the file name:

# Same graph defined up here

saver = tf.train.Saver()
save_file = './' + 'model.ckpt' # String addition used for emphasis

with tf.Session() as sess:
    saver.restore(sess, save_file)

You may not always need '. /', but depending on your environment and the version of TensorFlow, it can cause problems.

It is also important to mention that sess. Run (TF. Global "variables" initializer ()) is important before resuming the session.

If you receive an error about uninitialized variables when trying to restore a saved session, make sure to include sess. Run (TF. Global "variables" initializer()) before the saver. Restore (sess, save? File) line. It can save you headaches.

#14 building

My environment: Python 3.6, Tensorflow 1.3.0

Although there are many solutions, most of them are based on tf.train.Saver. When we load the. ckpt saved by Saver, we have to redefine the tensorflow network or use some weird and hard to remember names, such as' placehold_:0 ',' deny / Adam / weight: 0 '. Here, I suggest using tf.saved ﹣ model, which is the simplest example given below. You can choose from In the service TensorFlow model Learn more:

Save 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()

# 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 = (
      inputs={'x_input': tensor_info_x},
      outputs={'y_output': tensor_info_y},

  sess, [tf.saved_model.tag_constants.SERVING],

Load model:

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

#15 building


They built detailed and useful Tutorials - > https://www.tensorflow.org/guide/saved_model

From the document:


# 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:
  # Do some work with the model.
  # Save the variables to disk.
  save_path = saver.save(sess, "/tmp/model.ckpt")
  print("Model saved in path: %s" % save_path)



# 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

This is still in beta, so I don't recommend it. If you still want to take this road, here is Tf.saved-u model user guide

Tensorflow <2


For completeness For the sake of , I give many good answers, I will add 2 cents: simple_save . It is also a stand-alone code example using the tf.data.Dataset API.

Python 3; Tensorflow 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}
            sess, 'path/to/your/location/', inputs, outputs


graph = tf.Graph()
with restored_graph.as_default():
    with tf.Session() as sess:
        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

Independent example

Original blog post

For demonstration purposes, the following code generates random data.

  1. Let's create placeholders first. They will save the data at run time. Based on them, we create a Dataset and then its Iterator. We get the tensor generated by the Iterator, which is called input tensor, which will be used as input to the model.
  2. The model itself is constructed by input_sensor: a GRU based bidirectional RNN followed by a dense classifier. Because why not.
  3. The loss is softmax? Cross? Entry? With? Logits, optimized with Adam. After two periods (two batches for each batch), we save tf.saved ﹣ model.simple ﹣ save as a "trained" model. If you run the code as is, the model is saved in a folder called simple / in the current working directory.
  4. In the new diagram, use tf.saved_model.loader.load to restore the saved model. We grab placeholders and logits with graph. Get sensor by name and Iterator with initialization operation graph. Get operation by name.
  5. Finally, we extrapolate the two batches in the dataset and check that the saved and restored models produce the same values. They are!


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

        graph (tf.Graph): Tensors' graph
        input_tensor (tf.Tensor): Tensor fed as input to the model

        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(
            sequence_length=[10] * 32,
        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

        graph (tf.Graph): Tensors' graph
        logits (tf.Tensor): The model's output without activation
        labels_tensor (tf.Tensor): Target labels

        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'),
        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
    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
        # 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
            for epoch in range(3):
                batch = 0
                # Initialize dataset (could feed epochs in Dataset.repeat(epochs))
                        features_data_ph: features,
                        labels_data_ph: labels,
                        batch_size_ph: 32
                values = []
                while True:
                        if epoch < 2:
                            # Training
                            _, value = sess.run([opt_op, logits])
                            print('Epoch {}, batch {} | Sample value: {}'.format(epoch, batch, value[0]))
                            batch += 1
                            # Final inference
                            print('Epoch {}, batch {} | Final inference | Sample value: {}'.format(epoch, batch, values[-1][0]))
                            batch += 1
                    except tf.errors.OutOfRangeError:
            # Save model state
            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
                sess, path, inputs_dict, outputs_dict
    # Restoring
    graph2 = tf.Graph()
    with graph2.as_default():
        with tf.Session(graph=graph2) as sess:
            # Restore saved values
            # 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
                    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):
                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)

This will print:

$ 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]

INFO:tensorflow:Assets added to graph.
INFO:tensorflow:No assets to write.
INFO:tensorflow:SavedModel written to: b'/some/path/simple/saved_model.pb'

INFO:tensorflow:Restoring parameters from b'/some/path/simple/variables/variables'
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 building

Use tf.train.Saver to save the model and rename it. If you want to reduce the size of the model, you need to specify var? List. Val'list can be tf.trainable'variables or tf.global'variables.

#17 building

According to the new Tensorflow version, tf.train.Checkpoint is the preferred method to save and restore the model:

Checkpoint.save and Checkpoint.restore write and read object-based checkpoints, while tf.train.Saver can write and read variable.name-based checkpoints. Object based checkpoints store dependency graphs between Python objects (layers, optimizers, variables, etc.) with named edges, which are used to match variables when restoring checkpoints. It may be more robust for changes in Python programs, and it helps to support recovery when variables are created in a hurry. For the new code, tf.train.Saver uses tf.train.Checkpoint instead of tf.train.Saver.

Here is an example:

import tensorflow as tf
import os


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.

More information and examples are here.

#18 building

No matter where you want to save the model,

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

Make sure that all your tf.variables have names, because you may want to use their names later to restore them. Where you want to predict

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

Make sure the protector is running in the appropriate session. Keep in mind that if you use TF. Train. Latest Ju checkpoint ('. /'), only the latest checkpoint will be used.

#19 building

You can save variables to the network using the following methods

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

To restore the network for later reuse or use in another script, use:

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

Main points:

  1. The sess must be the same between the first run and the subsequent run (continuous structure).
  2. saver.restore requires a folder path for the saved files, not a single file path.

#20 building

For tensorflow 2.0, it's very simple

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


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

#21 building

I am using version:

tensorflow (1.13.1)
tensorflow-gpu (1.13.1)

The simple way is




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

#22 building

In the new version of tensorflow 2.0, the process of saving / loading the model is much easier. Because of the implementation of Keras API, it is a high-level API of TensorFlow.

Save model: check documentation for reference: 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)

Load model:


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

#23 building

tf.keras uses TF2.0 to save the model

I see a good answer to using TF1.x to save the model. I want to provide more pointers when I save the tensorflow.keras model, which is a bit complicated because there are many ways to save the model.

Here, I provide an example of saving the tensorflow.keras model to the model path folder in the current directory. This works well with the latest tensorflow (TF2.0). If there are any recent changes, I will update this description.

Save and load the entire model

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.Dense(10, activation=tf.nn.softmax)
# compile the model
  return model

# Create a basic model instance

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

# 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))

Save and load model weights only

If you just want to save the model weights and then load them to restore the model,

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

# Restore the weights
model = create_model()

loss,acc = model.evaluate(x_test, y_test)
print("Restored model, accuracy: {:5.2f}%".format(100*acc))

Save and restore using the keras checkpoint callback

# 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.

model = create_model()
model.fit(train_images, train_labels,
          epochs = 50, callbacks = [cp_callback],
          validation_data = (test_images,test_labels),

latest = tf.train.latest_checkpoint(checkpoint_dir)

new_model = create_model()
loss, acc = new_model.evaluate(test_images, test_labels)
print("Restored model, accuracy: {:5.2f}%".format(100*acc))

Save model with custom metrics

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) 
def customLoss1(yTrue,yPred):
  return tf.reduce_mean(yTrue-yPred) 

# Custom Loss2 (for example) 
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.Dense(10, activation=tf.nn.softmax)
              metrics=['accuracy', customLoss1, customLoss2])
  return model

# Create a basic model instance

# 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))



Save the Keras model using custom actions

In the following cases (tf.tile) with custom actions, we need to create a function and wrap a Lambda layer. Otherwise, the model cannot be saved.

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)


#load the model

I think I've introduced many ways to save tf.keras model. But there are many other ways. If you find no use cases involved above, please comment below. Thank you!

#24 building

Follow @ Vishnuvardhan Janapati's answer, which is another way to save and reload models using custom layers / measures / losses under 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})  

In this way, once such code is executed and the model is saved with tf.keras.models.save-u model or model.save or ModelCheckpoint callbacks, the model can be reloaded without precise custom objects, such as

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

#25 building

For tensorflow-2.0

It's very simple.

import tensorflow as tf




model = tf.keras.models.load_model('model_name')
Published 0 original articles, won praise 1, visited 3140
Private letter follow

Tags: Session Python network Lambda

Posted on Tue, 14 Jan 2020 00:17:07 -0500 by t.bo