Tensorflow: bagaimana cara menyimpan / mengembalikan model?


553

Setelah Anda melatih model di Tensorflow:

  1. Bagaimana Anda menyimpan model yang terlatih?
  2. Bagaimana nanti Anda mengembalikan model yang disimpan ini?

Apakah Anda dapat mengembalikan variabel yang digunakan dalam model awal? Saya juga mencoba masalah yang sama persis tetapi saya tidak dapat menulis set variabel yang digunakan saat melatih model awal (yang saya punya file ckpt)
exAres

Saya belum mencoba dengan model awal. Apakah Anda memiliki struktur jaringan model dengan namanya? Anda harus meniru jaringan dan kemudian memuat bobot dan bias (file ckpt) seperti yang dijelaskan oleh Ryan. Mungkin ada sesuatu yang berubah sejak 15 November dan ada pendekatan yang lebih langsung sekarang, saya tidak yakin
mathetes

Oh baiklah. Saya telah memuat model tensorflow lainnya yang sudah dilatih sebelumnya tetapi sedang mencari spesifikasi variabel dari model awal. Terima kasih.
exAres

1
Jika Anda mengembalikan untuk terus melatih, cukup gunakan pos pemeriksaan Saver. Jika Anda menyimpan model untuk melakukan referensi, cukup tensorflow SavedModel APIs.
HY G

Juga jika Anda menggunakan LSTM, Anda akan memiliki peta dari string ke daftar karakter, pastikan untuk menyimpan dan memuat daftar itu dalam urutan yang sama! Ini tidak tercakup dengan menyimpan bobot model dan jaringan grafik model dan akan membuatnya tampak seperti model Anda tidak dimuat saat Anda mengubah sesi atau perubahan data.
devssh

Jawaban:


119

Documents

Dari dokumen:

Menyimpan

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

Mengembalikan

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

Ini masih beta jadi saya sarankan untuk saat ini. Jika Anda masih ingin menyusuri jalan itu di sini adalah tf.saved_modelpanduan penggunaan

Tensorflow <2

simple_save

Banyak jawaban bagus, untuk kelengkapan saya akan menambahkan 2 sen: simple_save . Juga contoh kode mandiri menggunakan 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
        )

Memulihkan:

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

Contoh mandiri

Posting blog asli

Kode berikut menghasilkan data acak untuk kepentingan demonstrasi.

  1. Kami mulai dengan menciptakan placeholder. Mereka akan menyimpan data saat runtime. Dari mereka, kami membuat Datasetdan kemudian nya Iterator. Kami mendapatkan tensor yang dihasilkan iterator, yang disebut input_tensoryang akan berfungsi sebagai input untuk model kami.
  2. Model itu sendiri dibangun dari input_tensor: RNN dua arah berbasis GRU diikuti oleh classifier padat. Karena mengapa tidak.
  3. Kerugiannya adalah softmax_cross_entropy_with_logits, dioptimalkan dengan Adam. Setelah 2 zaman (masing-masing 2 batch), kami menyimpan model "terlatih" dengan tf.saved_model.simple_save. Jika Anda menjalankan kode apa adanya, maka model akan disimpan dalam folder yang disebut simple/di direktori kerja Anda saat ini.
  4. Dalam grafik baru, kami kemudian mengembalikan model yang disimpan dengan tf.saved_model.loader.load. Kami mengambil tempat penampung dan log dengan graph.get_tensor_by_namedan Iteratoroperasi inisialisasi dengan graph.get_operation_by_name.
  5. Terakhir kami menjalankan inferensi untuk kedua kumpulan dalam dataset, dan memeriksa apakah model yang disimpan dan dipulihkan keduanya menghasilkan nilai yang sama. Mereka melakukannya!

Kode:

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)

Ini akan mencetak:

$ 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
Saya pemula dan saya perlu penjelasan lebih lanjut ...: Jika saya memiliki model CNN, haruskah saya menyimpan hanya 1. input_placeholder 2. label_placeholder, dan 3. output_of_cnn? Atau semua perantara tf.contrib.layers?
Hujan

2
Grafik sepenuhnya dipulihkan. Anda bisa memeriksanya berjalan [n.name for n in graph2.as_graph_def().node]. Seperti yang dikatakan dalam dokumentasi, simpanan sederhana bertujuan menyederhanakan interaksi dengan tensorflow serve, inilah poin dari argumen; Namun variabel lain masih dipulihkan, jika tidak kesimpulan tidak akan terjadi. Ambil saja variabel minat Anda seperti yang saya lakukan dalam contoh. Lihatlah dokumentasi
ted

