Tensorflow: Wie kann ich ein Modell speichern/wiederherstellen?

Ich verbessere meine Antwort, um weitere Details zum Speichern und Wiederherstellen von Modellen hinzuzufügen. 

In (und nach) Tensorflow Version 0.11: 

Speichern Sie das Modell:

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)

Wiederherstellen des Modells: 

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 

Diese und einige fortgeschrittenere Anwendungsfälle wurden hier sehr gut erklärt.

Ein schnelles komplettes Tutorial zum Speichern und Wiederherstellen von Tensorflow-Modellen

In (und nach) TensorFlow Version 0.11.0RC1 können Sie Ihr Modell direkt speichern und wiederherstellen, indem Sie tf.train.export_meta_graph und tf.train.import_meta_graph gemäß https://www.tensorflow.org/programmers_guide/meta_graph aufrufen.

Speichern Sie das Modell

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

Stellen Sie das Modell wieder her

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

Für die TensorFlow-Version <0.11.0RC1:

Die gespeicherten Prüfpunkte enthalten Werte für Variables in Ihrem Modell, nicht das Modell/Diagramm selbst. Das bedeutet, dass das Diagramm beim Wiederherstellen des Prüfpunkts identisch sein sollte.

Hier ist ein Beispiel für eine lineare Regression, in der es eine Trainingsschleife gibt, die variable Prüfpunkte speichert, und einen Auswertungsabschnitt, in dem in einem vorherigen Lauf gespeicherte Variablen wiederhergestellt und Vorhersagen berechnet werden. Natürlich können Sie auch Variablen wiederherstellen und das Training fortsetzen, wenn Sie möchten.

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

Hier sind die docs für Variables, die das Speichern und Wiederherstellen abdecken. Und hier sind die docs für Saver.

Meine Umgebung: Python 3.6, Tensorflow 1.3.0

Obwohl es viele Lösungen gab, basieren die meisten auf tf.train.Saver. Wenn wir einen .ckpt laden, der von Saver gespeichert wurde, müssen wir entweder das Tensorflow-Netzwerk neu definieren oder einen ungewöhnlichen und schwer erinnerbaren Namen verwenden, z. 'placehold_0:0', 'dense/Adam/Weight:0'. Hier empfehle ich die Verwendung von tf.saved_model, einem einfachsten Beispiel, das Sie weiter unten finden können. Weitere Informationen finden Sie unter Serving eines TensorFlow-Modells :

Speichern Sie das Modell:

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

Laden Sie das Modell:

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

Das Modell besteht aus zwei Teilen, der Modelldefinition, die von Supervisor als graph.pbtxt im Modellverzeichnis gespeichert wird, und den numerischen Werten von Tensoren, die in Prüfpunktdateien wie model.ckpt-1003418 gespeichert werden.

Die Modelldefinition kann mit tf.import_graph_def wiederhergestellt werden, und die Gewichtungen werden mit Saver wiederhergestellt.

Saver verwendet jedoch eine spezielle Collection-Liste mit Variablen, die an den Modellgraphen angehängt ist. Diese Collection wird nicht mit import_graph_def initialisiert. Daher können Sie die beiden momentan nicht zusammen verwenden (dies ist in unserer Roadmap zu beheben). Für den Moment müssen Sie den Ansatz von Ryan Sepassi verwenden - erstellen Sie manuell einen Graphen mit identischen Knotennamen und laden Sie die Gewichte mit Saver.

(Alternativ können Sie es hacken, indem Sie import_graph_def verwenden, Variablen manuell erstellen und tf.add_to_collection(tf.GraphKeys.VARIABLES, variable) für jede Variable verwenden und dann Saver verwenden.)

Sie können diesen einfacheren Weg auch nehmen.

Schritt 1: Initialisieren Sie alle Ihre Variablen

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

Schritt 2: Speichern Sie die Sitzung im Modell Saver und speichern Sie sie

model_saver = tf.train.Saver()

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

Schritt 3: Stellen Sie das Modell wieder her

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

Schritt 4: Überprüfen Sie Ihre Variable

W1 = session.run(W1)
print(W1)

Verwenden Sie während der Ausführung in einer anderen Python-Instanz

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)

In den meisten Fällen ist das Speichern und Wiederherstellen von Datenträger mit einem tf.train.Saver die beste 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

Sie können auch die Diagrammstruktur selbst speichern/wiederherstellen (siehe MetaGraph-Dokumentation ). Standardmäßig speichert Saver die Diagrammstruktur in einer .meta-Datei. Sie können import_meta_graph() aufrufen, um es wiederherzustellen. Es stellt die Diagrammstruktur wieder her und gibt eine Saver zurück, mit der Sie den Zustand des Modells wiederherstellen können:

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

