python - Tensorflow: किसी मॉडल को बचाने/पुनर्स्थापित करने के लिए कैसे?




machine-learning model (16)

केरास मॉडल के साथ बचत TF2.0.0rc2

मैं TF1.x का उपयोग करके मॉडल को बचाने के लिए शानदार उत्तर देखता हूं। मैं बचत tensorflow.keras मॉडल में कुछ और संकेत देना चाहता हूं जो थोड़ा जटिल है क्योंकि एक मॉडल को बचाने के कई तरीके हैं।

यहां मैं एक tensorflow.keras मॉडल को model_path वर्तमान निर्देशिका के तहत फ़ोल्डर में सहेजने का एक उदाहरण प्रदान कर रहा हूं । यह सबसे हाल के टेंसरफ़्लो (TF2.0.0rc2) के साथ अच्छी तरह से काम करता है। निकट भविष्य में कोई बदलाव होने पर मैं इस विवरण को अपडेट करूंगा।

पूरे मॉडल को सहेजना और लोड करना

 import tensorflow as tf from tensorflow import keras mnist = tf.keras.datasets.mnist #import data (x_train, y_train),(x_test, y_test) = mnist.load_data() x_train, x_test = x_train / 255.0, x_test / 255.0 # create a model def create_model(): model = tf.keras.models.Sequential([ tf.keras.layers.Flatten(input_shape=(28, 28)), tf.keras.layers.Dense(512, activation=tf.nn.relu), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(10, activation=tf.nn.softmax) ]) # compile the model model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) return model # Create a basic model instance model=create_model() model.fit(x_train, y_train, epochs=1) loss, acc = model.evaluate(x_test, y_test,verbose=1) print("Original model, accuracy: {:5.2f}%".format(100*acc)) # Save entire model to a HDF5 file model.save('./model_path/my_model.h5') # Recreate the exact same model, including weights and optimizer. new_model = keras.models.load_model('./model_path/my_model.h5') loss, acc = new_model.evaluate(x_test, y_test) print("Restored model, accuracy: {:5.2f}%".format(100*acc)) 

सहेजना और लोड करना मॉडल वजन केवल

यदि आप केवल मॉडल वजन बचाने में रुचि रखते हैं और फिर मॉडल को पुनर्स्थापित करने के लिए भार लोड करते हैं, तो

 model.fit(x_train, y_train, epochs=5) loss, acc = model.evaluate(x_test, y_test,verbose=1) print("Original model, accuracy: {:5.2f}%".format(100*acc)) # Save the weights model.save_weights('./checkpoints/my_checkpoint') # Restore the weights model = create_model() model.load_weights('./checkpoints/my_checkpoint') loss,acc = model.evaluate(x_test, y_test) print("Restored model, accuracy: {:5.2f}%".format(100*acc)) 

केरस चेकपॉइंट कॉलबैक का उपयोग करके सहेजना और पुनर्स्थापित करना

 # include the epoch in the file name. (uses `str.format`) checkpoint_path = "training_2/cp-{epoch:04d}.ckpt" checkpoint_dir = os.path.dirname(checkpoint_path) cp_callback = tf.keras.callbacks.ModelCheckpoint( checkpoint_path, verbose=1, save_weights_only=True, # Save weights, every 5-epochs. period=5) model = create_model() model.save_weights(checkpoint_path.format(epoch=0)) model.fit(train_images, train_labels, epochs = 50, callbacks = [cp_callback], validation_data = (test_images,test_labels), verbose=0) latest = tf.train.latest_checkpoint(checkpoint_dir) new_model = create_model() new_model.load_weights(latest) loss, acc = new_model.evaluate(test_images, test_labels) print("Restored model, accuracy: {:5.2f}%".format(100*acc)) 

कस्टम मैट्रिक्स के साथ बचत मॉडल

 import tensorflow as tf from tensorflow import keras mnist = tf.keras.datasets.mnist (x_train, y_train),(x_test, y_test) = mnist.load_data() x_train, x_test = x_train / 255.0, x_test / 255.0 # Custom Loss1 (for example) @tf.function() def customLoss1(yTrue,yPred): return tf.reduce_mean(yTrue-yPred) # Custom Loss2 (for example) @tf.function() def customLoss2(yTrue, yPred): return tf.reduce_mean(tf.square(tf.subtract(yTrue,yPred))) def create_model(): model = tf.keras.models.Sequential([ tf.keras.layers.Flatten(input_shape=(28, 28)), tf.keras.layers.Dense(512, activation=tf.nn.relu), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(10, activation=tf.nn.softmax) ]) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy', customLoss1, customLoss2]) return model # Create a basic model instance model=create_model() # Fit and evaluate model model.fit(x_train, y_train, epochs=1) loss, acc,loss1, loss2 = model.evaluate(x_test, y_test,verbose=1) print("Original model, accuracy: {:5.2f}%".format(100*acc)) model.save("./model.h5") new_model=tf.keras.models.load_model("./model.h5",custom_objects={'customLoss1':customLoss1,'customLoss2':customLoss2}) 

