Tensorflow: Bir model nasıl kaydedilir / geri yüklenir?


552

Tensorflow'da bir model eğittikten sonra:

  1. Eğitimli modeli nasıl kaydedersiniz?
  2. Bu kaydedilmiş modeli daha sonra nasıl geri yüklersiniz?

Başlangıç ​​modelinde kullanılan değişkenleri geri yükleyebildiniz mi? Ben de aynı sorunu deniyorum ama başlangıç ​​modeli (ki ckpt dosyası var) eğitim sırasında kullanılan değişkenler kümesi yazamıyorum
exAres

Başlangıç ​​modelini denemedim. Modelin ağ yapısına sahip isimleri var mı? Ağı çoğaltmanız ve ardından Ryan'ın açıkladığı gibi ağırlıkları ve önyargıları (ckpt dosyası) yüklemeniz gerekir. Belki Kasım'15'ten beri bir şeyler değişti ve şimdi daha basit bir yaklaşım var, emin değilim
Mathetes

Ohh tamam. Önceden önceden eğitilmiş diğer tensorflow modellerini yükledim ancak başlangıç ​​modelinin değişken özelliklerini arıyordum. Teşekkürler.
exAres

1
Eğitime devam etmek için geri yüklerseniz, Tasarruf kontrol noktalarını kullanın. Modeli başvuru yapmak üzere kaydederseniz, sadece tensorflow SavedModel API'leri.
HY G

Ayrıca LSTM kullanıyorsanız, dizeden bir karakter listesine bir haritanız olacak, bu listeyi aynı sırayla kaydettiğinizden ve yüklediğinizden emin olun! Bu, model ağırlıkları ve model grafik ağı kaydedilerek ele alınmaz ve oturumları değiştirdiğinizde veya veri değiştiğinde modelinizin yüklü olmadığı gibi görünmesini sağlar.
devssh

Yanıtlar:


119

Dokümanlar

Dokümanlardan:

Kayıt etmek

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

Onarmak

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

Bu hala beta, bu yüzden şimdilik tavsiye ederim. Hala o yoldan gitmek istiyorsanız, tf.saved_modelkullanım kılavuzu

Tensorflow <2

simple_save

Çok iyi cevap, bütünlük için 2 sent ekleyeceğim: simple_save . Ayrıca tf.data.DatasetAPI kullanarak bağımsız bir kod örneği .

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
        )

geri Yükleme:

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

Bağımsız örnek

Orijinal blog yayını

Aşağıdaki kod, gösteri uğruna rastgele veriler oluşturur.

  1. Yer tutucuları yaratarak başlıyoruz. Verileri çalışma zamanında tutarlar. Onlardan, Datasetve sonra onu yaratırız Iterator. input_tensorModelimize girdi görevi görecek yineleyicinin oluşturduğu tensörünü alıyoruz.
  2. Modelin kendisi input_tensorGRU tabanlı çift yönlü bir RNN ve ardından yoğun bir sınıflandırıcıdan yapılmıştır. Çünkü neden olmasın.
  3. Kaybı ile softmax_cross_entropy_with_logitsoptimize edilmiş bir Adam. 2 dönemden sonra (her biri 2 parti), "eğitimli" modeli ile kaydediyoruz tf.saved_model.simple_save. Kodu olduğu gibi çalıştırırsanız, model simple/geçerli çalışma dizininizdeki bir klasöre kaydedilir .
  4. Yeni bir grafikte, kaydedilen modeli ile geri yükleriz tf.saved_model.loader.load. Yer tutucuları ve logları graph.get_tensor_by_nameve ile Iteratorbaşlatma işlemini yakalarız graph.get_operation_by_name.
  5. Son olarak, veri kümesindeki her iki grup için bir çıkarım gerçekleştiririz ve kaydedilen ve geri yüklenen modelin her ikisinin de aynı değerleri verdiğini kontrol ederiz. Onlar yapar!

Kod:

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)

Bu yazdırılacak:

