Tensorflow how to save restore a model

Question

After you train a model in Tensorflow     How do you save the trained model  How do you later restore this saved model

User · Answer

Here is a simple example using Tensorflow 2 0 SavedModel format  which is the recommended format  according to the docs  for a simple MNIST dataset classifier  using Keras functional API without too much fancy going on      Imports import tensorflow as tf from tensorflow keras layers import Input  Dense  Flatten from tensorflow keras models import Model import matplotlib pyplot as plt    Load data mnist   tf keras datasets mnist   28 x 28  x train y train    x test  y test    mnist load data      Normalize pixels  0 255  - gt   0 1  x train   tf keras utils normalize x train axis 1  x test   tf keras utils normalize x test axis 1     Create model input   Input shape  28 28   dtype  float64   name  graph input   x   Flatten   input  x   Dense 128  activation  relu   x  x   Dense 128  activation  relu   x  output   Dense 10  activation  softmax   name  graph output   dtype  float64   x  model   Model inputs input  outputs output   model compile optimizer  adam                loss  sparse categorical crossentropy                metrics   accuracy       Train model fit x train  y train  epochs 3     Save model in SavedModel format  Tensorflow 2 0  export path    model  tf saved model save model  export path         possibly another python program     Reload model loaded model   tf keras models load model export path      Get image sample for testing index   0 img   x test index    I normalized the image on a previous step    Predict using the signature definition  Tensorflow 2 0  predict   loaded model signatures  serving default   prediction   predict tf constant img      Show results print np argmax prediction  graph output        prints the class number plt imshow x test index   cmap plt cm binary     prints the image    What is serving default    It s the name of the signature def of the tag you selected  in this case  the default serve tag was selected   Also  here explains how to find the tag s and signatures of a model using saved model cli    Disclaimers  This is just a basic example if you just want to get it up and running  but is by no means a complete answer - maybe I can update it in the future  I just wanted to give a simple example using the SavedModel in TF 2 0 because I haven t seen one  even this simple  anywhere     Tom s answer is a SavedModel example  but it will not work on Tensorflow 2 0  because unfortunately there are some breaking changes    Vishnuvardhan Janapati s answer says TF 2 0  but it s not for SavedModel format

User · Answer

All the answers here are great  but I want to add two things   First  to elaborate on  user7505159 s answer  the      can be important to add to the beginning of the file name that you are restoring   For example  you can save a graph with no      in the file name like so     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    But in order to restore the graph  you may need to prepend a      to 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      sess run tf global variables initializer        saver restore sess  save file    You will not always need the       but it can cause problems depending on your environment and version of TensorFlow   It also want to mention that the sess run tf global variables initializer    can be important before restoring the session   If you are receiving an error regarding uninitialized variables when trying to restore a saved session  make sure you include sess run tf global variables initializer    before the saver restore sess  save file  line  It can save you a headache

User · Answer

As described in issue 6255   use        model name ckpt  saver restore sess    my model final ckpt     instead of   saver restore  my model final ckpt

User · Answer

In  and after  TensorFlow version 0 11 0RC1  you can save and restore your model directly by calling tf train export meta graph and tf train import meta graph according to https   www tensorflow org programmers guide meta graph   Save the 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   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   Restore the 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      print v

User · Answer

For tensorflow-2 0  it s very simple   import tensorflow as tf   SAVE  model save  model name     RESTORE  model   tf keras models load model  model name

User · Answer

There are two parts to the model  the model definition  saved by Supervisor as graph pbtxt in the model directory and the numerical values of tensors  saved into checkpoint files like model ckpt-1003418   The model definition can be restored using tf import graph def  and the weights are restored using Saver   However  Saver uses special collection holding list of variables that s attached to the model Graph  and this collection is not initialized using import graph def  so you can t use the two together at the moment  it s on our roadmap to fix   For now  you have to use approach of Ryan Sepassi -- manually construct a graph with identical node names  and use Saver to load the weights into it    Alternatively you could hack it by using by using import graph def  creating variables manually  and using tf add to collection tf GraphKeys VARIABLES  variable  for each variable  then using Saver

User · Answer

I am improving my answer to add more details for saving and restoring models    In and after  Tensorflow version 0 11    Save the 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   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    Restore the model    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    This and some more advanced use-cases have been explained very well here   A quick complete tutorial to save and restore Tensorflow models

User · Answer

You can also check out examples in TensorFlow skflow  which offers save and restore methods that can help you easily manage your models  It has parameters that you can also control how frequently you want to back up your model