कस्टम ऑप्स के साथ केरस मॉडल को सहेजना

जब हमारे पास निम्नलिखित मामले ( tf.tile ) के रूप में कस्टम ऑप्स होते हैं , तो हमें एक फ़ंक्शन बनाने और लैम्ब्डा परत के साथ लपेटने की आवश्यकता होती है। अन्यथा, मॉडल को बचाया नहीं जा सकता।

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

मुझे लगता है कि अगर मैंने केरस मॉडल को बचाने के कई तरीकों को कवर किया है। हालांकि, कई अन्य तरीके हैं। कृपया नीचे टिप्पणी करें यदि आप देखते हैं कि आपका उपयोग मामला ऊपर कवर नहीं किया गया है। धन्यवाद!

https://code.i-harness.com

आपके द्वारा Tensorflow में एक मॉडल को प्रशिक्षित करने के बाद:

  1. आप प्रशिक्षित मॉडल को कैसे बचाते हैं?
  2. आप बाद में इस सहेजे गए मॉडल को कैसे पुनर्स्थापित करते हैं?

डॉक्स

उन्होंने एक संपूर्ण और उपयोगी ट्यूटोरियल बनाया -> https://www.tensorflow.org/guide/saved_model

डॉक्स से:

सहेजें

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

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

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

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

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

पुनर्स्थापित

tf.reset_default_graph()

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

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

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

टेन्सफ़्लो 2

यह अभी भी बीटा है इसलिए मैं अभी के लिए सलाह दूंगा। यदि आप अभी भी उस सड़क से नीचे जाना चाहते हैं तो यहां tf.saved_model उपयोग गाइड है

तन्यप्रवाह <२

simple_save

कई अच्छे जवाब, पूर्णता के लिए मैं अपने 2 सेंट जोड़ूंगा: simple_save । इसके अलावा tf.data.Dataset API का उपयोग करके एक स्टैंडअलोन कोड उदाहरण।

पायथन 3; टेन्सफ्लो 1.14

import tensorflow as tf
from tensorflow.saved_model import tag_constants

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

        # Saving
        inputs = {
            "batch_size_placeholder": batch_size_placeholder,
            "features_placeholder": features_placeholder,
            "labels_placeholder": labels_placeholder,
        }
        outputs = {"prediction": model_output}
        tf.saved_model.simple_save(
            sess, 'path/to/your/location/', inputs, outputs
        )

पुनर्स्थापित कर रहा है:

graph = tf.Graph()
with restored_graph.as_default():
    with tf.Session() as sess:
        tf.saved_model.loader.load(
            sess,
            [tag_constants.SERVING],
            'path/to/your/location/',
        )
        batch_size_placeholder = graph.get_tensor_by_name('batch_size_placeholder:0')
        features_placeholder = graph.get_tensor_by_name('features_placeholder:0')
        labels_placeholder = graph.get_tensor_by_name('labels_placeholder:0')
        prediction = restored_graph.get_tensor_by_name('dense/BiasAdd:0')

        sess.run(prediction, feed_dict={
            batch_size_placeholder: some_value,
            features_placeholder: some_other_value,
            labels_placeholder: another_value
        })

स्टैंडअलोन उदाहरण

मूल ब्लॉग पोस्ट