@ ketika saya akan menggunakan tf.saved_model.simple_save vs tf.train.Saver ()? Dari intuisi saya, saya akan menggunakan tf.train.Saver () selama pelatihan dan untuk menyimpan berbagai momen dalam waktu. Saya akan menggunakan tf.saved_model.simple_save ketika pelatihan dilakukan untuk digunakan dalam produksi. (Saya juga menanyakan hal yang sama dalam komentar di sini )
loco.loop

1
Bagus saya kira, tetapi apakah itu juga berfungsi dengan model mode Eager dan tfe.Saver?
Geoffrey Anderson

1
tanpa global_step sebagai argumen, jika Anda berhenti kemudian mencoba mengambil pelatihan lagi, itu akan berpikir Anda satu langkah satu. Paling tidak itu akan mengacaukan visualisasi papan tensor Anda
Monica Heddneck

252

Saya meningkatkan jawaban saya untuk menambahkan lebih banyak detail untuk menyimpan dan memulihkan model.

Dalam (dan setelah) Tensorflow versi 0.11 :

Simpan model:

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)

Pulihkan model:

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 

Ini dan beberapa use case yang lebih maju telah dijelaskan dengan sangat baik di sini.

Tutorial lengkap cepat untuk menyimpan dan mengembalikan model Tensorflow


3
+1 untuk ini # Akses variabel yang disimpan, langsung cetak (sess.run ('bias: 0')) # Ini akan mencetak 2, yang merupakan nilai bias yang kami simpan. Ini membantu banyak untuk keperluan debugging untuk melihat apakah model dimuat dengan benar. variabel dapat diperoleh dengan "All_varaibles = tf.get_collection (tf.GraphKeys.GLOBAL_VARIABLES". Juga, "sess.run (tf.global_variables_initializer ())" harus sebelum pemulihan.
LGG

1
Apakah Anda yakin kami harus menjalankan global_variables_initializer lagi? Saya memulihkan grafik saya dengan global_variable_initialization, dan itu memberi saya output yang berbeda setiap kali pada data yang sama. Jadi saya berkomentar inisialisasi dan hanya mengembalikan grafik, input variabel dan ops, dan sekarang berfungsi dengan baik
Aditya Shinde

@AdityaShinde Saya tidak mengerti mengapa saya selalu mendapatkan nilai yang berbeda setiap saat. Dan saya tidak memasukkan langkah inisialisasi variabel untuk memulihkan. Saya menggunakan kode saya sendiri btw.
Chaine

@AdityaShinde: Anda tidak perlu init karena nilai sudah diinisialisasi oleh mengembalikan fungsi, jadi hapus saja. Namun, saya tidak yakin mengapa Anda mendapatkan output yang berbeda dengan menggunakan init op.
sankit

5
@sankit Ketika Anda mengembalikan tensor, mengapa Anda menambahkan :0nama?
Sahar Rabinoviz

177

Di (dan setelah) TensorFlow versi 0.11.0RC1, Anda dapat menyimpan dan memulihkan model Anda secara langsung dengan menelepon tf.train.export_meta_graphdan tf.train.import_meta_graphsesuai dengan https://www.tensorflow.org/programmers_guide/meta_graph .

Simpan model

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

Kembalikan model

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
bagaimana cara memuat variabel dari model yang disimpan? Bagaimana cara menyalin nilai di beberapa variabel lain?
neel

9
Saya tidak dapat menjalankan kode ini. Model memang bisa disimpan tetapi saya tidak bisa mengembalikannya. Ini memberi saya kesalahan ini. <built-in function TF_Run> returned a result with an error set
Saad Qureshi

2
Ketika setelah memulihkan saya mengakses variabel seperti yang ditunjukkan di atas, itu berfungsi. Tapi saya tidak bisa mendapatkan variabel lebih langsung menggunakan tf.get_variable_scope().reuse_variables()diikuti oleh var = tf.get_variable("varname"). Ini memberi saya kesalahan: "ValueError: Variabel varname tidak ada, atau tidak dibuat dengan tf.get_variable ()." Mengapa? Haruskah ini tidak mungkin?
Johann Petrak

4
Ini berfungsi baik hanya untuk variabel, tetapi bagaimana Anda bisa mendapatkan akses ke placeholder dan memberi nilai ke nilai setelah memulihkan grafik?
kbrose

