it-swarm.com.de

Tensorflow: Wie kann ich ein Modell speichern/wiederherstellen?

Nachdem Sie ein Modell in Tensorflow trainiert haben: 

  1. Wie speichern Sie das trainierte Modell?
  2. Wie stellen Sie dieses gespeicherte Modell später wieder her?
432
mathetes

Neuer und kürzerer Weg: simple_save

Viele gute Antwort, zur Vollständigkeit füge ich meine 2 Cent hinzu: simple_save. Auch ein eigenständiges Codebeispiel, das die tf.data.Dataset-API verwendet.

Python 3; Tensorfluss 1,7

import tensorflow as tf
from tensorflow.python.saved_model import tag_constants

with tf.Graph().as_default():
    with tf.Session as sess:
        ...

        # Saving
        inputs = {
            "batch_size_placeholder": batch_size_placeholder,
            "features_placeholder": features_placeholder,
            "labels_placeholder": labels_placeholder,
        }
        outputs = {"prediction": model_output}
        tf.saved_model.simple_save(
            sess, 'path/to/your/location/', inputs, outputs
        )

Wiederherstellen:

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-Beispiel

Ursprünglicher Blogbeitrag

Der folgende Code generiert Zufallsdaten für die Demonstration.

  1. Wir beginnen mit dem Erstellen der Platzhalter. Sie werden die Daten zur Laufzeit speichern. Aus ihnen erstellen wir die Dataset und dann ihre Iterator. Wir erhalten den generierten Tensor des Iterators, genannt input_tensor, der als Eingabe für unser Modell dient.
  2. Das Modell selbst basiert auf input_tensor: einem GRU-basierten bidirektionalen RNN, gefolgt von einem dichten Klassifikator. Weil warum nicht.
  3. Der Verlust ist ein softmax_cross_entropy_with_logits, optimiert mit Adam. Nach 2 Epochen (von jeweils 2 Chargen) speichern wir das "trainierte" Modell mit tf.saved_model.simple_save. Wenn Sie den Code so ausführen, wie er ist, wird das Modell in einem Ordner mit dem Namen simple/ in Ihrem aktuellen Arbeitsverzeichnis gespeichert.
  4. In einem neuen Diagramm wird das gespeicherte Modell dann mit tf.saved_model.loader.load wiederhergestellt. Wir packen die Platzhalter und Logits mit graph.get_tensor_by_name und die Initialisierungsoperation Iterator mit graph.get_operation_by_name.
  5. Zuletzt führen wir eine Inferenz für beide Stapel im Dataset durch und überprüfen, ob das gespeicherte und das wiederhergestellte Modell beide dieselben Werte ergeben. Tun sie!

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):
    """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
    """
    cell = tf.nn.rnn_cell.GRUCell(10)
    with graph.as_default():
        ((fw_outputs, bw_outputs), (fw_state, bw_state)) = tf.nn.bidirectional_dynamic_rnn(
            cell_fw=cell,
            cell_bw=cell,
            inputs=input_tensor,
            sequence_length=[10] * 32,
            dtype=tf.float32,
            swap_memory=True,
            scope=None)
        outputs = tf.concat((fw_outputs, bw_outputs), 2)
        mean = tf.reduce_mean(outputs, axis=1)
        dense = tf.layers.dense(mean, 5, activation=None)

        return dense


def get_opt_op(graph, logits, labels_tensor):
    """Create optimization operation from model'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
    """
    with graph.as_default():
        with tf.variable_scope('loss'):
            loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
                    logits=logits, labels=labels_tensor, name='xent'),
                    name="mean-xent"
                    )
        with tf.variable_scope('optimizer'):
            opt_op = tf.train.AdamOptimizer(1e-2).minimize(loss)
        return opt_op


