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




machine-learning model (13)

टेन्सफोर्लो में एक मॉडल को प्रशिक्षित करने के बाद:

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

Answers

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


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

हालांकि कई समाधान हुए हैं, उनमें से अधिकतर tf.train.Saver पर आधारित है। जब हम Saver द्वारा सहेजे गए एक .ckpt लोड करते हैं, तो हमें या तो tensorflow नेटवर्क को फिर से परिभाषित करना होगा या कुछ अजीब और कठोर याद किए गए नाम, जैसे 'placehold_0:0' , 'dense/Adam/Weight:0' weight 'dense/Adam/Weight:0' । यहां मैं tf.saved_model का उपयोग करने की अनुशंसा करता tf.saved_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()

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

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

ज्यादातर मामलों में, 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 का उपयोग करने और प्रारंभिक मान को प्रतिस्थापित करने की आवश्यकता है। हां, टेंसरफ्लो आपको प्लेसधारकों के लिए न केवल किसी भी ओप के लिए मूल्य खिला सकता है, इसलिए यह ठीक काम करता है।


जैसा कि 6255 अंक में वर्णित है:

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

के बजाय

saver.restore('my_model_final.ckpt')

(और बाद में) टेंसरफ्लो संस्करण 0.11.0 आरसी 1, आप https://www.tensorflow.org/programmers_guide/meta_graph अनुसार tf.train.export_meta_graph और tf.train.import_meta_graph को कॉल करके सीधे अपने मॉडल को सहेज सकते हैं और पुनर्स्थापित कर सकते हैं।

मॉडल को बचाओ

w1 = tf.Variable(tf.truncated_normal(shape=[10]), name='w1')
w2 = tf.Variable(tf.truncated_normal(shape=[20]), name='w2')
tf.add_to_collection('vars', w1)
tf.add_to_collection('vars', w2)
saver = tf.train.Saver()
sess = tf.Session()
sess.run(tf.global_variables_initializer())
saver.save(sess, 'my-model')
# `save` method will call `export_meta_graph` implicitly.
# you will get saved graph files:my-model.meta

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

sess = tf.Session()
new_saver = tf.train.import_meta_graph('my-model.meta')
new_saver.restore(sess, tf.train.latest_checkpoint('./'))
all_vars = tf.get_collection('vars')
for v in all_vars:
    v_ = sess.run(v)
    print(v_)

जैसा कि यारोस्लाव ने कहा था, आप ग्राफ़ को आयात करके ग्राफ़_डेफ़ और चेकपॉइंट से बहाल कर सकते हैं, मैन्युअल रूप से चर बनाते हैं, और उसके बाद सेवर का उपयोग कर सकते हैं।

मैंने इसे अपने व्यक्तिगत उपयोग के लिए कार्यान्वित किया, इसलिए मैं यहां कोड साझा करता हूं।

लिंक: https://gist.github.com/nikitakit/6ef3b72be67b86cb7868

(यह निश्चित रूप से एक हैक है, और इस बात की कोई गारंटी नहीं है कि इस तरह से सहेजे गए मॉडल टेंसरफ्लो के भविष्य के संस्करणों में पठनीय बने रहेंगे।)


यहां दो मूलभूत मामलों के लिए मेरा सरल समाधान है कि आप फ़ाइल से ग्राफ़ लोड करना चाहते हैं या रनटाइम के दौरान इसे बनाना चाहते हैं।

यह उत्तर Tensorflow 0.12+ (1.0 सहित) के लिए है।

कोड में ग्राफ को पुनर्निर्माण

बचत

graph = ... # build the graph
saver = tf.train.Saver()  # create the saver after the graph
with ... as sess:  # your session object
    saver.save(sess, 'my-model')

लोड हो रहा है

graph = ... # build the graph
saver = tf.train.Saver()  # create the saver after the graph
with ... as sess:  # your session object
    saver.restore(sess, tf.train.latest_checkpoint('./'))
    # now you can use the graph, continue training or whatever

फ़ाइल से ग्राफ भी लोड हो रहा है

इस तकनीक का उपयोग करते समय, सुनिश्चित करें कि आपके सभी परतों / चरों ने स्पष्ट रूप से अद्वितीय नाम सेट किए हैं। अन्यथा Tensorflow नाम अद्वितीय बना देगा और वे फ़ाइल में संग्रहीत नामों से अलग होंगे। यह पिछली तकनीक में कोई समस्या नहीं है, क्योंकि नाम लोडिंग और बचत दोनों में समान रूप से "उलझन" होते हैं।

