Tensorflow:モデルを保存/復元する方法は?


552

Tensorflowでモデルをトレーニングした後:

  1. トレーニング済みモデルをどのように保存しますか?
  2. この保存されたモデルを後でどのように復元しますか?

開始モデルで使用された変数を復元できましたか?私もまったく同じ問題を試していますが、開始モデル(私はckptファイルを持っています)のトレーニング中に使用された変数のセットを書き込めません
exAres

私は初期モデルで試していません。名前のあるモデルのネットワーク構造はありますか?Ryanが説明するように、ネットワークを複製してから、重みとバイアス(ckptファイル)をロードする必要があります。私はわからないんだけど、たぶん何かがNov'15以降に変更された、より簡単な方法は、今があります
mathetes

ああ大丈夫。以前に他の事前トレーニング済みのテンソルフローモデルをロードしましたが、開始モデルの可変仕様を探していました。ありがとう。
exAres

1
トレーニングを続行するために復元する場合は、セーバーチェックポイントを使用してください。モデルを保存して参照する場合は、テンソルフローのSavedModel APIのみを使用します。
HY G

また、LSTMを使用している場合は、文字列から文字のリストへのマップが作成されます。必ず、そのリストを同じ順序で保存およびロードしてください。これはモデルの重みとモデルグラフネットワークの保存ではカバーされないため、セッションを変更したりデータを変更したときにモデルがロードされなかったように見えます。
devssh 2018

回答:


119

文書

ドキュメントから:

セーブ

# Create some variables.
v1 = tf.get_variable("v1", shape=[3], initializer = tf.zeros_initializer)
v2 = tf.get_variable("v2", shape=[5], initializer = tf.zeros_initializer)

inc_v1 = v1.assign(v1+1)
dec_v2 = v2.assign(v2-1)

# Add an op to initialize the variables.
init_op = tf.global_variables_initializer()

# Add ops to save and restore all the variables.
saver = tf.train.Saver()

# Later, launch the model, initialize the variables, do some work, and save the
# variables to disk.
with tf.Session() as sess:
  sess.run(init_op)
  # Do some work with the model.
  inc_v1.op.run()
  dec_v2.op.run()
  # Save the variables to disk.
  save_path = saver.save(sess, "/tmp/model.ckpt")
  print("Model saved in path: %s" % save_path)

戻す

tf.reset_default_graph()

# Create some variables.
v1 = tf.get_variable("v1", shape=[3])
v2 = tf.get_variable("v2", shape=[5])

# Add ops to save and restore all the variables.
saver = tf.train.Saver()

# Later, launch the model, use the saver to restore variables from disk, and
# do some work with the model.
with tf.Session() as sess:
  # Restore variables from disk.
  saver.restore(sess, "/tmp/model.ckpt")
  print("Model restored.")
  # Check the values of the variables
  print("v1 : %s" % v1.eval())
  print("v2 : %s" % v2.eval())

Tensorflow 2

これはまだベータ版なので、今はお勧めしません。それでもその道を進みたい場合は、ここに使用ガイドがありtf.saved_modelます

Tensorflow <2

simple_save

良い答えがたくさんあります。完全を期すために、2セントを追加します:simple_save。また、tf.data.DatasetAPI を使用したスタンドアロンコードの例。

Python 3; Tensorflow 1.14

import tensorflow as tf
from tensorflow.saved_model import tag_constants

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

        # Saving
        inputs = {
            "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
        })

スタンドアロンの例

元のブログ投稿

次のコードは、デモンストレーションのためにランダムデータを生成します。

  1. まず、プレースホルダーを作成します。実行時にデータを保持します。それらから、を作成しDataset、次にを作成しますIterator。イテレータの生成されたテンソルを取得しますinput_tensor。これは、モデルへの入力として機能します。
  2. モデル自体はinput_tensor、GRUベースの双方向RNNとそれに続く密な分類子から構築されます。それはなぜか。
  3. 損失は​​、softmax_cross_entropy_with_logitsで最適化されていAdamます。(それぞれ2バッチの)2エポックの後、「トレーニング済み」モデルをで保存しtf.saved_model.simple_saveます。コードをそのまま実行すると、モデルはsimple/現在の作業ディレクトリにあるフォルダーに保存されます。
  4. 新しいグラフでは、保存したモデルをで復元しtf.saved_model.loader.loadます。でプレースホルダーとロジットをgraph.get_tensor_by_name、でIterator初期化操作を取得しgraph.get_operation_by_nameます。
  5. 最後に、データセットの両方のバッチに対して推論を実行し、保存されたモデルと復元されたモデルの両方が同じ値を生成することを確認します。彼らはします!