निम्न कोड प्रदर्शन के लिए यादृच्छिक डेटा उत्पन्न करता है।

  1. हम प्लेसहोल्डर्स बनाकर शुरू करते हैं। वे रनटाइम पर डेटा को होल्ड करेंगे। उनमें से, हम Dataset और उसके बाद Iterator बनाते हैं। हमें input_tensor के जेनरेट किए गए टेंसर input_tensor , जिन्हें input_tensor कहा जाता है जो हमारे मॉडल के इनपुट के रूप में काम करेगा।
  2. मॉडल खुद input_tensor से बनाया गया है: एक input_tensor आधारित द्विदिश RNN जिसके बाद घने क्लासिफायरियर है। क्योंकि क्यों नहीं।
  3. नुकसान एक softmax_cross_entropy_with_logits , जो Adam साथ अनुकूलित है। 2 युगों (प्रत्येक के 2 बैच) के बाद, हम "प्रशिक्षित" मॉडल को tf.saved_model.simple_save साथ tf.saved_model.simple_save । यदि आप जैसा है वैसे ही कोड चलाते हैं, तो मॉडल आपके वर्तमान कार्यशील निर्देशिका में simple/ नामक फ़ोल्डर में सहेजा जाएगा।
  4. एक नए ग्राफ में, हम फिर tf.saved_model.loader.load साथ सहेजे गए मॉडल को पुनर्स्थापित करते हैं। हम प्लेसहोल्डर्स को graph.get_tensor_by_name और graph.get_tensor_by_name और Iterator को graph.get_operation_by_name . graph.get_operation_by_name साथ आरंभ करने के साथ graph.get_operation_by_name
  5. अंतिम रूप से हम डेटासेट में दोनों बैचों के लिए एक अनुमान चलाते हैं, और जाँचते हैं कि सहेजे गए और बहाल किए गए मॉडल दोनों समान मान प्राप्त करते हैं। वे करते हैं!

कोड:

import os
import shutil
import numpy as np
import tensorflow as tf
from tensorflow.python.saved_model import tag_constants


def model(graph, input_tensor):
    """Create the model which consists of
    a bidirectional rnn (GRU(10)) followed by a dense classifier

    Args:
        graph (tf.Graph): Tensors' graph
        input_tensor (tf.Tensor): Tensor fed as input to the model

    Returns:
        tf.Tensor: the model's output layer Tensor
    """
    cell = tf.nn.rnn_cell.GRUCell(10)
    with graph.as_default():
        ((fw_outputs, bw_outputs), (fw_state, bw_state)) = tf.nn.bidirectional_dynamic_rnn(
            cell_fw=cell,
            cell_bw=cell,
            inputs=input_tensor,
            sequence_length=[10] * 32,
            dtype=tf.float32,
            swap_memory=True,
            scope=None)
        outputs = tf.concat((fw_outputs, bw_outputs), 2)
        mean = tf.reduce_mean(outputs, axis=1)
        dense = tf.layers.dense(mean, 5, activation=None)

        return dense


def get_opt_op(graph, logits, labels_tensor):
    """Create optimization operation from model's logits and labels

    Args:
        graph (tf.Graph): Tensors' graph
        logits (tf.Tensor): The model's output without activation
        labels_tensor (tf.Tensor): Target labels

    Returns:
        tf.Operation: the operation performing a stem of Adam optimizer
    """
    with graph.as_default():
        with tf.variable_scope('loss'):
            loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
                    logits=logits, labels=labels_tensor, name='xent'),
                    name="mean-xent"
                    )
        with tf.variable_scope('optimizer'):
            opt_op = tf.train.AdamOptimizer(1e-2).minimize(loss)
        return opt_op