if __== '__main__':
    # Set random seed for reproducibility
    # and create synthetic data
    np.random.seed(0)
    features = np.random.randn(64, 10, 30)
    labels = np.eye(5)[np.random.randint(0, 5, (64,))]

    graph1 = tf.Graph()
    with graph1.as_default():
        # Random seed for reproducibility
        tf.set_random_seed(0)
        # Placeholders
        batch_size_ph = tf.placeholder(tf.int64, name='batch_size_ph')
        features_data_ph = tf.placeholder(tf.float32, [None, None, 30], 'features_data_ph')
        labels_data_ph = tf.placeholder(tf.int32, [None, 5], 'labels_data_ph')
        # Dataset
        dataset = tf.data.Dataset.from_tensor_slices((features_data_ph, labels_data_ph))
        dataset = dataset.batch(batch_size_ph)
        iterator = tf.data.Iterator.from_structure(dataset.output_types, dataset.output_shapes)
        dataset_init_op = iterator.make_initializer(dataset, name='dataset_init')
        input_tensor, labels_tensor = iterator.get_next()

        # Model
        logits = model(graph1, input_tensor)
        # Optimization
        opt_op = get_opt_op(graph1, logits, labels_tensor)

        with tf.Session(graph=graph1) as sess:
            # Initialize variables
            tf.global_variables_initializer().run(session=sess)
            for Epoch in range(3):
                batch = 0
                # Initialize dataset (could feed epochs in Dataset.repeat(epochs))
                sess.run(
                    dataset_init_op,
                    feed_dict={
                        features_data_ph: features,
                        labels_data_ph: labels,
                        batch_size_ph: 32
                    })
                values = []
                while True:
                    try:
                        if Epoch < 2:
                            # Training
                            _, value = sess.run([opt_op, logits])
                            print('Epoch {}, batch {} | Sample value: {}'.format(Epoch, batch, value[0]))
                            batch += 1
                        else:
                            # Final inference
                            values.append(sess.run(logits))
                            print('Epoch {}, batch {} | Final inference | Sample value: {}'.format(Epoch, batch, values[-1][0]))
                            batch += 1
                    except tf.errors.OutOfRangeError:
                        break
            # Save model state
            print('\nSaving...')
            cwd = os.getcwd()
            path = os.path.join(cwd, 'simple')
            shutil.rmtree(path, ignore_errors=True)
            inputs_dict = {
                "batch_size_ph": batch_size_ph,
                "features_data_ph": features_data_ph,
                "labels_data_ph": labels_data_ph
            }
            outputs_dict = {
                "logits": logits
            }
            tf.saved_model.simple_save(
                sess, path, inputs_dict, outputs_dict
            )
            print('Ok')
    # Restoring
    graph2 = tf.Graph()
    with graph2.as_default():
        with tf.Session(graph=graph2) as sess:
            # Restore saved values
            print('\nRestoring...')
            tf.saved_model.loader.load(
                sess,
                [tag_constants.SERVING],
                path
            )
            print('Ok')
            # Get restored placeholders
            labels_data_ph = graph2.get_tensor_by_name('labels_data_ph:0')
            features_data_ph = graph2.get_tensor_by_name('features_data_ph:0')
            batch_size_ph = graph2.get_tensor_by_name('batch_size_ph:0')
            # Get restored model output
            restored_logits = graph2.get_tensor_by_name('dense/BiasAdd:0')
            # Get dataset initializing operation
            dataset_init_op = graph2.get_operation_by_name('dataset_init')

            # Initialize restored dataset
            sess.run(
                dataset_init_op,
                feed_dict={
                    features_data_ph: features,
                    labels_data_ph: labels,
                    batch_size_ph: 32
                }

            )
            # Compute inference for both batches in dataset
            restored_values = []
            for i in range(2):
                restored_values.append(sess.run(restored_logits))
                print('Restored values: ', restored_values[i][0])

    # Check if original inference and restored inference are equal
    valid = all((v == rv).all() for v, rv in Zip(values, restored_values))
    print('\nInferences match: ', valid)

Dies wird drucken:

$ 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
52
ted

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

233
sankit

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_)
174
lei du

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.

124
Ryan Sepassi

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

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

53

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)
38
Himanshu Babal

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.

20
MiniQuark

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

17
nikitakit

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

14
Sergey Demyanov

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
11
Martin Pecka

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. 

10
Yuan Tang

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.

8
saetch_g

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. 

8
Changming Sun

Wie in Ausgabe 6255 beschrieben:

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

anstatt 

saver.restore('my_model_final.ckpt')
7
AI4U.ai

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.

3
Amir

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. 
3
Ali Mahdavi

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.

2
Ariel

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. 

1

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')
1
serv-inc

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

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")
0
007fred