बचत

graph = ... # build the graph

for op in [ ... ]:  # operators you want to use after restoring the model
    tf.add_to_collection('ops_to_restore', op)

saver = tf.train.Saver()  # create the saver after the graph
with ... as sess:  # your session object
    saver.save(sess, 'my-model')

लोड हो रहा है

with ... as sess:  # your session object
    saver = tf.train.import_meta_graph('my-model.meta')
    saver.restore(sess, tf.train.latest_checkpoint('./'))
    ops = tf.get_collection('ops_to_restore')  # here are your operators in the same order in which you saved them to the collection

मैं मॉडलों को सहेजने और बहाल करने के लिए अधिक जानकारी जोड़ने के लिए अपना उत्तर सुधार रहा हूं।

में (और बाद में) Tensorflow संस्करण 0.11 :

मॉडल बचाओ:

import tensorflow as tf

#Prepare to feed input, i.e. feed_dict and placeholders
w1 = tf.placeholder("float", name="w1")
w2 = tf.placeholder("float", name="w2")
b1= tf.Variable(2.0,name="bias")
feed_dict ={w1:4,w2:8}

#Define a test operation that we will restore
w3 = tf.add(w1,w2)
w4 = tf.multiply(w3,b1,name="op_to_restore")
sess = tf.Session()
sess.run(tf.global_variables_initializer())

#Create a saver object which will save all the variables
saver = tf.train.Saver()

#Run the operation by feeding input
print sess.run(w4,feed_dict)
#Prints 24 which is sum of (w1+w2)*b1 

#Now, save the graph
saver.save(sess, 'my_test_model',global_step=1000)

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

import tensorflow as tf

sess=tf.Session()    
#First let's load meta graph and restore weights
saver = tf.train.import_meta_graph('my_test_model-1000.meta')
saver.restore(sess,tf.train.latest_checkpoint('./'))


# Access saved Variables directly
print(sess.run('bias:0'))
# This will print 2, which is the value of bias that we saved


# Now, let's access and create placeholders variables and
# create feed-dict to feed new data

graph = tf.get_default_graph()
w1 = graph.get_tensor_by_name("w1:0")
w2 = graph.get_tensor_by_name("w2:0")
feed_dict ={w1:13.0,w2:17.0}

#Now, access the op that you want to run. 
op_to_restore = graph.get_tensor_by_name("op_to_restore:0")

print sess.run(op_to_restore,feed_dict)
#This will print 60 which is calculated 

यह और कुछ और उन्नत उपयोग-मामलों को यहां बहुत अच्छी तरह से समझाया गया है।

Tensorflow मॉडल को सहेजने और पुनर्स्थापित करने के लिए एक त्वरित पूर्ण ट्यूटोरियल


टेंसरफ्लो संस्करण <0.11.0 आरसी 1 के लिए:

सहेजे गए चेकपॉइंट्स में आपके मॉडल में 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 एस के लिए docs यहां दिए गए हैं, जो बचत और बहाल करने को कवर करते हैं। और यहां Saver लिए docs हैं।


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

सबसे पहले, @ 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)

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

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

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

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

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


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

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

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

restorer.restore(self._sess, model_file)

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

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

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

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


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

चरण 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)

अधिकांशतः अधिकांश अनुप्रयोगों में डेटा, प्रदर्शन और प्रसंस्करण भाग होगा और हम उन सभी को M , V और C अक्षरों में डाल देंगे।

मॉडल ( M ) -> ऐसे गुण हैं जिनमें आवेदन की स्थिति है और यह V और C बारे में कुछ भी नहीं जानता C

देखें ( V ) -> एप्लिकेशन के लिए प्रारूप प्रदर्शित कर रहा है और केवल उस पर मॉडल को कैसे पचाने के बारे में जानता है और C बारे में परेशान नहीं करता C

नियंत्रक ( C ) ----> आवेदन के हिस्से को संसाधित कर रहा है और एम और वी के बीच तारों के रूप में कार्य करता है और यह एम और वी दोनों के विपरीत M , V दोनों पर निर्भर करता है।

कुल मिलाकर प्रत्येक के बीच चिंता का अलगाव होता है। भविष्य में किसी भी बदलाव या संवर्द्धन को बहुत आसानी से जोड़ा जा सकता है।





python tensorflow machine-learning model