if __name__ == '__main__':
    # Set random seed for reproducibility
    # and create synthetic data
    np.random.seed(0)
    features = np.random.randn(64, 10, 30)
    labels = np.eye(5)[np.random.randint(0, 5, (64,))]

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

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

        with tf.Session(graph=graph1) as sess:
            # Initialize variables
            tf.global_variables_initializer().run(session=sess)
            for epoch in range(3):
                batch = 0
                # Initialize dataset (could feed epochs in Dataset.repeat(epochs))
                sess.run(
                    dataset_init_op,
                    feed_dict={
                        features_data_ph: features,
                        labels_data_ph: labels,
                        batch_size_ph: 32
                    })
                values = []
                while True:
                    try:
                        if epoch < 2:
                            # Training
                            _, value = sess.run([opt_op, logits])
                            print('Epoch {}, batch {} | Sample value: {}'.format(epoch, batch, value[0]))
                            batch += 1
                        else:
                            # Final inference
                            values.append(sess.run(logits))
                            print('Epoch {}, batch {} | Final inference | Sample value: {}'.format(epoch, batch, values[-1][0]))
                            batch += 1
                    except tf.errors.OutOfRangeError:
                        break
            # Save model state
            print('\nSaving...')
            cwd = os.getcwd()
            path = os.path.join(cwd, 'simple')
            shutil.rmtree(path, ignore_errors=True)
            inputs_dict = {
                "batch_size_ph": batch_size_ph,
                "features_data_ph": features_data_ph,
                "labels_data_ph": labels_data_ph
            }
            outputs_dict = {
                "logits": logits
            }
            tf.saved_model.simple_save(
                sess, path, inputs_dict, outputs_dict
            )
            print('Ok')
    # Restoring
    graph2 = tf.Graph()
    with graph2.as_default():
        with tf.Session(graph=graph2) as sess:
            # Restore saved values
            print('\nRestoring...')
            tf.saved_model.loader.load(
                sess,
                [tag_constants.SERVING],
                path
            )
            print('Ok')
            # Get restored placeholders
            labels_data_ph = graph2.get_tensor_by_name('labels_data_ph:0')
            features_data_ph = graph2.get_tensor_by_name('features_data_ph:0')
            batch_size_ph = graph2.get_tensor_by_name('batch_size_ph:0')
            # Get restored model output
            restored_logits = graph2.get_tensor_by_name('dense/BiasAdd:0')
            # Get dataset initializing operation
            dataset_init_op = graph2.get_operation_by_name('dataset_init')

            # Initialize restored dataset
            sess.run(
                dataset_init_op,
                feed_dict={
                    features_data_ph: features,
                    labels_data_ph: labels,
                    batch_size_ph: 32
                }

            )
            # Compute inference for both batches in dataset
            restored_values = []
            for i in range(2):
                restored_values.append(sess.run(restored_logits))
                print('Restored values: ', restored_values[i][0])

    # Check if original inference and restored inference are equal
    valid = all((v == rv).all() for v, rv in zip(values, restored_values))
    print('\nInferences match: ', valid)

यह प्रिंट करेगा:

$ python3 save_and_restore.py

Epoch 0, batch 0 | Sample value: [-0.13851789 -0.3087595   0.12804556  0.20013677 -0.08229901]
Epoch 0, batch 1 | Sample value: [-0.00555491 -0.04339041 -0.05111827 -0.2480045  -0.00107776]
Epoch 1, batch 0 | Sample value: [-0.19321944 -0.2104792  -0.00602257  0.07465433  0.11674127]
Epoch 1, batch 1 | Sample value: [-0.05275984  0.05981954 -0.15913513 -0.3244143   0.10673307]
Epoch 2, batch 0 | Final inference | Sample value: [-0.26331693 -0.13013336 -0.12553    -0.04276478  0.2933622 ]
Epoch 2, batch 1 | Final inference | Sample value: [-0.07730117  0.11119192 -0.20817074 -0.35660955  0.16990358]

Saving...
INFO:tensorflow:Assets added to graph.
INFO:tensorflow:No assets to write.
INFO:tensorflow:SavedModel written to: b'/some/path/simple/saved_model.pb'
Ok

Restoring...
INFO:tensorflow:Restoring parameters from b'/some/path/simple/variables/variables'
Ok
Restored values:  [-0.26331693 -0.13013336 -0.12553    -0.04276478  0.2933622 ]
Restored values:  [-0.07730117  0.11119192 -0.20817074 -0.35660955  0.16990358]

Inferences match:  True

आप नेटवर्क का उपयोग करके चर को बचा सकते हैं

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

बाद में या किसी अन्य स्क्रिप्ट में पुन: उपयोग के लिए नेटवर्क को पुनर्स्थापित करने के लिए, उपयोग करें:

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

महत्वपूर्ण बिंदु:

  1. sess पहले और बाद के रन (सुसंगत संरचना) के बीच समान होना चाहिए।
  2. saver.restore सहेजे गए फ़ाइलों के फ़ोल्डर के पथ की आवश्यकता है, न कि किसी व्यक्तिगत फ़ाइल पथ की।

आप यह भी देख सकते हैं examples में TensorFlow/skflow जो प्रदान करता है, save और restore तरीकों आप आसानी से अपने मॉडलों प्रबंधन में मदद कर सकते हैं। इसके पैरामीटर हैं कि आप यह भी नियंत्रित कर सकते हैं कि आप कितनी बार अपने मॉडल का बैकअप लेना चाहते हैं।


के लिए tensorflow 2.0 , यह है के रूप में सरल

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

पुन: स्थापित करने हेतु:

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

जहां भी आप मॉडल को बचाना चाहते हैं,

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

सुनिश्चित करें, आपके सभी tf.Variable नाम हैं, क्योंकि आप बाद में उनके नामों का उपयोग करके उन्हें पुनर्स्थापित करना चाह सकते हैं। और जहां आप भविष्यवाणी करना चाहते हैं,