コード:

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 __name__ == '__main__':
    # Set random seed for reproducibility
    # and create synthetic data
    np.random.seed(0)
    features = np.random.randn(64, 10, 30)
    labels = np.eye(5)[np.random.randint(0, 5, (64,))]

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

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

        with tf.Session(graph=graph1) as sess:
            # Initialize variables
            tf.global_variables_initializer().run(session=sess)
            for epoch in range(3):
                batch = 0
                # Initialize dataset (could feed epochs in Dataset.repeat(epochs))
                sess.run(
                    dataset_init_op,
                    feed_dict={
                        features_data_ph: features,
                        labels_data_ph: labels,
                        batch_size_ph: 32
                    })
                values = []
                while True:
                    try:
                        if epoch < 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

1
私は初心者であり、さらに説明が必要です...:CNNモデルがある場合は、1。input_placeholder 2. labels_placeholderおよび3. output_of_cnnだけを保存する必要がありますか?またはすべての中間tf.contrib.layers
雨が降る

2
グラフは完全に復元されます。あなたはそれが実行されていることを確認でき[n.name for n in graph2.as_graph_def().node]ます。ドキュメントにあるように、単純な保存はテンソルフローの提供との相互作用を単純化することを目的としており、これが議論のポイントです。ただし、他の変数はまだ復元されます。それ以外の場合、推論は行われません。例で行ったように、関心のある変数を取得してください。ドキュメントを
テッド

@ tt.saved_model.simple_saveとtf.train.Saver()をいつ使用しますか?私の直感から、私はトレーニング中にtf.train.Saver()を使用して、さまざまな瞬間を保存します。本番環境で使用するためのトレーニングが終了したら、tf.saved_model.simple_saveを使用します。(私はここのコメントも同じことを尋ねました)
loco.loop

1
いいですね、でもEagerモードのモデルとtfe.Saverでも動作しますか?
ジェフリーアンダーソン

1
global_step引数なしで、あなたが停止してからもう一度トレーニングを始めようとすると、あなたはワンステップワンだと思います。それは少なくともあなたのテンソルボードの視覚化を台無しにするでしょう
モニカ・ヘドネック

252

モデルの保存と復元の詳細を追加するために、回答を改善しています。

Tensorflowバージョン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モデルを保存および復元するための簡単なチュートリアル


3
これの+1#保存された変数に直接アクセスprint(sess.run( 'bias:0'))#これは、保存したバイアスの値である2を出力します。モデルが正しくロードされているかどうかを確認することは、デバッグの目的で非常に役立ちます。変数は"All_varaibles = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES"を得ることができる。また、 "sess.run(tf.global_variables_initializerは())"の前に復元することがあります。。
LGG

1
global_variables_initializerをもう一度実行する必要がありますか?global_variable_initializationを使用してグラフを復元しましたが、同じデータに対して毎回異なる出力が表示されます。そのため、初期化をコメントアウトして、グラフ、入力変数、および演算を復元したところ、問題なく動作しました。
Aditya Shinde 2017年

@AdityaShindeなぜ毎回常に異なる値を取得するのかわかりません。また、復元用の変数の初期化手順は含まれていません。私は自分のコードを使用しています。
Chaine

@AdityaShinde:値はすでに復元機能によって初期化されているため、初期化操作は必要ないため、削除しました。ただし、なぜinit opを使用して異なる出力が得られたのかはわかりません。
sankit 2017年

5
@sankitテンソルを復元するとき、なぜ:0名前に追加するのですか?
Sahar Rabinoviz 2017

177

TensorFlowバージョン0.11.0RC1で(以降)、あなたは保存することができますし、呼び出すことによって、直接あなたのモデルを復元tf.train.export_meta_graphし、tf.train.import_meta_graphに従ってhttps://www.tensorflow.org/programmers_guide/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_)

4
保存されたモデルから変数をロードする方法は?他の変数の値をコピーするにはどうすればよいですか?
neel

9
このコードを機能させることができません。モデルは保存されますが、復元できません。このエラーが発生しています。<built-in function TF_Run> returned a result with an error set
Saad Qureshi 2017年

