Nachdem Sie ein Modell in Tensorflow trainiert haben:
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
})
Der folgende Code generiert Zufallsdaten für die Demonstration.
Dataset
und dann ihre Iterator
. Wir erhalten den generierten Tensor des Iterators, genannt input_tensor
, der als Eingabe für unser Modell dient.input_tensor
: einem GRU-basierten bidirektionalen RNN, gefolgt von einem dichten Klassifikator. Weil warum nicht.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.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
.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
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.
w1 = tf.Variable(tf.truncated_normal(shape=[10]), name='w1')
w2 = tf.Variable(tf.truncated_normal(shape=[20]), name='w2')
tf.add_to_collection('vars', w1)
tf.add_to_collection('vars', w2)
saver = tf.train.Saver()
sess = tf.Session()
sess.run(tf.global_variables_initializer())
saver.save(sess, 'my-model')
# `save` method will call `export_meta_graph` implicitly.
# you will get saved graph files:my-model.meta
sess = tf.Session()
new_saver = tf.train.import_meta_graph('my-model.meta')
new_saver.restore(sess, tf.train.latest_checkpoint('./'))
all_vars = tf.get_collection('vars')
for v in all_vars:
v_ = sess.run(v)
print(v_)
Für die TensorFlow-Version <0.11.0RC1:
Die gespeicherten Prüfpunkte enthalten Werte für Variable
s 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 Variable
s, 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.
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, .....
Saver
und speichern Sie siemodel_saver = tf.train.Saver()
# Train the model and save it in the end
model_saver.save(session, "saved_models/CNN_New.ckpt")
with tf.Session(graph=graph_cnn) as session:
model_saver.restore(session, "saved_models/CNN_New.ckpt")
print("Model restored.")
print('Initialized')
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).
graph = ... # build the graph
saver = tf.train.Saver() # create the saver after the graph
with ... as sess: # your session object
saver.save(sess, 'my-model')
graph = ... # build the graph
saver = tf.train.Saver() # create the saver after the graph
with ... as sess: # your session object
saver.restore(sess, tf.train.latest_checkpoint('./'))
# now you can use the graph, continue training or whatever
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.
graph = ... # build the graph
for op in [ ... ]: # operators you want to use after restoring the model
tf.add_to_collection('ops_to_restore', op)
saver = tf.train.Saver() # create the saver after the graph
with ... as sess: # your session object
saver.save(sess, 'my-model')
with ... as sess: # your session object
saver = tf.train.import_meta_graph('my-model.meta')
saver.restore(sess, tf.train.latest_checkpoint('./'))
ops = tf.get_collection('ops_to_restore') # here are your operators in the same order in which you saved them to the collection
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
undCheckpoint.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 übertf.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)
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:
sess
muss zwischen dem ersten und dem späteren Durchlauf gleich sein (zusammenhängende Struktur). 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")