$ 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
Ben acemi ve daha fazla açıklamaya ihtiyacım var ...: Bir CNN modelim varsa, ben sadece 1 depolamak gerekir. İnputs_placeholder 2. labels_placeholder ve 3. output_of_cnn? Yoksa tüm ara tf.contrib.layersmý?
Raining

2
Grafik tamamen geri yüklenir. Çalıştığını kontrol edebilirsiniz [n.name for n in graph2.as_graph_def().node]. Belgelerin dediği gibi, basit kaydetme, tensorflow sunumu ile etkileşimi basitleştirmeyi amaçlamaktadır, bu argümanların amacıdır; ancak diğer değişkenler hala geri yüklenir, aksi takdirde sonuç çıkmaz. Örnekte yaptığım gibi ilgi alanlarınızı alın. Dokümanlara
ted

@ted ne zaman tf.saved_model.simple_save vs tf.train.Saver () kullanmalıyım? Sezgimden, eğitim sırasında ve farklı anları zamanında saklamak için tf.train.Saver () kullanırdım. Üretimde kullanmak için eğitim yapıldığında tf.saved_model.simple_save kullanırdım. (Ben bir yorum da aynı sorulan burada )
loco.loop

1
Güzel sanırım, ama Eager modu modelleri ve tfe.Saver ile de çalışır?
Geoffrey Anderson

1
olmadan global_stepdaha sonra tekrar eğitim almaya çalışın bırakırsanız, söz konusu bağımsız değişken olarak, bu size bir adım vardır düşünürler. En azından tensorboard görselleştirmelerinizi berbat edecek
Monica Heddneck

252

Modelleri kaydetmek ve geri yüklemek için daha fazla ayrıntı eklemek için cevabımı geliştiriyorum.

Tensorflow 0.11 sürümünde (ve sonrasında) :

Modeli kaydedin:

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)

Modeli geri yükle:

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 

Bu ve bazı daha gelişmiş kullanım durumları burada çok iyi açıklanmıştır.

Tensorflow modellerini kaydetmek ve geri yüklemek için hızlı ve eksiksiz bir eğitim


3
Bu # için +1 Kaydedilen Değişkenlere doğrudan yazdır (sess.run ('bias: 0')) # Bu, kaydettiğimiz yanlılığın değeri olan 2'yi yazdırır. Hata ayıklama amacıyla, modelin doğru yüklenip yüklenmediğini görmek çok yardımcı olur. değişkenler "All_varaibles = tf.get_collection (tf.GraphKeys.GLOBAL_VARIABLES" ile elde edilebilir. Ayrıca, "sess.run (tf.global_variables_initializer ())" geri yüklemeden önce olmalıdır.
LGG

1
Global_variables_initializer programını tekrar çalıştırmamız gerektiğinden emin misiniz? Grafiğimi global_variable_initialization ile geri yükledim ve bana her seferinde aynı verilerde farklı bir çıktı veriyor. Bu yüzden başlatmayı yorumladım ve sadece grafiği, giriş değişkenini ve op'ları geri yükledim ve şimdi iyi çalışıyor.
Aditya Shinde

@AdityaShinde Her seferinde neden farklı değerler aldığımı anlamıyorum. Ve geri yükleme için değişken başlatma adımını dahil etmedim. Kendi kodumu btw kullanıyorum.
Chaine

@AdityaShinde: Değerler geri yükleme işlevi tarafından zaten başlatıldığından init op'e ihtiyacınız yoktur, bu yüzden kaldırın. Ancak, neden init op kullanarak farklı çıktı aldığınızdan emin değilim.
sankit

5
@sankit Tensörleri geri yüklediğinizde neden :0isimlere ekliyorsunuz ?
Sahar Rabinoviz

177

TensorFlow versiyonunda 0.11.0RC1 yılında (ve sonra), kaydedebilir ve arayarak doğrudan modelini geri tf.train.export_meta_graphve tf.train.import_meta_graphuygun https://www.tensorflow.org/programmers_guide/meta_graph .

Modeli kaydet

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