2
復元した後、上記のような変数にアクセスすると機能します。しかし、tf.get_variable_scope().reuse_variables()その後にを使用して変数を直接取得することはできません var = tf.get_variable("varname")。これにより、「ValueError:変数varnameが存在しないか、tf.get_variable()で作成されなかった」というエラーが発生します。どうして?これは不可能でしょうか?
Johann Petrak 2017年

4
これは変数に対してのみ有効ですが、グラフを復元した後、プレースホルダーにアクセスして値をフィードするにはどうすればよいですか?
kbrose 2017年

11
これは、変数を復元する方法のみを示しています。ネットワークを再定義せずに、モデル全体を復元して新しいデータでテストするにはどうすればよいですか?
Chaine

127

TensorFlowバージョン<0.11.0RC1の場合:

保存されるチェックポイントにはVariable、モデル/グラフ自体ではなく、モデル内のの値が含まれます。つまり、チェックポイントを復元したときにグラフが同じになるはずです。

変数のチェックポイントを保存するトレーニングループと、以前の実行で保存された変数を復元して予測を計算する評価セクションがある線形回帰の例を次に示します。もちろん、必要に応じて変数を復元してトレーニングを続けることもできます。

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

保存と復元に関するs のドキュメントを次に示しますVariable。そしてここにのドキュメントがありSaverます。


1
FLAGSはユーザー定義です。これらを定義する例を次に示します。github.com
Ryan Sepassi

どの形式であるbatch_x必要がありますか?バイナリ?Numpy配列?
pepe

@pepe Numpyの到着は大丈夫です。また、要素のタイプはプレースホルダーのタイプに対応している必要があります。[リンク] tensorflow.org/versions/r0.9/api_docs/python/...
ドニー

FLAGSはエラーを出しますundefined。このコードのFLAGSのdefを教えてください。@RyanSepassi
Muhammad Hannan

それが明示的にするには:Tensorflowの最近のバージョンではないモデル/グラフを保存することができます。[私には不明確でしたが、回答のどの側面が<0.11制約に当てはまるかはわかりません。多数の賛成票を与えられた私は、この一般的な声明が最近のバージョンでも依然として当てはまると信じたくなりました。]
bluenote10

78

私の環境:Python 3.6、Tensorflow 1.3.0

多くの解決策がありましたが、それらのほとんどはに基づいていtf.train.Saverます。.ckptによって保存されたものを読み込むときはSaver、テンソルフローネットワークを再定義するか、奇妙で覚えにくい名前(たとえば'placehold_0:0')を使用する必要があります'dense/Adam/Weight:0'。ここではtf.saved_model、以下に示す最も単純な例の1つを使用することをお勧めします。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})

4
+1はSavedModel APIの良い例です。ただし、「モデルの保存」セクションにRyan Sepassiの回答のようなトレーニングループが表示されていれば幸いです。これは古い質問ですが、この回答は、Googleで見つけたSavedModelの数少ない(そして貴重な)例の1つです。
ディランF

@Tomこれは素晴らしい答えです-新しいSavedModelを目的とした1つだけです。このSavedModelの質問を見てください。stackoverflow.com/questions/48540744/...
bluesummers

次に、TF Eagerモデルですべて正しく機能するようにします。Googleは2018年のプレゼンテーションで、誰もがTFグラフコードから離れるようアドバイスしました。
ジェフリーアンダーソン

55

モデルには2つの部分があります。モデル定義は、モデルディレクトリにによって保存さSupervisorgraph.pbtxt、テンソルの数値はのようなチェックポイントファイルに保存されますmodel.ckpt-1003418

モデル定義はを使用して復元できtf.import_graph_def、重みはを使用して復元されSaverます。

ただし、Saverモデルグラフにアタッチされた変数のリストを保持する特別なコレクションを使用します。このコレクションはimport_graph_defを使用して初期化されないため、現時点では2つを一緒に使用することはできません(修正のためのロードマップ上にあります)。今のところ、Ryan Sepassiのアプローチを使用する必要があります-同じノード名でグラフを手動で作成し、それにSaverウェイトをロードするために使用します。