11
Ini hanya menunjukkan cara mengembalikan variabel. Bagaimana Anda dapat memulihkan seluruh model dan mengujinya pada data baru tanpa mendefinisikan ulang jaringan?
Chaine

127

Untuk versi TensorFlow <0.11.0RC1:

Pos pemeriksaan yang disimpan berisi nilai untuk Variable s dalam model Anda, bukan model / grafik itu sendiri, yang berarti bahwa grafik harus sama ketika Anda mengembalikan pos pemeriksaan.

Berikut adalah contoh untuk regresi linier di mana ada loop pelatihan yang menyimpan pos pemeriksaan variabel dan bagian evaluasi yang akan mengembalikan variabel yang disimpan dalam jangka sebelumnya dan menghitung prediksi. Tentu saja, Anda juga dapat memulihkan variabel dan melanjutkan pelatihan jika Anda mau.

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

Berikut adalah dokumen untuk Variables, yang mencakup penyimpanan dan pemulihan. Dan di sini adalah dokumen untuk Saver.


1
BENDERA ditentukan oleh pengguna. Inilah contoh mendefinisikannya: github.com/tensorflow/tensorflow/blob/master/tensorflow/…
Ryan Sepassi

dalam format apa yang batch_xperlu? Biner? Array numpy?
pepe

@ pepe Numpy arrary seharusnya baik-baik saja. Dan tipe elemen harus sesuai dengan tipe placeholder. [tautan] tensorflow.org/versions/r0.9/api_docs/python/…
Donny

FLAGS memberi kesalahan undefined. Bisakah Anda memberi tahu saya yang merupakan kekurangan BENDERA untuk kode ini. @RyanSepassi
Muhammad Hannan

Untuk membuatnya eksplisit: versi terbaru dari Tensorflow yang memungkinkan untuk menyimpan model / grafik. [Tidak jelas bagi saya, aspek mana dari jawaban yang berlaku untuk batasan <0,11. Dengan banyaknya jumlah upvote, saya tergoda untuk percaya bahwa pernyataan umum ini masih berlaku untuk versi-versi terbaru.]
bluenote10

78

Lingkungan saya: Python 3.6, Tensorflow 1.3.0

Meskipun ada banyak solusi, sebagian besar didasarkan pada tf.train.Saver. Ketika kami memuat .ckptdiselamatkan oleh Saver, kita harus baik mendefinisikan jaringan tensorflow atau menggunakan beberapa nama yang aneh dan sulit diingat, misalnya 'placehold_0:0', 'dense/Adam/Weight:0'. Di sini saya sarankan untuk menggunakan tf.saved_model, salah satu contoh paling sederhana yang diberikan di bawah ini, Anda dapat belajar lebih banyak dari Melayani Model TensorFlow :

Simpan model:

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

Muat model:

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 untuk contoh hebat API SavedModel. Namun, saya berharap bagian Save the model Anda memperlihatkan loop pelatihan seperti jawaban Ryan Sepassi! Saya menyadari ini adalah pertanyaan lama, tetapi respons ini adalah salah satu dari sedikit (dan berharga) contoh dari SavedModel yang saya temukan di Google.
Dylan F

@ Tom, ini adalah jawaban yang bagus - hanya satu yang ditujukan untuk SavedModel baru. Bisakah Anda melihat pertanyaan SavedModel ini? stackoverflow.com/questions/48540744/…
bluesummers

Sekarang buat semuanya berfungsi dengan benar dengan model TF Eager. Google menyarankan dalam presentasi 2018 mereka agar semua orang menjauh dari kode grafik TF.
Geoffrey Anderson

55

Ada dua bagian dari model, definisi model, disimpan oleh Supervisorseperti graph.pbtxtdalam direktori model dan nilai numerik dari tensor, disimpan ke dalam file pos pemeriksaan sepertimodel.ckpt-1003418 .

Definisi model dapat dipulihkan dengan menggunakan tf.import_graph_def, dan bobot dipulihkan dengan menggunakanSaver .

Namun, Savergunakan daftar koleksi khusus variabel yang terlampir pada model Graph, dan koleksi ini tidak diinisialisasi menggunakan import_graph_def, jadi Anda tidak dapat menggunakan keduanya bersamaan saat ini (ada di peta jalan kami untuk memperbaikinya). Untuk saat ini, Anda harus menggunakan pendekatan Ryan Sepassi - secara manual membuat grafik dengan nama simpul yang identik, dan gunakan Saveruntuk memuat bobot ke dalamnya.