Modeli geri yükle

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
kaydedilen modelden değişkenler nasıl yüklenir? Başka bir değişkendeki değerler nasıl kopyalanır?
neel

9
Bu kodu çalıştıramıyorum. Model kaydediliyor, ancak geri yükleyemiyorum. Bana bu hatayı veriyor. <built-in function TF_Run> returned a result with an error set
Saad Qureshi

2
Geri yükledikten sonra yukarıda gösterildiği gibi değişkenlere eriştiğimde çalışır. Ama değişkenleri daha doğrudan kullanarak tf.get_variable_scope().reuse_variables()takip edemiyorum var = tf.get_variable("varname"). Bu bana şu hatayı verir: "ValueError: Değişken varname mevcut değil veya tf.get_variable () ile oluşturulmadı." Neden? Bu mümkün olmamalı mı?
Johann Petrak

4
Bu yalnızca değişkenler için iyi çalışır, ancak grafiği geri yükledikten sonra yer tutucuya ve feed değerlerine nasıl erişebilirsiniz?
kbrose

11
Bu sadece değişkenlerin nasıl geri yükleneceğini gösterir. Ağı yeniden tanımlamadan tüm modeli nasıl geri yükleyebilir ve yeni veriler üzerinde nasıl test edebilirsiniz?
Chaine

127

TensorFlow sürümü <0.11.0RC1 için:

Kaydedilen denetim noktaları Variable, model / grafiğin kendisini değil, modelinizdeki değerler için değerler içerir ; bu, denetim noktasını geri yüklediğinizde grafiğin aynı olması gerektiği anlamına gelir.

Aşağıda, değişken kontrol noktalarını kaydeden bir eğitim döngüsü ve önceki bir çalışmada kaydedilen değişkenleri geri yükleyecek ve tahminleri hesaplayacak bir değerlendirme bölümü bulunan doğrusal bir regresyon örneği verilmiştir. Elbette, değişkenleri geri yükleyebilir ve isterseniz eğitime devam edebilirsiniz.

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

İşte dokümanlar için Variablekaydetmek ve yeniden geri kapsayacak s. Ve burada dokümanlar için Saver.


1
FLAGS kullanıcı tanımlıdır. Onları tanımlamanın bir örneği: github.com/tensorflow/tensorflow/blob/master/tensorflow/…
Ryan Sepassi

hangi formatta olması batch_xgerekir? İkili? Numpy dizisi?
pepe

@pepe Numpy arrary iyi olmalı. Öğenin türü, yer tutucunun türüne karşılık gelmelidir. [link] tensorflow.org/versions/r0.9/api_docs/python/…
Donny

FLAGS hata veriyor undefined. Bana bu kod için hangi FLAGS def olduğunu söyleyebilir misiniz. @RyanSepassi
Muhammad Hannan

Tensorflow son sürümleri: Net yapmak için do modeli / grafik saklamak için izin verir. [Cevabın hangi yönlerinin <0.11 kısıtı için geçerli olduğu açık değildi. Çok sayıda upvotes göz önüne alındığında, bu genel ifadenin son sürümler için hala doğru olduğuna inanmak istedim.]
bluenote10

78

Çevrem: Python 3.6, Tensorflow 1.3.0

Birçok çözüm bulunmasına rağmen, çoğu buna dayanmaktadır tf.train.Saver. Biz yüklediğinizde .ckpttarafından kaydedilen Saver, biz ya örneğin tensorflow ağını yeniden tanımlamak veya bazı garip ve zor hatırlanan adı kullanmak zorunda 'placehold_0:0', 'dense/Adam/Weight:0'. Burada tf.saved_model, aşağıda verilen en basit bir örneği kullanmanızı öneririm , bir TensorFlow Modeli Sunmaktan daha fazla bilgi edinebilirsiniz. :

Modeli kaydedin:

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