(またはimport_graph_def、を使用tf.add_to_collection(tf.GraphKeys.VARIABLES, variable)して変数を手動で作成し、各変数に使用してからを使用してハッキングすることもできますSaver


inceptionv3を使用するclassify_image.pyの例では、graphdefのみがロードされます。GraphDefにも変数が含まれているということですか?
jrabary 2016

1
@jrabaryモデルはおそらくフリーズされています
Eric Platon 2016年

1
ねえ、私はtensorflowが初めてで、モデルの保存に問題があります。あなたは私を助けることができる場合、私はそれを本当に感謝stackoverflow.com/questions/48083474/...
Ruchir Baronia

39

これをもっと簡単に行うこともできます。

ステップ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)

こんにちは、Caffeと同様に、3000回の反復後にモデルを保存するにはどうすればよいですか。すべての反復でそれを区別するためにモデルに反復番号を連結しているにもかかわらず、テンソルフローは最後のモデルのみを保存することがわかりました。つまり、model_3000.ckpt、model_6000.ckpt、--- model_100000.ckptです。最後の3回の繰り返しのみを保存するのではなく、なぜすべてを保存しないのか、親切に説明してください。
2017


3
すべての変数/操作名をグラフ内に保存する方法はありますか?
Moondra 2017年

21

ほとんどの場合、aを使用したディスクからの保存と復元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

ただし、もっと高速なものが必要な場合もあります。たとえば、早期停止を実装する場合は、トレーニング中にモデルが改善するたびにチェックポイントを保存する必要があります(検証セットで測定)。その後、しばらく進行がない場合は、最適なモデルにロールバックする必要があります。改善するたびにモデルをディスクに保存すると、トレーニングが大幅に遅くなります。トリックは、変数の状態をメモリに保存し、後でそれらを復元することです。

... # 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を作成して、変数の初期値を設定します。プレースホルダーと追加の代入演算(グラフが煩雑になるだけ)を作成する代わりに、これらの既存の代入演算を使用します。各代入assign_op.inputs[1]演算の最初の入力は、初期化することになっている変数への参照であり、2番目の入力()は初期値です。したがって、(初期値ではなく)必要な値を設定するには、aを使用しfeed_dictて初期値を置き換える必要があります。はい、TensorFlowを使用すると、プレースホルダだけでなく、あらゆる演算の値をフィードできるため、これは正常に機能します。


答えてくれてありがとう。1つの.ckptファイルを2つの.indexファイルと.dataファイルに変換する方法について同様の質問があります(たとえば、tf.slimで利用可能な事前トレーニング済みの開始モデルなど)。私の質問はここにある:stackoverflow.com/questions/47762114/...
アミール

ねえ、私はtensorflowが初めてで、モデルの保存に問題があります。あなたは私を助けることができる場合、私はそれを本当に感謝stackoverflow.com/questions/48083474/...
Ruchir Baronia

17

Yaroslavが言ったように、グラフをインポートし、手動で変数を作成してからSaverを使用することにより、graph_defとチェックポイントからの復元をハックできます。

私はこれを個人的な使用のために実装したので、ここでコードを共有します。

リンク:https : //gist.github.com/nikitakit/6ef3b72be67b86cb7868

(これはもちろんハックであり、この方法で保存されたモデルがTensorFlowの将来のバージョンでも読み取り可能なままである保証はありません。)


14

内部的に保存されたモデルの場合は、すべての変数の復元を

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モデルの再トレーニングの例が含まれています


all_variables()は現在廃止されています
MiniQuark 2017年

ねえ、私はtensorflowが初めてで、モデルの保存に問題があります。あなたは私を助けることができる場合、私はそれを本当に感謝stackoverflow.com/questions/48083474/...
Ruchir Baronia

12

これは、実行時にファイルからグラフをロードするか、グラフを作成するかが異なる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

-1「ここにある他のすべての回答」を却下して回答を始めるのは少し厳しいです。そうは言っても、私は他の理由で反対票を投じました。トレーニング可能な変数だけでなく、すべてのグローバル変数を確実に保存する必要があります。たとえば、global_step変数とバッチ正規化の移動平均はトレーニング不可能な変数ですが、どちらも確実に保存する価値があります。また、グラフのSaver(...).save()作成とセッションの実行をより明確に区別する必要があります。たとえば、グラフを実行するたびに新しいノードが作成されます。おそらくあなたが望むものではありません。そしてもっとあります...:/
ミニクォーク2017年

@MiniQuarkわかりました。フィードバックをありがとう、あなたの提案に従って回答を編集します;)
Martin Pecka