(Atau Anda dapat meretasnya dengan menggunakan import_graph_def, menggunakan , membuat variabel secara manual, dan menggunakan tf.add_to_collection(tf.GraphKeys.VARIABLES, variable)untuk setiap variabel, lalu menggunakan Saver)


Dalam contoh classify_image.py yang menggunakan inceptionv3, hanya graphdef yang dimuat. Apakah ini berarti bahwa sekarang GraphDef juga mengandung Variabel?
jrabary

1
@jrabary Model mungkin telah dibekukan .
Eric Platon

1
Hei, saya baru di tensorflow dan saya kesulitan menyelamatkan model saya. Saya akan sangat menghargai jika Anda bisa membantu saya stackoverflow.com/questions/48083474/...
Ruchir Baronia

39

Anda juga dapat mengambil cara yang lebih mudah ini.

Langkah 1: inisialisasi semua variabel Anda

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

Langkah 2: simpan sesi di dalam model Saverdan simpan

model_saver = tf.train.Saver()

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

Langkah 3: kembalikan model

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

Langkah 4: periksa variabel Anda

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

Saat berjalan dalam instance python yang berbeda, gunakan

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)

Hai, Bagaimana saya bisa menyimpan model setelah misalkan 3000 iterasi, mirip dengan Caffe. Saya menemukan bahwa tensorflow hanya menyimpan model terakhir meskipun saya menggabungkan angka iterasi dengan model untuk membedakannya di antara semua iterasi. Maksud saya model_3000.ckpt, model_6000.ckpt, --- model_100000.ckpt. Bisakah Anda jelaskan mengapa itu tidak menyimpan semua bukan hanya menyimpan 3 iterasi terakhir.
Khan


3
Apakah ada metode untuk menyimpan semua variabel / nama operasi yang tersimpan dalam grafik?
Moondra

21

Dalam kebanyakan kasus, menyimpan dan memulihkan dari disk menggunakan tf.train.Saveropsi terbaik Anda:

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

Anda juga dapat menyimpan / mengembalikan struktur grafik itu sendiri (lihat dokumentasi MetaGraph untuk detailnya). Secara default, Savermenyimpan struktur grafik ke dalam .metafile. Anda dapat menelepon import_meta_graph()untuk mengembalikannya. Ini mengembalikan struktur grafik dan mengembalikan Saveryang dapat Anda gunakan untuk mengembalikan keadaan model:

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

Namun, ada beberapa kasus di mana Anda membutuhkan sesuatu yang lebih cepat. Misalnya, jika Anda menerapkan penghentian awal, Anda ingin menyimpan pos-pos pemeriksaan setiap kali model meningkat selama pelatihan (sebagaimana diukur pada set validasi), maka jika tidak ada kemajuan untuk beberapa waktu, Anda ingin kembali ke model terbaik. Jika Anda menyimpan model ke disk setiap kali itu membaik, itu akan sangat memperlambat pelatihan. Caranya adalah dengan menyimpan status variabel memori , lalu kembalikan saja nanti:

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

Penjelasan cepat: ketika Anda membuat variabel X, TensorFlow secara otomatis membuat operasi penugasan X/Assignuntuk mengatur nilai awal variabel. Alih-alih membuat placeholder dan op penugasan tambahan (yang hanya akan membuat grafik berantakan), kami hanya menggunakan op penugasan yang ada ini. Input pertama dari setiap op penugasan adalah referensi ke variabel yang seharusnya diinisialisasi, dan input kedua ( assign_op.inputs[1]) adalah nilai awal. Jadi untuk menetapkan nilai apa pun yang kita inginkan (alih-alih nilai awal), kita perlu menggunakan feed_dictdan mengganti nilai awal. Ya, TensorFlow memungkinkan Anda memberi nilai untuk op apa pun, tidak hanya untuk placeholder, jadi ini berfungsi dengan baik.


Terima kasih atas jawabannya. Saya punya pertanyaan serupa tentang bagaimana mengkonversi satu file .ckpt ke dua .index dan .data file (katakanlah untuk model awal pra-pelatihan tersedia di tf.slim). Pertanyaan saya ada di sini: stackoverflow.com/questions/47762114/…
Amir