Modeli yükleyin:

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
+ KaydedilenModel API'sinin harika bir örneği için +1. Bununla birlikte, Modeli kaydet bölümünüzün Ryan Sepassi'nin cevabı gibi bir eğitim döngüsü göstermesini diliyorum ! Bunun eski bir soru olduğunun farkındayım, ancak bu yanıt Google'da bulduğum bir Kayıtlı Model modelinin birkaç (ve değerli) örneğidir.
Dylan F

@Tom bu harika bir cevap - sadece yeni SavedModel'i hedefleyen bir cevap. Bu SavedModel sorusuna bir göz atabilir misiniz? stackoverflow.com/questions/48540744/…
bluesummers

Şimdi TF Eager modelleriyle her şeyin doğru çalışmasını sağlayın. Google, 2018 sunumlarında herkesin TF grafik kodundan kurtulmasını tavsiye etti.
Geoffrey Anderson

55

Modelde iki bölüm vardır , model dizininde Supervisorolduğu gibi kaydedilen model tanımı graph.pbtxtve tensörlerin sayısal değerleri gibi kontrol noktası dosyalarına kaydedilirmodel.ckpt-1003418 .

Model tanımı kullanılarak geri yüklenebilir tf.import_graph_defve ağırlıklar kullanılarak geri yüklenebilirSaver .

Ancak, SaverGraph modeline eklenen değişkenlerin özel koleksiyon tutma listesini kullanır ve bu koleksiyon import_graph_def kullanılarak başlatılmaz, bu yüzden ikisini şu anda birlikte kullanamazsınız (düzeltmek için yol haritamızdadır). Şimdilik, Ryan Sepassi yaklaşımını kullanmalısınız - aynı düğüm adlarına sahip bir grafiği manuel olarak oluşturmalı Saverve ağırlıkları içine yüklemek için kullanmalısınız .

(Alternatif olarak, kullanarak import_graph_def, el ile değişkenler oluşturarak ve tf.add_to_collection(tf.GraphKeys.VARIABLES, variable)her bir değişken için kullanarak ve sonra kullanarak hackleyebilirsiniz Saver)


İnceptionv3 kullanan classify_image.py örneğinde, yalnızca graphdef yüklenir. GraphDef'in şimdi Değişken'i de içerdiği anlamına mı geliyor?
jrabary

1
@jrabary Model muhtemelen donmuş durumda .
Eric Platon

1
Hey, tensorflow'da yeniyim ve modelimi kaydetmekte sorun yaşıyorum. Bana yardım edebilirsen gerçekten çok memnun olur stackoverflow.com/questions/48083474/…
Ruchir Baronia

39

Bu kolay yolu da kullanabilirsiniz.

1.Adım: Tüm değişkenlerinizi başlatın

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.Adım: Oturumu modelin içine Saverkaydedin ve kaydedin

model_saver = tf.train.Saver()

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

3.Adım: Modeli geri yükleyin

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

4.Adım: Değişkeninizi kontrol edin

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

Farklı python örneğinde çalışırken

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)

Merhaba, Caffe'ye benzer 3000 yinelemeden sonra modeli nasıl kaydedebilirim. Tensorflow'un tüm son yinelemeleri birbirinden ayırmak için yineleme numarasını modelle birleştirmesine rağmen, sadece son modelleri kaydettiğini öğrendim. Yani model_3000.ckpt, model_6000.ckpt, --- model_100000.ckpt. Neden tüm bunları kaydetmediğini açıklar mısınız, sadece son 3 tekrardan tasarruf sağlar.
khan


3
Grafikte kayıtlı tüm değişkenleri / işlem adlarını almanın bir yöntemi var mı?
Moondra

21

Çoğu durumda, a kullanarak diskten kaydetmek ve geri yüklemek tf.train.Saveren iyi seçenektir:

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

Grafik yapısını da kaydedebilir / geri yükleyebilirsiniz (ayrıntılar için MetaGraph belgelerine bakın). Varsayılan olarak, Savergrafik yapısını bir .metadosyaya kaydeder . import_meta_graph()Geri yüklemek için arayabilirsiniz . Grafik yapısını geri yükler ve Savermodelin durumunu geri yüklemek için kullanabileceğiniz bir döndürür :

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