User · Answer

You can also take this easier way   Step 1  initialize all your 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 session inside 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         print  Initialized     Step 4  check your variable  W1   session run W1  print W1      While running in different python instance  use  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

User · Answer

Wherever you want to save the model   self saver   tf train Saver   with tf Session   as sess              sess run tf global variables initializer                                self saver save sess  filename    Make sure  all your tf Variable have names  because you may want to restore them later using their names  And 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 that saver runs inside the corresponding session   Remember that  if you use the tf train latest checkpoint        then only the latest check point will be used

User · Answer

According to the new Tensorflow version  tf train Checkpoint is the preferable way of saving and restoring a model      Checkpoint save and Checkpoint restore write and read object-based   checkpoints  in contrast to tf train Saver which writes and reads   variable name based checkpoints  Object-based checkpointing saves a   graph of dependencies between Python objects  Layers  Optimizers    Variables  etc   with named edges  and this graph is used to match   variables when restoring a checkpoint  It can be more robust to   changes in the Python program  and helps to support restore-on-create   for variables when executing eagerly  Prefer tf train Checkpoint over   tf train Saver for new code    Here is an example   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    More information and example here

User · Answer

tf keras Model saving with TF2 0  I see great answers for saving models using TF1 x  I want to provide couple of more pointers in saving tensorflow keras models which is a little complicated as there are many ways to save a model    Here I am providing an example of saving a tensorflow keras model to model path folder under current directory  This works well with most recent tensorflow  TF2 0   I will update this description if there is any change in near future   Saving and loading 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 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     Saving and loading model Weights only  If you are interested in saving model weights only and then load weights to restore the model  then  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     Saving and restoring using 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      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     saving 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    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     Saving keras model with custom ops  When we have custom ops as in the following case  tf tile   we need to create a function and wrap with a Lambda layer  Otherwise  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  print model x  numpy     model save  my model h5     load the model new model tf keras models load model  my model h5     I think I have covered a few of the many ways of saving tf keras model  However  there are many other ways  Please comment below if you see your use case is not covered above  Thanks

User · Answer

You can save the variables in the network using  saver   tf train Saver    saver save sess   path of save fileName ckpt     To restore the network for reuse later or in another script  use   saver   tf train Saver   saver restore sess  tf train latest checkpoint  path of save    sess run          Important points    sess must be same between first and later runs  coherent structure    saver restore needs the path of the folder of the saved files  not an individual file path

User · Answer

For TensorFlow version  lt  0 11 0RC1   The checkpoints that are saved contain values for the Variables in your model  not the model graph itself  which means that the graph should be the same when you restore the checkpoint   Here s an example for a linear regression where there s a training loop that saves variable checkpoints and an evaluation section that will restore variables saved in a prior run and compute predictions  Of course  you can also restore variables and continue training if you d like   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     Here are the docs for Variables  which cover saving and restoring  And here are the docs for the Saver

User · Answer

In the new version of tensorflow 2 0  the process of saving loading a model is a lot easier  Because of the Implementation of the Keras API  a high-level API for TensorFlow   To save a model  Check the 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    To load a model   https   www tensorflow org versions r2 0 api docs python tf keras models load model  model   tf keras models load model filepath

User · Answer