10

また、チェックアウトすることができますTensorFlow / skflow、申し出saverestore簡単にあなたのモデルを管理することができた方法を。これには、モデルをバックアップする頻度を制御できるパラメータもあります。


9

tf.train.MonitoredTrainingSessionをデフォルトセッションとして使用する場合、保存/復元を行うために追加のコードを追加する必要はありません。チェックポイントディレクトリ名をMonitoredTrainingSessionのコンストラクターに渡すだけで、セッションフックを使用してこれらを処理します。


tf.train.Supervisorを使用すると、このようなセッションの作成が処理され、より完全なソリューションが提供されます。
マーク

1
@Mark tf.train.Supervisorは非推奨
Sun

スーパーバイザーが非推奨であるという主張を支持するリンクはありますか?これが事実であることを示すものは何も見当たりませんでした。
マーク


URLをありがとう-情報の元の情報源を確認したところ、おそらくTF 1.xシリーズの最後まで存在すると言われましたが、その後は保証されません。
マーク

8

ここでの答えはすべて素晴らしいですが、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)行の前に含めるようにしてください。それはあなたの頭痛を救うことができます。


7

問題6255で説明されているように:

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

の代わりに

saver.restore('my_model_final.ckpt')

7

新しいTensorflowバージョンによると、tf.train.Checkpointはモデルの保存と復元に適した方法です。

Checkpoint.saveそしてCheckpoint.restore、書き込みや読み取り書き込み、variable.nameベースのチェックポイントを読み込みtf.train.Saverとは対照的に、チェックポイントをオブジェクトベース。オブジェクトベースのチェックポイントは、名前付きエッジを持つPythonオブジェクト(レイヤー、オプティマイザー、変数など)間の依存関係のグラフを保存します。このグラフは、チェックポイントを復元するときに変数を照合するために使用されます。Pythonプログラムの変更に対してより堅牢になり、熱心に実行するときの変数のcreate-on-createをサポートするのに役立ちます。新しいコードを優先tf.train.Checkpointtf.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)

詳細と例はこちら。


7

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

モデルオブジェクトの一部ではないすべてのカスタムtf操作と変数についてはどうですか?モデルでsave()を呼び出すと、どういうわけか保存されますか?推論および生成ネットワークで使用されるさまざまなカスタム損失およびテンソルフロー確率式がありますが、それらは私のモデルの一部ではありません。私のケラスモデルオブジェクトには、密層と変換層のみが含まれています。TF 1ではsaveメソッドを呼び出しただけで、グラフで使用されているすべての演算とテンソルが確実に保存されるようになりました。TF2では、ケラスモデルに追加されなかった操作がどのように保存されるのかわかりません。
クリストフ

TF 2.0でのモデルの復元に関する詳細はありますか?私はC APIを介して生成されたチェックポイント・ファイルからの重みを復元することはできません、以下を参照してくださいstackoverflow.com/questions/57944786/...
jregalad


5

tf.kerasモデルでの保存 TF2.0

TF1.xを使用してモデルを保存するための素晴らしい答えを見つけました。tensorflow.kerasモデルを保存するには多くの方法があるので、少し複雑なモデルの保存にいくつかのポインタを提供したいと思います。

ここでは、現在のディレクトリの下のフォルダにtensorflow.kerasモデルを保存する例を示しmodel_pathます。これは最新のテンソルフロー(TF2.0)でうまく機能します。近い将来変更がある場合は、この説明を更新します。

モデル全体の保存と読み込み

import tensorflow as tf
from tensorflow import keras
mnist = tf.keras.datasets.mnist

#import data
(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# create a model
def create_model():
  model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(512, activation=tf.nn.relu),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation=tf.nn.softmax)
    ])
# compile the model
  model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
  return model

# Create a basic model instance
model=create_model()

model.fit(x_train, y_train, epochs=1)
loss, acc = model.evaluate(x_test, y_test,verbose=1)
print("Original model, accuracy: {:5.2f}%".format(100*acc))

# Save entire model to a HDF5 file
model.save('./model_path/my_model.h5')

# Recreate the exact same model, including weights and optimizer.
new_model = keras.models.load_model('./model_path/my_model.h5')
loss, acc = new_model.evaluate(x_test, y_test)
print("Restored model, accuracy: {:5.2f}%".format(100*acc))

モデルの重みのみの保存と読み込み