Bununla birlikte, çok daha hızlı bir şeye ihtiyacınız olan durumlar vardır. Örneğin, erken durdurma uygularsanız, eğitim sırasında (doğrulama setinde ölçüldüğü gibi) model her geliştiğinde kontrol noktalarını kaydetmek istersiniz, o zaman bir süre ilerleme olmazsa, en iyi modele geri dönmek istersiniz. Modeli her geliştiğinde diske kaydederseniz, eğitimi büyük ölçüde yavaşlatır. İşin püf noktası, değişken durumları belleğe daha sonra bunları geri yüklemek:

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

Hızlı bir açıklama: Bir değişken oluşturduğunuzda X, TensorFlow X/Assigndeğişkenin başlangıç ​​değerini ayarlamak için otomatik olarak bir atama işlemi oluşturur . Yer tutucu ve ekstra atama op'ları oluşturmak yerine (bu sadece grafiği dağınık hale getirir), sadece mevcut atama op'larını kullanıyoruz. Her atama opunun ilk girişi, başlatması gereken değişkene bir referanstır ve ikinci giriş ( assign_op.inputs[1]) başlangıç ​​değeridir. Bu nedenle, istediğimiz herhangi bir değeri ayarlamak için (başlangıç ​​değeri yerine), a kullanmamız feed_dictve başlangıç ​​değerini değiştirmemiz gerekir . Evet, TensorFlow, yalnızca yer tutucular için değil, herhangi bir op için bir değer beslemenizi sağlar, bu nedenle bu iyi çalışır.


Cevap için teşekkürler. Tek bir .ckpt dosyasını iki .index ve .data dosyasına dönüştürme konusunda benzer bir sorum var (tf.slim'de bulunan önceden eğitilmiş başlangıç ​​modelleri için). Benim sorum burada: stackoverflow.com/questions/47762114/…
Amir

Hey, tensorflow'da yeniyim ve modelimi kaydetmekte sorun yaşıyorum. Bana yardım edebilirsen gerçekten çok memnun olur stackoverflow.com/questions/48083474/…
Ruchir Baronia

17

Yaroslav'ın dediği gibi, grafiği içe aktararak, manuel olarak değişkenler oluşturarak ve ardından bir Koruyucu kullanarak bir grafik_def ve denetim noktasından geri yüklemeyi hackleyebilirsiniz.

Bunu kişisel kullanımım için uyguladım, bu yüzden kodu burada paylaşacaktım.

Bağlantı: https://gist.github.com/nikitakit/6ef3b72be67b86cb7868

(Elbette bu bir hack'tir ve bu şekilde kaydedilen modellerin TensorFlow'un gelecekteki sürümlerinde okunabilir kalacağının garantisi yoktur.)


14

Dahili olarak kaydedilmiş bir modelse, tüm değişkenler için bir geri yükleme

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

ve bunu geçerli bir oturumdaki değişkenleri geri yüklemek için kullanın:

restorer.restore(self._sess, model_file)

Harici model için değişken adlarından değişken adlarınıza eşlemeyi belirtmeniz gerekir. Model değişkeni adlarını şu komutu kullanarak görüntüleyebilirsiniz:

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

İnspect_checkpoint.py betiği, Tensorflow kaynağının './tensorflow/python/tools' klasöründe bulunabilir.

Eşlemeyi belirtmek için, farklı modelleri eğitmek ve yeniden eğitmek üzere bir dizi sınıf ve komut dosyası içeren Tensorflow-Worklab'ımı kullanabilirsiniz . Burada bulunan ResNet modellerinin yeniden eğitimine bir örnek içerir


all_variables()artık kullanımdan kaldırıldı
MiniQuark

Hey, tensorflow'da yeniyim ve modelimi kaydetmekte sorun yaşıyorum. Bana yardım edebilirsen gerçekten çok memnun olur stackoverflow.com/questions/48083474/…
Ruchir Baronia

12

Grafiği dosyadan yüklemek veya çalışma zamanı sırasında oluşturmak isteyip istemediğinize bağlı olarak iki temel durum için basit çözümüm.

Bu cevap Tensorflow 0.12+ (1.0 dahil) için geçerlidir.

Koddaki grafiği yeniden oluşturma

Tasarruf

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

Yükleniyor

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

Grafiği bir dosyadan da yükleme

Bu tekniği kullanırken, tüm katmanlarınızın / değişkenlerinizin açıkça benzersiz adları ayarladığından emin olun.Aksi takdirde Tensorflow adları benzersiz hale getirecek ve bu nedenle dosyada saklanan adlardan farklı olacaktır. Önceki teknikte bir sorun değil, çünkü isimler hem yükleme hem de kaydetmede aynı şekilde "karıştırılıyor".

Tasarruf

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

Yükleniyor

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 Cevabınızı "diğer tüm cevapları" reddederek başlatmak biraz zordur. Bununla birlikte, başka nedenlerle reddedildim: sadece eğitilebilir değişkenleri değil, tüm küresel değişkenleri kesinlikle kaydetmelisiniz. Örneğin, global_stepparti normalizasyonunun değişken ve hareketli ortalamaları eğitilemez değişkenlerdir, ancak her ikisi de kesinlikle tasarruf etmeye değer. Ayrıca, grafiğin yapısını oturumu çalıştırmaktan daha açık bir şekilde ayırt etmelisiniz, örneğin Saver(...).save()her çalıştırdığınızda yeni düğümler oluşturacaktır. Muhtemelen istediğin şey değil. Ve daha fazlası var ...: /
MiniQuark

@MiniQuark tamam, geri bildiriminiz için teşekkürler, cevabı önerilerinize göre düzenleyeceğim;)
Martin Pecka

