新しくて短い方法：simple_save
完全にするために、2セントを追加します。simple_save。 tf.data.Dataset APIを使用したスタンドアロンのコード例もあります。
Python 3;テンソル流 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
)
復元中：
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
})
スタンドアロンの例
次のコードは、デモのためにランダムデータを生成します。
- プレースホルダーを作成することから始めます。それらは実行時にデータを保持します。それらから、私たちは
Datasetを作成し、次にそのIteratorを作成します。イテレータが生成したinput_tensorというテンソルを取得します。これはモデルへの入力として機能します。 - モデル自体は
input_tensor：GRUベースの双方向RNNとそれに続く密分類器から構築されています。なぜそうではないのですか。 - 損失は
Adamで最適化されたsoftmax_cross_entropy_with_logitsです。 2エポック（それぞれ2バッチのうち）の後、「訓練された」モデルをtf.saved_model.simple_saveで保存します。コードをそのまま実行すると、モデルは現在の作業ディレクトリのsimple/というフォルダに保存されます。 - 新しいグラフで、保存したモデルを
tf.saved_model.loader.loadで復元します。プレースホルダとログはgraph.get_tensor_by_nameで、Iterator初期化操作はgraph.get_operation_by_nameでつかみます。 - 最後に、データセット内の両方のバッチについて推論を実行し、保存されたモデルと復元されたモデルの両方が同じ値になることを確認します。彼らはします！
コード：
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)
これは印刷されます。
$ 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
モデルの保存と復元に関する詳細を追加するために回答を改善しています。
/（以降） Tensorflow version 0.11 ：
モデルを保存します。
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)
モデルを復元します。
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
これと、より高度なユースケースは、ここで非常によく説明されています。
TensorFlowバージョン0.11.0RC1以降では、 https://www.tensorflow.org/programmers_guide/meta_graph に従ってtf.train.export_meta_graphおよびtf.train.import_meta_graphを呼び出すことで、モデルを直接保存および復元できます。
モデルを保存する
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_)
TensorFlowバージョン<0.11.0RC1の場合：
保存されたチェックポイントには、モデル/グラフ自体ではなく、モデル内のVariablesの値が含まれています。これは、チェックポイントを復元したときにグラフが同じになることを意味します。
これは、変数チェックポイントを保存するトレーニングループと、前回の実行で保存された変数を復元して予測を計算する評価セクションがある線形回帰の例です。もちろん、変数を元に戻してトレーニングを続けることもできます。
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})
私の環境：Python 3.6、Tensorflow 1.3.0
多くの解決策がありますが、それらのほとんどはtf.train.Saverに基づいています。 Saverによって保存された.ckptをロードするとき、テンソルフローネットワークを再定義するか、あるいは奇妙で覚えにくい名前を使う必要があります。 'placehold_0:0'、'dense/Adam/Weight:0'。ここで私はtf.saved_modelを使用することをお勧めします。これは以下で与えられる最も簡単な例です、あなたは TensorFlowモデルを提供すること ：からさらに学ぶことができます）
モデルを保存します。
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()
モデルをロードします。
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})
モデルには2つの部分があります。モデル定義はSupervisorによってモデルディレクトリにgraph.pbtxtとして保存され、テンソルの数値はmodel.ckpt-1003418のようなチェックポイントファイルに保存されます。
モデル定義はtf.import_graph_defを使って復元でき、重みはSaverを使って復元できます。
しかし、SaverはモデルGraphにアタッチされている変数のリストを保持する特別なコレクションを使用します、そしてこのコレクションはimport_graph_defを使用して初期化されません。今のところ、Ryan Sepassiのアプローチを使用する必要があります - 手動で同じノード名でグラフを作成し、それに重みをロードするためにSaverを使用します。
（あるいは、import_graph_defを使用して手動で変数を作成し、各変数にtf.add_to_collection(tf.GraphKeys.VARIABLES, variable)を使用してからSaverを使用してハッキングすることもできます。）
これも簡単な方法です。
ステップ1：すべての変数を初期化する
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, .....
ステップ2：セッションをモデルSaver内に保存して保存する
model_saver = tf.train.Saver()
# Train the model and save it in the end
model_saver.save(session, "saved_models/CNN_New.ckpt")
ステップ3：モデルを復元する
with tf.Session(graph=graph_cnn) as session:
model_saver.restore(session, "saved_models/CNN_New.ckpt")
print("Model restored.")
print('Initialized')
ステップ4：あなたの変数をチェックする
W1 = session.run(W1)
print(W1)
異なるpythonインスタンスで実行している間は、
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)
ほとんどの場合、tf.train.Saverを使用してディスクから保存および復元するのが最善の選択肢です。
... # 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
グラフ構造自体を保存/復元することもできます（詳細については MetaGraphのドキュメント を参照してください）。デフォルトでは、Saverはグラフ構造を.metaファイルに保存します。復元するにはimport_meta_graph()を呼び出します。これはグラフ構造を復元し、モデルの状態を復元するために使用できるSaverを返します。
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
しかし、もっと早く何かが必要な場合があります。たとえば、早期停止を実装する場合、トレーニング中にモデルが改善されるたびに（検証セットで測定された）チェックポイントを保存し、しばらくの間進捗がない場合は最良のモデルにロールバックします。モデルを改善するたびにディスクに保存すると、トレーニングが非常に遅くなります。トリックは、変数の状態を memory に保存し、後でそれらを復元することです。
... # 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)
簡単な説明：変数Xを作成すると、TensorFlowは自動的に代入操作X/Assignを作成して変数の初期値を設定します。プレースホルダと追加の割り当て操作を作成する代わりに（これでグラフが乱雑になります）、既存の割り当て操作を使用します。各代入opの最初の入力は、それが初期化することになっている変数への参照であり、2番目の入力（assign_op.inputs[1]）は初期値です。したがって、（初期値の代わりに）必要な値を設定するには、feed_dictを使用して初期値を置き換える必要があります。はい、TensorFlowを使用すると、プレースホルダだけでなく、任意の操作の値を入力できるため、これで問題なく機能します。
Yaroslavが言ったように、グラフをインポートし、手動で変数を作成し、そしてSaverを使うことによってgraph_defとチェックポイントから復元することをハックすることができます。
私はこれを私の個人的な使用のために実装したので、私はここでコードを共有したいと思います。
リンク： https://Gist.github.com/nikitakit/6ef3b72be67b86cb7868
（もちろんこれはハックであり、この方法で保存されたモデルが将来のバージョンのTensorFlowで読みやすくなるという保証はありません。）
それが内部的に保存されたモデルであるならば、あなたはちょうどすべての変数のためにrestorerを指定するように
restorer = tf.train.Saver(tf.all_variables())
現在のセッションで変数を復元するためにそれを使用します。
restorer.restore(self._sess, model_file)
外部モデルでは、その変数名から自分の変数名へのマッピングを指定する必要があります。コマンドを使用してモデル変数名を表示できます
python /path/to/tensorflow/tensorflow/python/tools/inspect_checkpoint.py --file_name=/path/to/pretrained_model/model.ckpt
Inspect_checkpoint.pyスクリプトは、Tensorflowソースの './tensorflow/python/tools'フォルダーにあります。
マッピングを指定するには、my Tensorflow-Worklab を使用します。これには、さまざまなモデルの学習と再学習を行うための一連のクラスとスクリプトが含まれています。これには、 ここ にあるResNetモデルの再トレーニングの例が含まれています。
これは、グラフをファイルからロードするのか、実行時に構築するのかによって異なる、2つの基本的なケースに対する私の簡単な解決策です。
この答えはTensorflow 0.12+（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
ファイルからグラフも読み込む
このテクニックを使うとき、あなたのすべてのレイヤ/変数が明示的にユニークな名前を設定していることを確認してください。 そうでなければTensorflowは名前をそれ自身でユニークにするでしょう、そしてそれらはファイルに格納された名前と異なるでしょう。ロードと保存の両方で名前が同じ方法で「マングル」されるため、前の手法では問題ありません。
保存中
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
examples in TensorFlow/skflow をチェックアウトすることもできます。これはsaveおよびrestoreメソッドを提供し、モデルの管理を容易にします。モデルをバックアップする頻度も制御できるパラメータがあります。
ここでの答えはすべて素晴らしいですが、2つのことを追加したいと思います。
まず、@ user7505159の答えを詳しく説明するために、復元するファイル名の先頭に「./」を追加することが重要です。
たとえば、ファイル名に "./"を付けずにグラフを保存することができます。
# 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)
グラフを元に戻すには、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)
あなたはいつも "./"を必要としないでしょう、しかしあなたの環境とTensorFlowのバージョンによっては問題を引き起こすかもしれません。
セッションを再開する前にsess.run(tf.global_variables_initializer())が重要になる可能性があることにも言及したいと思います。
保存したセッションを復元しようとしたときに未初期化変数に関するエラーを受け取った場合は、sess.run(tf.global_variables_initializer())行の前にsaver.restore(sess, save_file)を含めるようにしてください。頭痛を解消することができます。
デフォルトセッションとして tf.train.MonitoredTrainingSession を使用する場合は、保存/復元するためにコードを追加する必要はありません。チェックポイントディレクトリ名をMonitoredTrainingSessionのコンストラクタに渡すだけで、セッションフックを使用してこれらを処理します。
Issue 6255 に記載されているように、
use '**./**model_name.ckpt'
saver.restore(sess,'./my_model_final.ckpt')
の代わりに
saver.restore('my_model_final.ckpt')
新しいTensorflowバージョンによると、tf.train.Checkpointはモデルを保存し復元するための望ましい方法です。
variable.nameベースのチェックポイントを読み書きするtf.train.Saverとは対照的に、
Checkpoint.saveとCheckpoint.restoreはオブジェクトベースのチェックポイントを読み書きします。オブジェクトベースのチェックポイントは、名前付き辺を持つPythonオブジェクト（Layers、Optimizer、変数など）間の依存関係のグラフを保存します。このグラフは、変数を照合するために使用されます。チェックポイントを復元します。これはPythonプログラムの変更に対してより頑強になることができ、熱心に実行するときに変数のcreate-on-create をサポートするのを助けます。 新しいコードにはtf.train.Checkpointよりtf.train.Saverを優先してください 。
これが一例です。
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)
変数をネットワークに保存する using
saver = tf.train.Saver()
saver.save(sess, 'path of save/fileName.ckpt')
ネットワークを復元する 後でまたは別のスクリプトで再利用するには、次のコマンドを使用します。
saver = tf.train.Saver()
saver.restore(sess, tf.train.latest_checkpoint('path of save/')
sess.run(....)
重要なポイント
sessは最初の実行とそれ以降の実行で同じでなければなりません（コヒーレント構造）。saver.restoreは、個々のファイルパスではなく、保存されたファイルのフォルダのパスを必要とします。
モデルを保存するにはtf.train.Saverを使用します。モデルサイズを縮小したい場合は、var_listを指定する必要があります。 val_listは、tf.trainable_variablesまたはtf.global_variablesです。
モデルを保存したい場所はどこでも、
self.saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
...
self.saver.save(sess, filename)
後でそれらの名前を使用してそれらを復元したい場合があるので、すべてのtf.Variableに名前があることを確認してください。
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
セーバーが対応するセッション内で実行されていることを確認してください。 tf.train.latest_checkpoint('./')を使用した場合は、最新のチェックポイントのみが使用されます。
tensorflow 2.0 の場合、 と同じくらい単純です
# Save the model model.save('path_to_my_model.h5')
復元するには：
new_model = tensorflow.keras.models.load_model('path_to_my_model.h5')
イーガーモードはまた、文書でさえも実際には誰も答えていない未解決の保存/復元の質問です。これは私が書いたnon-working codeで、tensorflow.contrib.eager内のSaverクラスをtfeとして使用しようとしています。私のコードは間違いなくディスクに保存されました...何かが保存されました。問題は回復しています。最初に手動ですべてを再作成してから学習したパラメータをロードするための明示的なコードを追加しました。
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")
それは何かを復元してからValueErrorを投げます：
INFO:tensorflow:Restoring parameters from /tmp/iris-1
---------------------------------------------------------------------------
ValueError...
--> names, slices, dtypes = Zip(*restore_specs)
私はバージョンです：
tensorflow (1.13.1)
tensorflow-gpu (1.13.1)
簡単な方法は
保存する：
model.save("model.h5")
リストア：
model = tf.keras.models.load_model("model.h5")