モデルの重みのみを保存して、モデルを復元するために重みをロードすることに関心がある場合は、

model.fit(x_train, y_train, epochs=5)
loss, acc = model.evaluate(x_test, y_test,verbose=1)
print("Original model, accuracy: {:5.2f}%".format(100*acc))

# Save the weights
model.save_weights('./checkpoints/my_checkpoint')

# Restore the weights
model = create_model()
model.load_weights('./checkpoints/my_checkpoint')

loss,acc = model.evaluate(x_test, y_test)
print("Restored model, accuracy: {:5.2f}%".format(100*acc))

kerasチェックポイントコールバックを使用した保存と復元

# include the epoch in the file name. (uses `str.format`)
checkpoint_path = "training_2/cp-{epoch:04d}.ckpt"
checkpoint_dir = os.path.dirname(checkpoint_path)

cp_callback = tf.keras.callbacks.ModelCheckpoint(
    checkpoint_path, verbose=1, save_weights_only=True,
    # Save weights, every 5-epochs.
    period=5)

model = create_model()
model.save_weights(checkpoint_path.format(epoch=0))
model.fit(train_images, train_labels,
          epochs = 50, callbacks = [cp_callback],
          validation_data = (test_images,test_labels),
          verbose=0)

latest = tf.train.latest_checkpoint(checkpoint_dir)

new_model = create_model()
new_model.load_weights(latest)
loss, acc = new_model.evaluate(test_images, test_labels)
print("Restored model, accuracy: {:5.2f}%".format(100*acc))

カスタム指標でモデルを保存する

import tensorflow as tf
from tensorflow import keras
mnist = tf.keras.datasets.mnist

(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# Custom Loss1 (for example) 
@tf.function() 
def customLoss1(yTrue,yPred):
  return tf.reduce_mean(yTrue-yPred) 

# Custom Loss2 (for example) 
@tf.function() 
def customLoss2(yTrue, yPred):
  return tf.reduce_mean(tf.square(tf.subtract(yTrue,yPred))) 

def create_model():
  model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(512, activation=tf.nn.relu),  
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation=tf.nn.softmax)
    ])
  model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy', customLoss1, customLoss2])
  return model

# Create a basic model instance
model=create_model()

# Fit and evaluate model 
model.fit(x_train, y_train, epochs=1)
loss, acc,loss1, loss2 = model.evaluate(x_test, y_test,verbose=1)
print("Original model, accuracy: {:5.2f}%".format(100*acc))

model.save("./model.h5")

new_model=tf.keras.models.load_model("./model.h5",custom_objects={'customLoss1':customLoss1,'customLoss2':customLoss2})

カスタムopsを使用したケラスモデルの保存

次のケース(tf.tile)のようにカスタムopがある場合、関数を作成してLambdaレイヤーでラップする必要があります。そうしないと、モデルを保存できません。

import numpy as np
import tensorflow as tf
from tensorflow.keras.layers import Input, Lambda
from tensorflow.keras import Model

def my_fun(a):
  out = tf.tile(a, (1, tf.shape(a)[0]))
  return out

a = Input(shape=(10,))
#out = tf.tile(a, (1, tf.shape(a)[0]))
out = Lambda(lambda x : my_fun(x))(a)
model = Model(a, out)

x = np.zeros((50,10), dtype=np.float32)
print(model(x).numpy())

model.save('my_model.h5')

#load the model
new_model=tf.keras.models.load_model("my_model.h5")

tf.kerasモデルを保存する多くの方法のいくつかをカバーしたと思います。ただし、他にも多くの方法があります。ユースケースが上記でカバーされていない場合は、以下にコメントしてください。ありがとう!


3

tf.train.Saverを使用してモデルを保存します。モデルサイズを縮小する場合は、var_listを指定する必要があります。val_listには、tf.trainable_variablesまたはtf.global_variablesを指定できます。


3

あなたはできるネットワーク内の変数を保存使用して

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

重要なポイント:

  1. sess 最初の実行と後の実行で同じでなければなりません(一貫した構造)。
  2. saver.restore 個別のファイルパスではなく、保存されたファイルのフォルダのパスが必要です。

2

モデルを保存する場所はどこでも、

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('./')、最新のチェックポイントのみが使用されることに注意してください。


2

私はバージョンにいます:

tensorflow (1.13.1)
tensorflow-gpu (1.13.1)