10

Ayrıca kontrol edebilirsiniz örnekler içinde TensorFlow / skflow , teklifler saveve restorekolayca modelleri yönetmenize yardımcı olabilir yöntemleri. Modelinizi ne sıklıkta yedeklemek istediğinizi de kontrol edebileceğiniz parametreler vardır.


9

Varsayılan oturum olarak tf.train.MonitoredTrainingSession kullanıyorsanız, işleri kaydetmek / geri yüklemek için fazladan kod eklemenize gerek yoktur. MonitoredTrainingSession'ın yapıcısına bir kontrol noktası dir adı iletmeniz yeterlidir, bunları işlemek için oturum kancalarını kullanır.


tf.train.Supervisor kullanmak sizin için böyle bir oturum oluşturmayı başaracak ve daha eksiksiz bir çözüm sağlayacaktır.
Mark

1
@Mark tf.train.Supervisor kullanımdan kaldırıldı
Changming Sun

Süpervizörün kullanımdan kaldırıldığı iddiasını destekleyen herhangi bir bağlantınız var mı? Bunun böyle olduğunu gösteren hiçbir şey görmedim.
Mark


URL için teşekkürler - Bilginin orijinal kaynağını kontrol ettim ve muhtemelen TF 1.x serisinin sonuna kadar etrafta olacağı söylendi, ancak bundan sonra garanti yok.
Mark

8

Buradaki tüm cevaplar harika, ama iki şey eklemek istiyorum.

İlk olarak, @ user7505159 yanıtını ayrıntılı olarak açıklamak için, "./" geri yüklediğiniz dosya adının başına eklemek önemli olabilir.

Örneğin, dosya adına "./" içermeyen bir grafiği aşağıdaki gibi kaydedebilirsiniz:

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

Ancak grafiği geri yüklemek için dosya_adı'nın başına bir "./" eklemeniz gerekebilir:

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

Her zaman "./" dosyasına ihtiyacınız olmayacaktır, ancak ortamınıza ve TensorFlow sürümüne bağlı olarak sorunlara neden olabilir.

Ayrıca sess.run(tf.global_variables_initializer()), oturumu geri yüklemeden önce bunun önemli olabileceğini belirtmek isteriz .