Tensorflow 2 Docs Saving Checkpoints Adapted from the docs   -------------------------   -----  Toy Context  -----   ------------------------- import tensorflow as tf   class Net tf keras Model        quot  quot  quot A simple linear model  quot  quot  quot       def   init   self           super Net  self    init             self l1   tf keras layers Dense 5       def call self  x           return self l1 x    def toy dataset        inputs   tf range 10 0     None      labels   inputs   5 0   tf range 5 0  None         return           tf data Dataset from tensor slices dict x inputs  y labels   repeat   batch 2          def train step net  example  optimizer        quot  quot  quot Trains  net  on  example  using  optimizer   quot  quot  quot      with tf GradientTape   as tape          output   net example  quot x quot            loss   tf reduce mean tf abs output - example  quot y quot         variables   net trainable variables     gradients   tape gradient loss  variables      optimizer apply gradients zip gradients  variables       return loss     ----------------------------   -----  Create Objects  -----   ----------------------------  net   Net   opt   tf keras optimizers Adam 0 1  dataset   toy dataset   iterator   iter dataset  ckpt   tf train Checkpoint      step tf Variable 1   optimizer opt  net net  iterator iterator   manager   tf train CheckpointManager ckpt   quot   tf ckpts quot   max to keep 3     ----------------------------   -----  Train and Save  -----   ----------------------------  ckpt restore manager latest checkpoint  if manager latest checkpoint      print  quot Restored from    quot  format manager latest checkpoint   else      print  quot Initializing from scratch  quot    for   in range 50       example   next iterator      loss   train step net  example  opt      ckpt step assign add 1      if int ckpt step    10    0          save path   manager save           print  quot Saved checkpoint for step        quot  format int ckpt step   save path           print  quot loss   1 2f  quot  format loss numpy         ---------------------   -----  Restore  -----   ---------------------    In another script  re-initialize objects opt   tf keras optimizers Adam 0 1  net   Net   dataset   toy dataset   iterator   iter dataset  ckpt   tf train Checkpoint      step tf Variable 1   optimizer opt  net net  iterator iterator   manager   tf train CheckpointManager ckpt   quot   tf ckpts quot   max to keep 3     Re-use the manager code above    ckpt restore manager latest checkpoint  if manager latest checkpoint      print  quot Restored from    quot  format manager latest checkpoint   else      print  quot Initializing from scratch  quot    for   in range 50       example   next iterator        Continue training or evaluate etc    More links  exhaustive and useful tutorial on saved model - gt  https   www tensorflow org guide saved model  keras detailed guide to save models - gt  https   www tensorflow org guide keras save and serialize    Checkpoints capture the exact value of all parameters  tf Variable objects  used by a model  Checkpoints do not contain any description of the computation defined by the model and thus are typically only useful when source code that will use the saved parameter values is available  The SavedModel format on the other hand includes a serialized description of the computation defined by the model in addition to the parameter values  checkpoint   Models in this format are independent of the source code that created the model  They are thus suitable for deployment via TensorFlow Serving  TensorFlow Lite  TensorFlow js  or programs in other programming languages  the C  C    Java  Go  Rust  C  etc  TensorFlow APIs     Highlights are my own   Tensorflow  lt  2  From the docs  Save   Create some variables  v1   tf get variable  quot v1 quot   shape  3   initializer   tf zeros initializer  v2   tf get variable  quot v2 quot   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   quot  tmp model ckpt quot     print  quot Model saved in path   s quot    save path   Restore tf reset default graph      Create some variables  v1   tf get variable  quot v1 quot   shape  3   v2   tf get variable  quot v2 quot   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   quot  tmp model ckpt quot     print  quot Model restored  quot       Check the values of the variables   print  quot v1    s quot    v1 eval      print  quot v2    s quot    v2 eval     simple save Many good answer  for completeness I ll add my 2 cents  simple save  Also a standalone 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                  quot batch size placeholder quot   batch size placeholder               quot features placeholder quot   features placeholder               quot labels placeholder quot   labels placeholder                    outputs     quot prediction quot   model output          tf saved model simple save              sess   path to your location    inputs  outputs            Restoring  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             Standalone example Original blog post The following code generates random data for the sake of the demonstration   We start by creating the placeholders  They will hold the data at runtime  From them  we create the Dataset and then its Iterator  We get the iterator s generated tensor  called input tensor which will serve as input to our model  The model itself is built from input tensor  a GRU-based bidirectional RNN followed by a dense classifier  Because why not  The loss is a softmax cross entropy with logits  optimized with Adam  After 2 epochs  of 2 batches each   we save the  quot trained quot  model with tf saved model simple save  If you run the code as is  then the model will be saved in a folder called simple  in your current working directory  In a new graph  we then restore the saved model with tf saved model loader load  We grab the placeholders and logits with graph get tensor by name and the Iterator initializing operation with graph get operation by name  Lastly we run an inference for both batches in the dataset  and check that the saved and restored model both yield the same values  They do   Code  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        quot  quot  quot Create the model which consists of     a bidirectional rnn  GRU 10   followed by a dense classifier      Args          graph  tf Graph   Tensors  graph         input tensor  tf Tensor   Tensor fed as input to the model      Returns          tf Tensor  the model s output layer Tensor      quot  quot  quot      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        quot  quot  quot Create optimization operation from model s logits and labels      Args          graph  tf Graph   Tensors  graph         logits  tf Tensor   The model s output without activation         labels tensor  tf Tensor   Target labels      Returns          tf Operation  the operation performing a stem of Adam optimizer      quot  quot  quot      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  quot mean-xent quot                                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  lt  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                      quot batch size ph quot   batch size ph                   quot features data ph quot   features data ph                   quot labels data ph quot   labels data ph                           outputs dict                      quot logits quot   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   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   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