saver = tf.train.import_meta_graph(filename)
name = 'name given when you saved the file' 
with tf.Session() as sess:
      saver.restore(sess, name)
      print(sess.run('W1:0')) #example to retrieve by variable name

सुनिश्चित करें कि सेवर इसी सत्र के अंदर चलता है। याद रखें कि, यदि आप उपयोग करते हैं tf.train.latest_checkpoint('./') , तो केवल नवीनतम चेक प्वाइंट का उपयोग किया जाएगा।


टेनसफ़्लो 2.0 के नए संस्करण में, एक मॉडल को बचाने / लोड करने की प्रक्रिया बहुत आसान है। कार्स एपीआई के कार्यान्वयन के कारण, TensorFlow के लिए एक उच्च-स्तरीय एपीआई।

एक मॉडल को बचाने के लिए: संदर्भ के लिए प्रलेखन की जाँच करें: https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/keras/models/save_model

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

एक मॉडल लोड करने के लिए:

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

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

नए Tensorflow संस्करण के अनुसार, tf.train.Checkpoint एक मॉडल को बचाने और पुनर्स्थापित करने का बेहतर तरीका है:

Checkpoint.save और Checkpoint.restore tf.train.Saver के विपरीत जो ऑब्जेक्ट-आधारित चौकियों को लिखते हैं और पढ़ते हैं, जो वेरिएबल पर आधारित है। ऑब्जेक्ट-आधारित चेकपॉइंटिंग नामित किनारों के साथ पायथन ऑब्जेक्ट्स (परत, ऑप्टिमाइज़र, वेरिएबल्स, आदि) के बीच निर्भरता के एक ग्राफ को बचाता है, और इस ग्राफ़ का उपयोग चेकपॉइंट को पुनर्स्थापित करते समय चर से मिलान करने के लिए किया जाता है। यह पायथन कार्यक्रम में बदलाव के लिए अधिक मजबूत हो सकता है, और उत्सुकता से निष्पादित करने पर चर के लिए पुनर्स्थापना-निर्माण का समर्थन करने में मदद करता है। पसंद करते हैं tf.train.Checkpoint अधिक tf.train.Saver नए कोड के लिए

यहाँ एक उदाहरण है:

import tensorflow as tf
import os

tf.enable_eager_execution()

checkpoint_directory = "/tmp/training_checkpoints"
checkpoint_prefix = os.path.join(checkpoint_directory, "ckpt")

checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=model)
status = checkpoint.restore(tf.train.latest_checkpoint(checkpoint_directory))
for _ in range(num_training_steps):
  optimizer.minimize( ... )  # Variables will be restored on creation.
status.assert_consumed()  # Optional sanity checks.
checkpoint.save(file_prefix=checkpoint_prefix)

अधिक जानकारी और उदाहरण यहाँ।


यदि आप डिफ़ॉल्ट सत्र के रूप में tf.train.MonitoredTrainingSession उपयोग करते हैं, तो आपको चीजों को बचाने / पुनर्स्थापित करने के लिए अतिरिक्त कोड जोड़ने की आवश्यकता नहीं है। मॉनिटर किए गए TrainingSession के कंस्ट्रक्टर के लिए बस एक चेकपॉइंट dir नाम पास करें, यह इनको संभालने के लिए सत्र हुक का उपयोग करेगा।


यहां सभी उत्तर महान हैं, लेकिन मैं दो बातें जोड़ना चाहता हूं।

सबसे पहले, @ user7505159 के उत्तर को विस्तृत करने के लिए, "./" उस फ़ाइल नाम की शुरुआत में जोड़ना महत्वपूर्ण हो सकता है जिसे आप पुनर्स्थापित कर रहे हैं।

उदाहरण के लिए, आप फ़ाइल नाम में ग्राफ को "./" जैसे नाम से सहेज सकते हैं:

# Some graph defined up here with specific names

saver = tf.train.Saver()
save_file = 'model.ckpt'

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    saver.save(sess, save_file)

लेकिन ग्राफ़ को पुनर्स्थापित करने के लिए, आपको file_name के लिए "./" को प्रस्तुत करने की आवश्यकता हो सकती है:

# Same graph defined up here

saver = tf.train.Saver()
save_file = './' + 'model.ckpt' # String addition used for emphasis

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    saver.restore(sess, save_file)

आपको हमेशा "./" की आवश्यकता नहीं होगी, लेकिन यह आपके पर्यावरण और TensorFlow के संस्करण के आधार पर समस्याएं पैदा कर सकता है।