Kaydedilmiş bir oturumu geri yüklemeye çalışırken başlatılmamış değişkenlerle ilgili bir hata alıyorsanız sess.run(tf.global_variables_initializer()), saver.restore(sess, save_file)satırın önüne eklediğinizden emin olun . Size bir baş ağrısından kurtarabilir.


7

Sayı 6255'te açıklandığı gibi :

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

onun yerine

saver.restore('my_model_final.ckpt')

7

Yeni Tensorflow versiyonuna göre, tf.train.Checkpointbir modeli kaydetmenin ve geri yüklemenin tercih edilen yolu:

Checkpoint.saveve Checkpoint.restorevariable.name tabanlı kontrol noktalarını yazan ve okuyan tf.train.Saver'ın aksine nesne tabanlı kontrol noktalarını yazıp okuyabilirsiniz. Nesne tabanlı kontrol noktası, adlandırılmış kenarlara sahip Python nesneleri (Katmanlar, Optimize Ediciler, Değişkenler vb.) Arasındaki bağımlılık grafiğini kaydeder ve bu grafik, bir kontrol noktasını geri yüklerken değişkenleri eşleştirmek için kullanılır. Python programındaki değişikliklere karşı daha sağlam olabilir ve istekli bir şekilde yürütülürken değişkenler için oluşturma sırasında geri yüklemeyi desteklemeye yardımcı olur. Tercih tf.train.Checkpointüzerinde tf.train.Saveryeni kodu .

İşte bir örnek:

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)

Daha fazla bilgi ve örnek burada.


7

İçin tensorflow 2.0 , öyle olarak basit olarak

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

Yenilemek:

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

Model nesnesinin parçası olmayan tüm özel tf işlemleri ve değişkenleri ne olacak? Modelde save () öğesini çağırdığınızda bir şekilde kaydedilecekler mi? Çıkarım ve üretim ağında kullanılan çeşitli özel kayıp ve tensorflow-olasılık ifadelerim var, ancak bunlar benim modelimin bir parçası değil. Keras model nesnesim yalnızca yoğun ve dönüşümlü katmanları içeriyor. TF 1'de kaydetme yöntemini yeni aradım ve grafiğimde kullanılan her işlem ve tensörün kaydedileceğinden emin olabilirdim. TF2'de keras modeline bir şekilde eklenmeyen işlemlerin nasıl kaydedileceğini göremiyorum.
Kristof

TF 2.0'da modelleri geri yükleme hakkında daha fazla bilgi var mı? C api üzerinden oluşturulan kontrol noktası dosyalarından ağırlıkları geri yükleyemiyorum, bkz .: stackoverflow.com/questions/57944786/…
jregalad


5

tf.keras Model tasarrufu TF2.0

TF1.x kullanarak modelleri kaydetmek için harika yanıtlar görüyorum. tensorflow.kerasModelleri kaydetmek için birkaç tane daha işaretçi sağlamak istiyorum, bu da bir modeli kaydetmenin birçok yolu olduğu için biraz karmaşık.

Burada, geçerli dizin altındaki klasöre bir tensorflow.kerasmodel kaydetme örneği sağlıyorum model_path. Bu, en son tensorflow (TF2.0) ile iyi çalışır. Yakın gelecekte bir değişiklik olursa bu açıklamayı güncelleyeceğim.

Tüm modeli kaydetme ve yükleme

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 ağırlıklarını kaydetme ve yükleme

Yalnızca model ağırlıklarını kaydetmek ve ardından modeli geri yüklemek için ağırlık yüklemek istiyorsanız,

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 kontrol noktası geri aramasını kullanarak kaydetme ve geri yükleme

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

modeli özel metriklerle kaydetme

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

Keras modelini özel ops ile kaydetme

Aşağıdaki durumda ( tf.tile) olduğu gibi özel op'larımız olduğunda , bir işlev oluşturmanız ve Lambda katmanıyla sarmamız gerekir. Aksi takdirde, model kaydedilemez.

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