Hei, saya baru di tensorflow dan saya kesulitan menyelamatkan model saya. Saya akan sangat menghargai jika Anda bisa membantu saya stackoverflow.com/questions/48083474/...
Ruchir Baronia

17

Seperti yang dikatakan Yaroslav, Anda dapat meretas pemulihan dari graph_def dan pos pemeriksaan dengan mengimpor grafik, secara manual membuat variabel, dan kemudian menggunakan Saver.

Saya menerapkan ini untuk penggunaan pribadi saya, jadi saya pikir saya akan membagikan kode di sini.

Tautan: https://gist.github.com/nikitakit/6ef3b72be67b86cb7868

(Ini, tentu saja, peretasan, dan tidak ada jaminan bahwa model yang disimpan dengan cara ini akan tetap dapat dibaca di versi TensorFlow yang akan datang.)


14

Jika ini adalah model yang disimpan secara internal, Anda cukup menentukan pemulih semua variabel sebagai

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

dan menggunakannya untuk mengembalikan variabel dalam sesi saat ini:

restorer.restore(self._sess, model_file)

Untuk model eksternal, Anda perlu menentukan pemetaan dari nama variabelnya ke nama variabel Anda. Anda dapat melihat nama variabel model menggunakan perintah

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

Skrip inspect_checkpoint.py dapat ditemukan di folder './tensorflow/python/tools' dari sumber Tensorflow.

Untuk menentukan pemetaan, Anda dapat menggunakan Tensorflow-Worklab saya , yang berisi sekumpulan kelas dan skrip untuk melatih dan melatih kembali berbagai model. Ini termasuk contoh pelatihan ulang model ResNet, yang terletak di sini


all_variables()sekarang tidak digunakan lagi
MiniQuark

Hei, saya baru di tensorflow dan saya kesulitan menyelamatkan model saya. Saya akan sangat menghargai jika Anda bisa membantu saya stackoverflow.com/questions/48083474/...
Ruchir Baronia

12

Inilah solusi sederhana saya untuk dua kasus dasar berbeda pada apakah Anda ingin memuat grafik dari file atau membangunnya selama runtime.

Jawaban ini berlaku untuk Tensorflow 0.12+ (termasuk 1.0).

Membangun kembali grafik dalam kode

Penghematan

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

Memuat

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

Memuat juga grafik dari file

Saat menggunakan teknik ini, pastikan semua layer / variabel Anda secara eksplisit menetapkan nama unik.Kalau tidak, Tensorflow akan membuat nama-nama itu sendiri unik dan dengan demikian mereka akan berbeda dari nama-nama yang tersimpan dalam file. Ini bukan masalah dalam teknik sebelumnya, karena nama-nama "hancur" dengan cara yang sama dalam memuat dan menyimpan.

Penghematan

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

Memuat

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 Memulai jawaban Anda dengan menolak "semua jawaban lain di sini" agak kasar. Yang mengatakan, saya turun karena alasan lain: Anda pasti harus menyimpan semua variabel global, bukan hanya variabel yang bisa dilatih. Sebagai contoh, global_stepvariabel dan rata-rata bergerak normalisasi batch adalah variabel yang tidak dapat dilatihkan, tetapi keduanya jelas layak untuk dihemat. Selain itu, Anda harus lebih jelas membedakan konstruksi grafik dari menjalankan sesi, misalnya Saver(...).save()akan membuat node baru setiap kali Anda menjalankannya. Mungkin bukan yang Anda inginkan. Dan masih ada lagi ...: /
MiniQuark

@MiniQuark ok, terima kasih atas tanggapan Anda, saya akan mengedit jawaban sesuai dengan saran Anda;)
Martin Pecka

10

Anda juga dapat melihat contoh di TensorFlow / skflow , yang menawarkan savedan restoremetode yang dapat membantu Anda mengelola model dengan mudah. Ini memiliki parameter yang Anda juga dapat mengontrol seberapa sering Anda ingin membuat cadangan model Anda.


9

Jika Anda menggunakan tf.train.MonitoredTrainingSession sebagai sesi default, Anda tidak perlu menambahkan kode tambahan untuk melakukan save / restore. Cukup berikan nama dir pos pemeriksaan ke konstruktor MonitoredTrainingSession, itu akan menggunakan kait sesi untuk menangani ini.


menggunakan tf.train.Supervisor akan menangani pembuatan sesi seperti itu untuk Anda, dan memberikan solusi yang lebih lengkap.
Tandai