यह भी उल्लेख करना चाहता हूं कि sess.run(tf.global_variables_initializer()) सत्र को बहाल करने से पहले यह महत्वपूर्ण हो सकता है।

यदि आप सहेजे गए सत्र को पुनर्स्थापित करने की कोशिश कर रहे हैं, तो अनइंस्टॉल किए गए चर के संबंध में एक त्रुटि प्राप्त कर रहे हैं, सुनिश्चित करें कि आप लाइन sess.run(tf.global_variables_initializer()) से पहले शामिल करते हैं saver.restore(sess, save_file) । यह आपको सिरदर्द से बचा सकता है।


TensorFlow संस्करण के लिए <0.11.0RC1:

जिन चौकियों को बचाया जाता है, वे आपके मॉडल में Variable एस के लिए मान Variable , न कि मॉडल / ग्राफ ही, जिसका अर्थ है कि जब आप चेकपॉइंट को पुनर्स्थापित करते हैं तो ग्राफ समान होना चाहिए।

यहां एक रेखीय प्रतिगमन के लिए एक उदाहरण है जहां एक प्रशिक्षण लूप है जो चर चौकियों को बचाता है और एक मूल्यांकन अनुभाग है जो एक पूर्व चलाने में सहेजे गए चर को बहाल करेगा और भविष्यवाणियों की गणना करेगा। बेशक, आप चर भी बहाल कर सकते हैं और यदि आप चाहें तो प्रशिक्षण जारी रख सकते हैं।

x = tf.placeholder(tf.float32)
y = tf.placeholder(tf.float32)

w = tf.Variable(tf.zeros([1, 1], dtype=tf.float32))
b = tf.Variable(tf.ones([1, 1], dtype=tf.float32))
y_hat = tf.add(b, tf.matmul(x, w))

...more setup for optimization and what not...

saver = tf.train.Saver()  # defaults to saving all variables - in this case w and b

with tf.Session() as sess:
    sess.run(tf.initialize_all_variables())
    if FLAGS.train:
        for i in xrange(FLAGS.training_steps):
            ...training loop...
            if (i + 1) % FLAGS.checkpoint_steps == 0:
                saver.save(sess, FLAGS.checkpoint_dir + 'model.ckpt',
                           global_step=i+1)
    else:
        # Here's where you're restoring the variables w and b.
        # Note that the graph is exactly as it was when the variables were
        # saved in a prior training run.
        ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)
        if ckpt and ckpt.model_checkpoint_path:
            saver.restore(sess, ckpt.model_checkpoint_path)
        else:
            ...no checkpoint found...

        # Now you can run the model to get predictions
        batch_x = ...load some data...
        predictions = sess.run(y_hat, feed_dict={x: batch_x})

यहाँ Variable s के लिए docs हैं, जो बचत और पुनर्स्थापन को कवर करते हैं। और यहां Saver लिए docs दिए गए हैं।


आप यह आसान तरीका भी अपना सकते हैं।

चरण 1: अपने सभी चर को इनिशियलाइज़ करें

W1 = tf.Variable(tf.truncated_normal([6, 6, 1, K], stddev=0.1), name="W1")
B1 = tf.Variable(tf.constant(0.1, tf.float32, [K]), name="B1")

Similarly, W2, B2, W3, .....

चरण 2: मॉडल Saver अंदर सत्र को सहेजें और इसे सहेजें

model_saver = tf.train.Saver()

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

चरण 3: मॉडल को पुनर्स्थापित करें

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

चरण 4: अपने चर की जाँच करें

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

विभिन्न अजगर उदाहरण में चलाते समय, उपयोग करें

with tf.Session() as sess:
    # Restore latest checkpoint
    saver.restore(sess, tf.train.latest_checkpoint('saved_model/.'))

    # Initalize the variables
    sess.run(tf.global_variables_initializer())

    # Get default graph (supply your custom graph if you have one)
    graph = tf.get_default_graph()

    # It will give tensor object
    W1 = graph.get_tensor_by_name('W1:0')

    # To get the value (numpy array)
    W1_value = session.run(W1)

ज्यादातर मामलों में, tf.train.Saver का उपयोग करके डिस्क से बचत और पुनर्स्थापना आपका सबसे अच्छा विकल्प है:

... # build your model
saver = tf.train.Saver()

with tf.Session() as sess:
    ... # train the model
    saver.save(sess, "/tmp/my_great_model")

with tf.Session() as sess:
    saver.restore(sess, "/tmp/my_great_model")
    ... # use the model