User · Answer

My environment  Python 3 6  Tensorflow 1 3 0  Though there have been many solutions  most of them is based on tf train Saver  When we load a  ckpt saved by Saver  we have to either redefine the tensorflow network or use some weird and hard-remembered name  e g   placehold 0 0   dense Adam Weight 0   Here I recommend to use tf saved model  one simplest example given below  your can learn more from Serving a TensorFlow Model   Save the 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     Load the model     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

User · Answer

Use tf train Saver to save a model  remerber  you need to specify the var list  if you want to reduce the model size  The val list can be tf trainable variables or tf global variables

User · Answer

If it is an internally saved model  you just specify a restorer for all variables as  restorer   tf train Saver tf all variables      and use it to restore variables in a current session   restorer restore self  sess  model file    For the external model you need to specify the mapping from the its variable names to your variable names  You can view the model variable names using the command   python  path to tensorflow tensorflow python tools inspect checkpoint py --file name  path to pretrained model model ckpt   The inspect checkpoint py script can be found in    tensorflow python tools  folder of the Tensorflow source   To specify the mapping  you can use my Tensorflow-Worklab  which contains a set of classes and scripts to train and retrain different models  It includes an example of retraining ResNet models  located here

User · Answer

In most cases  saving and restoring from disk using a tf train Saver is your best option         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 graph structure itself  see the MetaGraph documentation for details   By default  the Saver saves the graph structure into a  meta file  You can call import meta graph   to restore it  It restores the graph structure and returns a Saver that you can use to restore the model s state   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  there are cases where you need something much faster  For example  if you implement early stopping  you want to save checkpoints every time the model improves during training  as measured on the validation set   then if there is no progress for some time  you want to roll back to the best model   If you save the model to disk every time it improves  it will tremendously slow down training  The trick is to save the variable states to memory  then just 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    A quick explanation  when you create a variable X  TensorFlow automatically creates an assignment operation X Assign to set the variable s initial value  Instead of creating placeholders and extra assignment ops  which would just make the graph messy   we just use these existing assignment ops  The first input of each assignment op is a reference to the variable it is supposed to initialize  and the second input  assign op inputs 1   is the initial value  So in order to set any value we want  instead of the initial value   we need to use a feed dict and replace the initial value  Yes  TensorFlow lets you feed a value for any op  not just for placeholders  so this works fine

User · Answer

Here s my simple solution for the two basic cases differing on whether you want to load the graph from file or build it during runtime   This answer holds for Tensorflow 0 12   including 1 0    Rebuilding the graph in code  Saving  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     Loading  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   Loading also the graph from a file  When using this technique  make sure all your layers variables have explicitly set unique names  Otherwise Tensorflow will make the names unique itself and they ll be thus different from the names stored in the file  It s not a problem in the previous technique  because the names are  mangled  the same way in both loading and saving   Saving  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     Loading  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

User · Answer

For tensorflow 2 0  it is as simple as      Save the model model save  path to my model h5      To restore   new model   tensorflow keras models load model  path to my model h5

User · Answer

I m on Version   tensorflow  1 13 1  tensorflow-gpu  1 13 1    Simple way is  Save   model save  model h5     Restore   model   tf keras models load model  model h5

User · Answer

As Yaroslav said  you can hack restoring from a graph def and checkpoint by importing the graph  manually creating variables  and then using a Saver   I implemented this for my personal use  so I though I d share the code here   Link  https   gist github com nikitakit 6ef3b72be67b86cb7868   This is  of course  a hack  and there is no guarantee that models saved this way will remain readable in future versions of TensorFlow

User · Answer

If you use tf train MonitoredTrainingSession as the default session  you don t need to add extra code to do save restore things  Just pass a checkpoint dir name to MonitoredTrainingSession s constructor  it will use session hooks to handle these

User · Answer

Following  Vishnuvardhan Janapati  s answer  here is another way to save and reload model with custom layer metric loss 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 you have executed such codes  and saved your model with tf keras models save model or model save or ModelCheckpoint callback  you can re-load your model without the need of precise custom objects  as simple as  new model   tf keras models load model    model h5

[python] Tensorflow: how to save/restore a model?

Examples related to python

Examples related to tensorflow

Examples related to machine-learning

Examples related to model