Es gibt jedoch Fälle, in denen Sie etwas schneller brauchen. Wenn Sie beispielsweise ein frühes Anhalten implementieren, möchten Sie Checkpoints jedes Mal speichern, wenn sich das Modell während des Trainings verbessert (gemessen am Validierungssatz). Wenn Sie einige Zeit keinen Fortschritt machen, möchten Sie zum besten Modell zurückkehren. Wenn Sie das Modell jedes Mal auf der Festplatte speichern, wenn es sich verbessert, wird das Training erheblich verlangsamt. Der Trick ist, die Zustände der Variablen in memory zu speichern und sie später einfach wiederherzustellen:

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

Eine kurze Erklärung: Wenn Sie eine Variable X erstellen, erstellt TensorFlow automatisch eine Zuweisungsoperation X/Assign, um den Anfangswert der Variablen festzulegen. Anstatt Platzhalter und zusätzliche Zuweisungsoperationen zu erstellen (was die Grafik nur unübersichtlich machen würde), verwenden wir nur diese vorhandenen Zuweisungsoperationen. Die erste Eingabe jedes Zuweisungsoperators ist eine Referenz auf die Variable, die initialisiert werden soll, und die zweite Eingabe (assign_op.inputs[1]) ist der Anfangswert. Um also einen beliebigen Wert festzulegen (anstelle des Anfangswerts), müssen wir einen feed_dict verwenden und den Anfangswert ersetzen. Ja, TensorFlow gibt Ihnen die Möglichkeit, einen Wert für jede Operation anzugeben, nicht nur für Platzhalter. Dies funktioniert also gut.

Wie Yaroslav sagte, können Sie die Wiederherstellung von einem graph_def und einem Prüfpunkt aus hacken, indem Sie den Graph importieren, manuell Variablen erstellen und dann einen Saver verwenden.

Ich habe dies für meinen persönlichen Gebrauch implementiert, also würde ich den Code hier weitergeben.

Link: https://Gist.github.com/nikitakit/6ef3b72be67b86cb7868

(Dies ist natürlich ein Hack, und es gibt keine Garantie, dass auf diese Weise gespeicherte Modelle in zukünftigen Versionen von TensorFlow lesbar bleiben.)

Wenn es sich um ein intern gespeichertes Modell handelt, geben Sie einfach einen Restorer für alle Variablen an

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

und verwenden Sie es, um Variablen in einer aktuellen Sitzung wiederherzustellen:

restorer.restore(self._sess, model_file)

Für das externe Modell müssen Sie die Zuordnung von seinen Variablennamen zu Ihren Variablennamen angeben. Sie können die Namen der Modellvariablen mit dem Befehl anzeigen 

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

Das Skript inspect_checkpoint.py befindet sich im Ordner './tensorflow/python/tools' der Tensorflow-Quelle.

Um das Mapping festzulegen, können Sie mein Tensorflow-Worklab verwenden, das eine Reihe von Klassen und Skripten enthält, um verschiedene Modelle zu trainieren und neu zu trainieren. Es enthält ein Beispiel für die Umschulung von ResNet-Modellen. Diese befinden sich hier

Hier ist meine einfache Lösung für die zwei grundlegenden Fälle, die sich davon unterscheiden, ob Sie das Diagramm aus einer Datei laden oder zur Laufzeit erstellen möchten.

Diese Antwort gilt für Tensorflow 0.12+ (einschließlich 1.0).

Neuerstellen des Diagramms im Code

Speichern

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

Wird geladen

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

Laden Sie auch das Diagramm aus einer Datei

Wenn Sie diese Technik verwenden, stellen Sie sicher, dass alle Ihre Layer/Variablen explizit eindeutige Namen festgelegt haben. Andernfalls macht Tensorflow die Namen selbst eindeutig und unterscheidet sich daher von den in der Datei gespeicherten Namen. Bei der vorherigen Technik ist dies kein Problem, da die Namen sowohl beim Laden als auch beim Speichern auf die gleiche Weise "verstümmelt" werden.

Speichern

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

Wird geladen

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

Sie können auch Examples in TensorFlow/skflow überprüfen, die save- und restore-Methoden bietet, mit denen Sie Ihre Modelle problemlos verwalten können. Es verfügt über Parameter, mit denen Sie auch steuern können, wie häufig Sie Ihr Modell sichern möchten. 

Alle Antworten hier sind großartig, aber ich möchte zwei Dinge hinzufügen.

Um näher auf die Antwort von @ user7505159 einzugehen, kann das "./" am Anfang des wiederherzustellenden Dateinamens wichtig sein.