आप स्वयं ग्राफ़ संरचना को सहेज / पुनर्स्थापित भी कर सकते हैं (विवरण के लिए https://www.tensorflow.org/programmers_guide/meta_graph देखें)। डिफ़ॉल्ट रूप से, Saver ग्राफ़ संरचना को एक .meta फ़ाइल में .meta है। आप इसे पुनर्स्थापित करने के लिए import_meta_graph() कॉल कर सकते हैं। यह ग्राफ़ संरचना को पुनर्स्थापित करता है और एक Saver देता है जिसे आप मॉडल की स्थिति को पुनर्स्थापित करने के लिए उपयोग कर सकते हैं:

saver = tf.train.import_meta_graph("/tmp/my_great_model.meta")

with tf.Session() as sess:
    saver.restore(sess, "/tmp/my_great_model")
    ... # use the model

हालांकि, ऐसे मामले हैं जहां आपको बहुत तेजी से कुछ चाहिए। उदाहरण के लिए, यदि आप शुरुआती रोक को लागू करते हैं, तो आप प्रशिक्षण के दौरान हर बार मॉडल को सुधारना चाहते हैं (जैसा कि सत्यापन सेट पर मापा जाता है), तो यदि कुछ समय के लिए कोई प्रगति नहीं है, तो आप सर्वश्रेष्ठ मॉडल पर वापस जाना चाहते हैं। यदि आप सुधार करने के लिए हर बार मॉडल को सहेजते हैं, तो यह प्रशिक्षण को धीमा कर देगा। चर को स्मृति में परिवर्तनशील अवस्थाओं को सहेजना है, फिर बाद में उन्हें पुनर्स्थापित करें:

... # build your model

# get a handle on the graph nodes we need to save/restore the model
graph = tf.get_default_graph()
gvars = graph.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)
assign_ops = [graph.get_operation_by_name(v.op.name + "/Assign") for v in gvars]
init_values = [assign_op.inputs[1] for assign_op in assign_ops]

with tf.Session() as sess:
    ... # train the model

    # when needed, save the model state to memory
    gvars_state = sess.run(gvars)

    # when needed, restore the model state
    feed_dict = {init_value: val
                 for init_value, val in zip(init_values, gvars_state)}
    sess.run(assign_ops, feed_dict=feed_dict)

एक त्वरित व्याख्या: जब आप एक चर X बनाते हैं, तो TensorFlow स्वचालित रूप से चर का प्रारंभिक मान सेट करने के लिए असाइनमेंट ऑपरेशन X/Assign करता है। प्लेसहोल्डर्स और अतिरिक्त असाइनमेंट ऑप्स बनाने के बजाय (जो कि बस ग्राफ को गड़बड़ कर देगा), हम सिर्फ इन मौजूदा असाइनमेंट ऑप्स का उपयोग करते हैं। प्रत्येक असाइनमेंट सेशन का पहला इनपुट वैरिएबल का एक संदर्भ है जिसे इसे इनिशियलाइज़ करना है, और दूसरा इनपुट ( assign_op.inputs[1] ) इनिशियल वैल्यू है। इसलिए हम जो भी मूल्य निर्धारित करना चाहते हैं (प्रारंभिक मूल्य के बजाय), हमें एक feed_dict का उपयोग करने और प्रारंभिक मूल्य को बदलने की आवश्यकता है। हां, TensorFlow आपको प्लेसहोल्डर्स के लिए नहीं, बल्कि किसी भी सेशन के लिए वैल्यू फीड करने की सुविधा देता है, इसलिए यह ठीक काम करता है।


मेरा वातावरण: पायथन 3.6, टेंसरफ़्लो 1.3.0

हालांकि कई समाधान हैं, उनमें से अधिकांश tf.train.Saver पर आधारित हैं। जब हम Saver द्वारा .ckpt गए .ckpt लोड करते हैं, तो हमें या तो टेंसोफ़्लो नेटवर्क को फिर से परिभाषित करना होगा या कुछ अजीब और कठिन-याद नाम का उपयोग करना होगा, जैसे 'placehold_0:0' , 'dense/Adam/Weight:0' । यहाँ मैं tf.saved_model का उपयोग करने की सलाह देता tf.saved_model , tf.saved_model एक सरल उदाहरण नीचे दिया गया है, आप TensorFlow मॉडल की सेवा करने से अधिक सीख सकते हैं:

मॉडल सहेजें:

import tensorflow as tf