1
@Mark tf.train.Supervisor sudah tidak digunakan lagi
Changming Sun

Apakah Anda memiliki tautan yang mendukung klaim bahwa Pengawas sudah ditinggalkan? Saya tidak melihat apa pun yang menunjukkan hal ini.
Tandai


Terima kasih untuk URL - Saya memeriksa dengan sumber asli informasi, dan diberitahu bahwa mungkin akan ada sampai akhir seri TF 1.x, tetapi tidak ada jaminan setelah itu.
Markus

8

Semua jawaban di sini luar biasa, tetapi saya ingin menambahkan dua hal.

Pertama, untuk menguraikan jawaban @ user7505159, "./" bisa penting untuk ditambahkan ke awal nama file yang Anda pulihkan.

Misalnya, Anda dapat menyimpan grafik tanpa "./" di nama file seperti:

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

Tetapi untuk mengembalikan grafik, Anda mungkin perlu menambahkan "./" ke nama file:

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

Anda tidak akan selalu membutuhkan "./", tetapi dapat menyebabkan masalah tergantung pada lingkungan dan versi TensorFlow Anda.

Juga ingin menyebutkan bahwa ini sess.run(tf.global_variables_initializer())bisa menjadi penting sebelum mengembalikan sesi.

Jika Anda menerima kesalahan terkait variabel yang tidak diinisialisasi saat mencoba memulihkan sesi yang disimpan, pastikan Anda memasukkan sess.run(tf.global_variables_initializer())sebelum saver.restore(sess, save_file)baris. Ini bisa menyelamatkan Anda dari sakit kepala.


7

Seperti yang dijelaskan dalam edisi 6255 :

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

dari pada

saver.restore('my_model_final.ckpt')

7

Menurut versi Tensorflow baru, tf.train.Checkpointadalah cara yang lebih disukai untuk menyimpan dan memulihkan model:

Checkpoint.savedan Checkpoint.restoremenulis dan membaca pos pemeriksaan berbasis objek, berbeda dengan tf.train.Saver yang menulis dan membaca pos pemeriksaan berdasarkan variabel.name. Checkpointing berbasis objek menyimpan grafik dependensi antara objek Python (Layers, Optimizer, Variables, dll.) Dengan tepi bernama, dan grafik ini digunakan untuk mencocokkan variabel ketika mengembalikan pos pemeriksaan. Itu bisa lebih kuat untuk perubahan dalam program Python, dan membantu untuk mendukung restore-on-create untuk variabel ketika mengeksekusi dengan penuh semangat. Lebih memilih tf.train.Checkpointlebih tf.train.Saveruntuk kode baru .

Berikut ini sebuah contoh:

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)

Informasi lebih lanjut dan contoh di sini.


7

Untuk tensorflow 2.0 , sesederhana

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

Untuk memulihkan:

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

Bagaimana dengan semua operasi tf kustom dan variabel yang bukan bagian dari objek model? Apakah mereka akan diselamatkan entah bagaimana ketika Anda memanggil save () pada model? Saya memiliki berbagai kustom loss dan ekspresi probabilitas-lambat yang digunakan dalam inferensi dan jaringan generasi tetapi mereka bukan bagian dari model saya. Objek model keras saya hanya berisi lapisan padat dan konv. Dalam TF 1 saya baru saja memanggil metode save dan saya bisa yakin bahwa setiap operasi dan tensor yang digunakan dalam grafik saya akan disimpan. Dalam TF2 saya tidak melihat bagaimana operasi yang tidak ditambahkan ke model keras akan diselamatkan.
Kristof

Apakah ada info lebih lanjut tentang memulihkan model di TF 2.0? Saya tidak dapat mengembalikan bobot dari file pos pemeriksaan yang dihasilkan melalui api C, lihat: stackoverflow.com/questions/57944786/…
jregalad


5

tf.keras Model hemat dengan TF2.0

Saya melihat jawaban yang bagus untuk menyimpan model menggunakan TF1.x. Saya ingin memberikan beberapa petunjuk lebih banyak dalam menyimpan tensorflow.kerasmodel yang sedikit rumit karena ada banyak cara untuk menyimpan model.

Di sini saya memberikan contoh menyimpan tensorflow.kerasmodel ke model_pathfolder di bawah direktori saat ini. Ini bekerja dengan baik dengan tensorflow terbaru (TF2.0). Saya akan memperbarui deskripsi ini jika ada perubahan dalam waktu dekat.