Sie können beispielsweise ein Diagramm ohne "./" im Dateinamen wie folgt speichern:

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

Um das Diagramm jedoch wiederherzustellen, müssen Sie dem Dateinamen möglicherweise ein "./" voranstellen:

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

Sie benötigen nicht immer das "./", aber abhängig von Ihrer Umgebung und Version von TensorFlow kann dies zu Problemen führen.

Ich möchte auch erwähnen, dass sess.run(tf.global_variables_initializer()) wichtig sein kann, bevor die Sitzung wiederhergestellt wird.

Wenn Sie beim Versuch, eine gespeicherte Sitzung wiederherzustellen, einen Fehler bezüglich nicht initialisierter Variablen erhalten, stellen Sie sicher, dass Sie sess.run(tf.global_variables_initializer()) vor der Zeile saver.restore(sess, save_file) angeben. Es kann Ihnen Kopfschmerzen ersparen.

Wenn Sie tf.train.MonitoredTrainingSession als Standardsitzung verwenden, müssen Sie keinen zusätzlichen Code zum Speichern/Wiederherstellen von Dingen hinzufügen. Übergeben Sie einfach einen Checkpoint-Namen an den Konstruktor von MonitoredTrainingSession. Hierfür werden Session-Hooks verwendet. 

Wie in Ausgabe 6255 beschrieben:

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

anstatt 

saver.restore('my_model_final.ckpt')

Gemäß der neuen Tensorflow-Version ist tf.train.Checkpoint die bevorzugte Methode zum Speichern und Wiederherstellen eines Modells:

Checkpoint.save und Checkpoint.restore schreiben und lesen objektbasiert Prüfpunkte, im Gegensatz zu tf.train.Saver, der __ schreibt und liest. Kontrollpunkte auf Basis von Variablen. Objektbasiertes Checkpointing speichert eine Diagramm der Abhängigkeiten zwischen Python-Objekten (Ebenen, Optimierer, Variablen, Variablen usw.) mit benannten Kanten. Variablen beim Wiederherstellen eines Prüfpunkts. Es kann robuster für .__ sein. Änderungen im Python-Programm und unterstützen die Unterstützung von restore-on-create für Variablen bei eifriger Ausführung. tf.train.Checkpoint lieber über tf.train.Saver für neuen Code.

Hier ist ein Beispiel:

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)

Weitere Informationen und Beispiel hier.

Sie können die Variablen im Netzwerk speichern verwenden

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

Um Wiederherstellen des Netzwerks zur späteren Verwendung oder in einem anderen Skript verwenden Sie Folgendes:

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

Wichtige Punkte:

1. sess muss zwischen dem ersten und dem späteren Durchlauf gleich sein (zusammenhängende Struktur). 
2. saver.restore benötigt den Pfad des Ordners der gespeicherten Dateien, nicht einen einzelnen Dateipfad. 

Verwenden Sie tf.train.Saver, um ein Modell zu speichern. Wenn Sie erneut nachkommen, müssen Sie die var_list angeben, wenn Sie die Modellgröße reduzieren möchten. Die val_list kann tf.trainable_variables oder tf.global_variables sein.

Wo immer Sie das Modell speichern möchten,

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

Vergewissern Sie sich, dass alle Ihre tf.Variable-Namen einen Namen haben, weil Sie sie später mit ihren Namen wiederherstellen können.

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

Stellen Sie sicher, dass der Saver in der entsprechenden Sitzung ausgeführt wird. Denken Sie daran, dass bei Verwendung von tf.train.latest_checkpoint('./') nur der letzte Kontrollpunkt verwendet wird. 

Für tensorflow 2.0 ist es so einfach wie

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

Etwas wiederherstellen:

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

Eager-Modus ist auch eine ungelöste Frage zum Speichern/Wiederherstellen, die nicht einmal die Dokumentation beantwortet hat, obwohl die Docs mit Sicherheit den Anspruch erheben wollen. Hier ist nicht funktionierender Code, den ich geschrieben habe, der versucht, die Saver-Klasse in tensorflow.contrib.eager als Tfe zu verwenden. Mein Code wurde definitiv auf der Festplatte gespeichert ... etwas wurde gespeichert. Das Problem wird wiederhergestellt. Ich habe sogar expliziten Code hinzugefügt, um zuerst alles manuell neu zu erstellen und dann die erlernten Parameter zu laden:

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

Es stellt etwas wieder her und wirft einen ValueError:

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

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

Ich bin auf Version:

tensorflow (1.13.1)
tensorflow-gpu (1.13.1)

Einfacher Weg ist

Sparen:

model.save("model.h5")

Wiederherstellen:

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