# define the tensorflow network and do some trains
x = tf.placeholder("float", name="x")
w = tf.Variable(2.0, name="w")
b = tf.Variable(0.0, name="bias")

h = tf.multiply(x, w)
y = tf.add(h, b, name="y")
sess = tf.Session()
sess.run(tf.global_variables_initializer())

# save the model
export_path =  './savedmodel'
builder = tf.saved_model.builder.SavedModelBuilder(export_path)

tensor_info_x = tf.saved_model.utils.build_tensor_info(x)
tensor_info_y = tf.saved_model.utils.build_tensor_info(y)

prediction_signature = (
  tf.saved_model.signature_def_utils.build_signature_def(
      inputs={'x_input': tensor_info_x},
      outputs={'y_output': tensor_info_y},
      method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME))

builder.add_meta_graph_and_variables(
  sess, [tf.saved_model.tag_constants.SERVING],
  signature_def_map={
      tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY:
          prediction_signature 
  },
  )
builder.save()

मॉडल लोड करें:

import tensorflow as tf
sess=tf.Session() 
signature_key = tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY
input_key = 'x_input'
output_key = 'y_output'

export_path =  './savedmodel'
meta_graph_def = tf.saved_model.loader.load(
           sess,
          [tf.saved_model.tag_constants.SERVING],
          export_path)
signature = meta_graph_def.signature_def

x_tensor_name = signature[signature_key].inputs[input_key].name
y_tensor_name = signature[signature_key].outputs[output_key].name

x = sess.graph.get_tensor_by_name(x_tensor_name)
y = sess.graph.get_tensor_by_name(y_tensor_name)

y_out = sess.run(y, {x: 3.0})

मॉडल के दो भाग हैं, मॉडल की परिभाषा, मॉडल निर्देशिका में graph.pbtxt रूप में Supervisor द्वारा सहेजा गया और graph.pbtxt के संख्यात्मक मान, मॉडल की तरह चेकपॉइंट फ़ाइलों में सहेजे गए। model.ckpt-1003418

मॉडल की परिभाषा को tf.import_graph_def का उपयोग करके पुनर्स्थापित किया जा सकता है, और Saver का उपयोग करके वजन बहाल किया जाता है।

हालाँकि, Saver विशेष ग्राफ़ की चर संग्रह सूची का उपयोग करता है जो मॉडल ग्राफ़ से जुड़ी होती है, और इस संग्रह को import_graph_def के उपयोग से आरंभ नहीं किया जाता है, इसलिए आप फिलहाल दोनों का उपयोग नहीं कर सकते हैं (यह ठीक करने के लिए हमारे रोडमैप पर है)। अभी के लिए, आपको रयान सेपसी के दृष्टिकोण का उपयोग करना होगा - मैन्युअल रूप से समान नोड नामों के साथ एक ग्राफ का निर्माण करना होगा, और इसमें वजन को लोड करने के लिए Saver का उपयोग करना होगा।

(वैकल्पिक रूप से आप इसे import_graph_def कर सकते हैं हैक करके, import_graph_def का उपयोग import_graph_def , मैन्युअल रूप से वेरिएबल्स बनाकर और tf.add_to_collection(tf.GraphKeys.VARIABLES, variable) का उपयोग करके किसी भी वेरिएबल के लिए, फिर Saver का उपयोग करके)


यदि यह आंतरिक रूप से सहेजा गया मॉडल है, तो आप बस के रूप में सभी चर के लिए एक रिस्टोरर निर्दिष्ट करते हैं

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

और इसका उपयोग वर्तमान सत्र में चर बहाल करने के लिए करें:

restorer.restore(self._sess, model_file)

बाहरी मॉडल के लिए आपको इसके चर नामों से मानचित्रण को अपने चर नामों तक निर्दिष्ट करना होगा। आप कमांड का उपयोग करके मॉडल चर नाम देख सकते हैं

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

Inspect_checkpoint.py स्क्रिप्ट को Tensorflow source के './tensorflow/python/tools' फ़ोल्डर में पाया जा सकता है।

मैपिंग को निर्दिष्ट करने के लिए, आप मेरे Tensorflow-Worklab उपयोग कर सकते हैं, जिसमें विभिन्न मॉडलों को प्रशिक्षित करने और Tensorflow-Worklab उपयोग करने के लिए कक्षाओं और स्क्रिप्ट का एक सेट है। इसमें here स्थित ResNet मॉडल को फिर से प्रदर्शित करने का एक उदाहरण शामिल here






model