Sanırım tf.keras modelini kaydetmenin birçok yolunu ele aldım. Ancak, başka birçok yol var. Kullanım durumunuzun yukarıda yer almadığını görürseniz lütfen aşağıya yorum yapın. Teşekkürler!


3

Bir modeli kaydetmek için tf.train.Saver kullanın, remerber, model boyutunu azaltmak istiyorsanız, var_list'i belirtmeniz gerekir. Val_list tf.trainable_variables veya tf.global_variables olabilir.


3

Şunları yapabilirsiniz ağda değişkenleri kaydetmek kullanarak

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

To şebekeyi geri geç yapılması veya başka bir komut dosyasına yeniden kullanım için, kullanın:

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

Önemli noktalar:

  1. sess ilk ve sonraki koşular arasında aynı olmalıdır (tutarlı yapı).
  2. saver.restore tek bir dosya yoluna değil, kaydedilen dosyaların klasörün yoluna ihtiyaç duyar.

2

Modeli nereye kaydetmek isterseniz,

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

Tüm tf.Variableadlarınızın olduğundan emin olun, çünkü daha sonra adlarını kullanarak geri yüklemek isteyebilirsiniz. Ve tahmin etmek istediğiniz yer,

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

Tasarrufun ilgili oturum içinde çalıştığından emin olun. Unutmayın, eğer kullanırsanız, tf.train.latest_checkpoint('./')sadece en son kontrol noktasının kullanılacağını unutmayın.


2

Versiyondayım:

tensorflow (1.13.1)
tensorflow-gpu (1.13.1)

Basit yol

Kayıt etmek:

model.save("model.h5")

Onarmak:

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

2

Tensorflow-2.0 için

çok basit.

import tensorflow as tf

KAYIT ETMEK

model.save("model_name")

ONARMAK

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

1

@Vishnuvardhan Janapati'nin cevabını takiben, TensorFlow 2.0.0 altında modeli özel katman / metrik / kayıp ile kaydetmenin ve yeniden yüklemenin başka bir yolu

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

Bu şekilde, bu tür kodları yürüttükten ve modelinizi tf.keras.models.save_modelveya model.saveveya ModelCheckpointgeri aramayla kaydettikten sonra, kesin özel nesnelere gerek kalmadan modelinizi yeniden yükleyebilirsiniz.

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

0

Tensorflow 2.0'ın yeni sürümünde, bir modeli kaydetme / yükleme işlemi çok daha kolaydır. Keras API'sının uygulanması nedeniyle, TensorFlow için üst düzey bir API.

Bir modeli kaydetmek için: Referans için belgelere bakın: 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)

Bir model yüklemek için:

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

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

0

İşte kullanarak basit bir örnek Tensorflow 2.0 SavedModel formatını (tavsiye edilen biçimi olan dokümanlara göre ) çok fazla süslü üzerinde gitmeden Keras fonksiyonel API kullanarak basit bir MNIST veri kümesi sınıflandırıcı için,:

# 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

Nedir serving_default?

Seçtiğiniz etiketin imza def'sinin adıdır (bu durumda, varsayılan serveetiket seçilmiştir). Ayrıca, burada kullanarak bir modelin etiketlerinin ve imzalarının nasıl bulunacağını açıklar saved_model_cli.

Feragatler

Bu sadece onu çalıştırmak ve çalıştırmak istiyorsanız sadece temel bir örnektir, ancak hiçbir şekilde tam bir cevap değildir - belki de gelecekte güncelleyebilirim. Ben sadece kullanarak basit bir örnek vermek istedimSavedModelTF 2.0'da çünkü hiçbir yerde bu kadar basit bir tane bile görmedim.

@ Tom'un yanıtı bir RegistModel örneğidir, ancak Tensorflow 2.0'da çalışmaz, çünkü ne yazık ki bazı değişiklikler var.

@ Vishnuvardhan Janapati'nin cevabı TF 2.0 diyor, ancak KaydedildiModel formatı için değil.

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.