簡単な方法は

セーブ:

model.save("model.h5")

戻す:

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

2

tensorflow-2.0の場合

とても簡単です。

import tensorflow as tf

セーブ

model.save("model_name")

戻す

model = tf.keras.models.load_model('model_name')

1

@Vishnuvardhan Janapatiの回答に続き、TensorFlow 2.0.0カスタムレイヤー/メトリック/損失使用してモデルを保存および再ロードする別の方法を次に示します

import tensorflow as tf
from tensorflow.keras.layers import Layer
from tensorflow.keras.utils.generic_utils import get_custom_objects

# custom loss (for example)  
def custom_loss(y_true,y_pred):
  return tf.reduce_mean(y_true - y_pred)
get_custom_objects().update({'custom_loss': custom_loss}) 

# custom loss (for example) 
class CustomLayer(Layer):
  def __init__(self, ...):
      ...
  # define custom layer and all necessary custom operations inside custom layer

get_custom_objects().update({'CustomLayer': CustomLayer})  

このようにして、このようなコードを実行し、tf.keras.models.save_modelor model.saveまたはModelCheckpointcallback を使用してモデルを保存すると、次のように、正確なカスタムオブジェクトを必要とせずにモデルを再ロードできます。

new_model = tf.keras.models.load_model("./model.h5"})

0

新しいバージョンのtensorflow 2.0では、モデルの保存/読み込みのプロセスがはるかに簡単になりました。TensorFlowの高レベルAPIであるKeras APIの実装のため。

モデルを保存するには:ドキュメントを参照して確認してください:https : //www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/models/save_model

tf.keras.models.save_model(model_name, filepath, save_format)

モデルをロードするには:

https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/models/load_model

model = tf.keras.models.load_model(filepath)

0

ここで使用した簡単な例であるTensorflow 2.0 SavedModelの形式を(、推奨される形式であるドキュメントによるに行くあまり派手なしKeras機能APIを使用して、簡単なMNISTデータセットの分類器のために:

# Imports
import tensorflow as tf
from tensorflow.keras.layers import Input, Dense, Flatten
from tensorflow.keras.models import Model
import matplotlib.pyplot as plt

# Load data
mnist = tf.keras.datasets.mnist # 28 x 28
(x_train,y_train), (x_test, y_test) = mnist.load_data()

# Normalize pixels [0,255] -> [0,1]
x_train = tf.keras.utils.normalize(x_train,axis=1)
x_test = tf.keras.utils.normalize(x_test,axis=1)

# Create model
input = Input(shape=(28,28), dtype='float64', name='graph_input')
x = Flatten()(input)
x = Dense(128, activation='relu')(x)
x = Dense(128, activation='relu')(x)
output = Dense(10, activation='softmax', name='graph_output', dtype='float64')(x)
model = Model(inputs=input, outputs=output)

model.compile(optimizer='adam',
             loss='sparse_categorical_crossentropy',
             metrics=['accuracy'])

# Train
model.fit(x_train, y_train, epochs=3)

# Save model in SavedModel format (Tensorflow 2.0)
export_path = 'model'
tf.saved_model.save(model, export_path)

# ... possibly another python program 

# Reload model
loaded_model = tf.keras.models.load_model(export_path) 

# Get image sample for testing
index = 0
img = x_test[index] # I normalized the image on a previous step

# Predict using the signature definition (Tensorflow 2.0)
predict = loaded_model.signatures["serving_default"]
prediction = predict(tf.constant(img))

# Show results
print(np.argmax(prediction['graph_output']))  # prints the class number
plt.imshow(x_test[index], cmap=plt.cm.binary)  # prints the image

なにserving_default

これは、選択したタグの署名定義の名前です(この場合、デフォルトのserveタグが選択されています)。また、ここでは、を使用してモデルのタグと署名を見つける方法について説明しますsaved_model_cli

免責事項

これは、起動して実行したい場合の基本的な例にすぎませんが、完全な答えではありません。将来的には更新できるかもしれません。私は単純な例を使ってSavedModelはTF 2.0でです。これはどこにも見られないためです。

@ Tomの答えはSavedModelの例ですが、Tensorflow 2.0では機能しません。残念ながら、いくつかの重大な変更があるためです。

@ Vishnuvardhan Janapatiの答えはTF 2.0と言っていますが、それはSavedModelフォーマット用ではありません。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.