Menyimpan dan memuat seluruh model

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

Menyimpan dan memuat model Hanya bobot

Jika Anda tertarik untuk menyimpan hanya bobot model dan kemudian memuat bobot untuk memulihkan model, maka

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

Menyimpan dan memulihkan menggunakan callback pos pemeriksaan 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))

menyimpan model dengan metrik khusus

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

Menyimpan model keras dengan ops kustom

Ketika kita memiliki ops kustom seperti dalam case berikut ( tf.tile), kita perlu membuat fungsi dan membungkus dengan layer Lambda. Jika tidak, model tidak dapat disimpan.

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

Saya pikir saya telah membahas beberapa cara menghemat model tf.keras. Namun, ada banyak cara lain. Berikan komentar di bawah ini jika Anda melihat kasus penggunaan Anda tidak tercakup di atas. Terima kasih!


3

Gunakan tf.train.Saver untuk menyimpan model, remerber, Anda perlu menentukan var_list, jika Anda ingin mengurangi ukuran model. Val_list dapat berupa tf.trainable_variables atau tf.global_variables.


3

Anda dapat menyimpan variabel dalam jaringan menggunakan

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

Untuk memulihkan jaringan untuk digunakan kembali nanti atau dalam skrip lain, gunakan:

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

Poin-poin penting:

  1. sess harus sama antara pertama dan kemudian dijalankan (struktur yang koheren).
  2. saver.restore membutuhkan jalur folder dari file yang disimpan, bukan jalur file individual.

2

Di mana pun Anda ingin menyimpan model,

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

Pastikan, semua Anda tf.Variablememiliki nama, karena Anda mungkin ingin mengembalikannya nanti menggunakan nama mereka. Dan di mana Anda ingin memprediksi,

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

Pastikan saver berjalan di dalam sesi yang sesuai. Ingat bahwa, jika Anda menggunakan tf.train.latest_checkpoint('./'), maka hanya titik pemeriksaan terbaru yang akan digunakan.


2

Saya di Versi:

tensorflow (1.13.1)
tensorflow-gpu (1.13.1)

Cara sederhana adalah

Menyimpan:

model.save("model.h5")

Mengembalikan:

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

2

Untuk tensorflow-2.0

ini sangat sederhana.

import tensorflow as tf

MENYIMPAN

model.save("model_name")

MENGEMBALIKAN

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

1

Mengikuti jawaban @Vishnuvardhan Janapati, berikut adalah cara lain untuk menyimpan dan memuat kembali model dengan lapisan kustom / metrik / kerugian di bawah 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})  

Dengan cara ini, setelah Anda mengeksekusi kode tersebut, dan menyimpan model Anda dengan tf.keras.models.save_modelatau model.saveatau ModelCheckpointcallback, Anda dapat memuat ulang model Anda tanpa perlu objek khusus yang tepat, sesederhana

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

0

Dalam versi baru tensorflow 2.0, proses menyimpan / memuat model jauh lebih mudah. Karena Implementasi Keras API, API tingkat tinggi untuk TensorFlow.

Untuk menyimpan model: Periksa dokumentasi untuk referensi: 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)

Untuk memuat model:

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

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

0

Berikut ini adalah contoh sederhana menggunakan format Tensorflow 2.0 SavedModel (yang merupakan format yang disarankan, menurut dokumen ) untuk pengklasifikasi dataset MNIST sederhana, menggunakan API fungsional Keras tanpa terlalu banyak suka terjadi:

# 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

Apa serving_default?

Ini nama def tanda tangan dari tag yang Anda pilih (dalam hal ini, servetag default dipilih) Juga, di sini dijelaskan cara menemukan tag dan tanda tangan model yang digunakan saved_model_cli.

Penafian

Ini hanya contoh dasar jika Anda hanya ingin menjalankannya, tetapi tidak berarti jawaban yang lengkap - mungkin saya dapat memperbaruinya di masa mendatang. Saya hanya ingin memberikan contoh sederhana menggunakanSavedModel di TF 2.0 karena saya belum melihat satu, bahkan ini sederhana, di mana saja.

@ Tom menjawab adalah contoh SavedModel, tetapi itu tidak akan berfungsi pada Tensorflow 2.0, karena sayangnya ada beberapa perubahan yang melanggar.

@ Vishnuvardhan Janapati menjawab mengatakan TF 2.0, tetapi itu bukan untuk format SavedModel.

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.