इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

TensorFlow 2 में TF हब से SavedModels

TensorFlow 2 का SavedModel प्रारूप, TensorFlow Hub पर पूर्व-प्रशिक्षित मॉडल और मॉडल टुकड़े साझा करने का अनुशंसित तरीका है। यह पुराने TF1 हब प्रारूप को बदल देता है और एपीआई के एक नए सेट के साथ आता है।

यह पृष्ठ बताता है कि TensorFlow 2 में TF2 SavedModels को निम्न-स्तरीय hub.load() API और इसके hub.KerasLayer . hub.KerasLayer आवरण के साथ पुन: उपयोग कैसे करें। (आमतौर पर, hub.KerasLayerhub.KerasLayer अन्य tf.keras.layers के साथ मिलकर tf.keras.layers मॉडल या TF2 एस्टीमेटर के tf.keras.layers का निर्माण करता है।) ये API model_fn TF1 मॉडल में लीगेसी मॉडल को लोड कर सकती हैं, सीमा के भीतर, संगतता गाइड देखें

TensorFlow 1 के उपयोगकर्ता TF 1.15 में अपडेट कर सकते हैं और फिर उसी API का उपयोग कर सकते हैं। TF1 के पुराने संस्करण काम नहीं करते हैं।

TF हब से SavedModels का उपयोग करना

करैस में सेव्डमॉडल का उपयोग करना

Keras Keras परत वस्तुओं रचना द्वारा गहरी सीखने वाले मॉडल के लिए TensorFlow के उच्च स्तर एपीआई है। tensorflow_hub लाइब्रेरी क्लास hub.KerasLayer प्रदान करता है। tensorflow_hub hub.KerasLayer जो कि एक SavedModel के URL (या फाइलसिस्टम पथ) से आरंभीकृत हो जाता है और फिर अपने पूर्व-प्रशिक्षित वेट सहित SavedModel से कम्प्यूटेशन प्रदान करता है।

यहां एक पूर्व-प्रशिक्षित पाठ एम्बेडिंग का उपयोग करने का एक उदाहरण है:

import tensorflow as tf
import tensorflow_hub as hub

hub_url = "https://tfhub.dev/google/tf2-preview/nnlm-en-dim128/1"
embed = hub.KerasLayer(hub_url)
embeddings = embed(["A long sentence.", "single-word", "http://example.com"])
print(embeddings.shape, embeddings.dtype)

इस से, एक टेक्स्ट क्लासिफायर को सामान्य केरस तरीके से बनाया जा सकता है:

model = tf.keras.Sequential([
    embed,
    tf.keras.layers.Dense(16, activation="relu"),
    tf.keras.layers.Dense(1, activation="sigmoid"),
])

पाठ वर्गीकरण कोलाब इस तरह के एक क्लासिफायरियर को प्रशिक्षित और मूल्यांकन करने का एक पूरा उदाहरण है।

एक hub.KerasLayer में मॉडल वजन। hub.KerasLayer डिफ़ॉल्ट रूप से गैर-ट्रेन करने योग्य है। कैसे ठीक करने के लिए नीचे ठीक ट्यूनिंग पर अनुभाग देखें। वेट को एक ही लेयर ऑब्जेक्ट के सभी अनुप्रयोगों के बीच साझा किया जाता है, जैसा कि केरेस में हमेशा होता है।

एक अनुमानक में एक SavedModel का उपयोग करना

वितरित प्रशिक्षण के लिए TensorFlow के एस्टिमेटर एपीआई के उपयोगकर्ता अन्य tf.keras.layers बीच hub.KerasLayer संदर्भ में अपने model_fn लिखकर TF हब से SavedModels का उपयोग कर सकते हैं।

पर्दे के पीछे: SavedModel डाउनलोडिंग और कैशिंग

TensorFlow Hub (या इसके होस्टिंग प्रोटोकॉल को लागू करने वाले अन्य HTTPS सर्वर) से एक SavedModel का उपयोग करते हुए डाउनलोड करता है और अगर पहले से मौजूद नहीं है तो इसे स्थानीय फाइल सिस्टम में डिकम्प्रेस करता है। पर्यावरण चर TFHUB_CACHE_DIR डाउनलोड और असम्पीडित SavedModels कैशिंग के लिए डिफ़ॉल्ट अस्थायी स्थान को ओवरराइड करने के लिए सेट किया जा सकता है। जानकारी के लिए, कैशिंग देखें।

निम्न-स्तरीय TensorFlow में एक SavedModel का उपयोग करना

फ़ंक्शन hub.load(handle) डाउनलोड करता है और एक SavedModel को विघटित करता है (जब तक कि handle पहले से ही एक फ़ाइल सिस्टम पथ नहीं है) और फिर इसे TensorFlow के अंतर्निहित फ़ंक्शन tf.saved_model.load() साथ लोड करने का परिणाम देता है। इसलिए, hub.load() किसी भी मान्य SavedModel (इसके पूर्ववर्ती hub.Module विपरीत) TF1 के लिए संभाल सकता है।

उन्नत विषय: लोड करने के बाद सेव्डमॉडल से क्या उम्मीद करें

SavedModel की सामग्री के आधार पर, obj = hub.load(...) के परिणाम को विभिन्न तरीकों से लागू किया जा सकता है (जैसा कि TensorFlow के SavedModel गाइड में बहुत अधिक विस्तार से बताया गया है:

  • SavedModel (यदि कोई हो) के सेवारत हस्ताक्षरों को ठोस कार्यों के शब्दकोश के रूप में दर्शाया गया है और tensors_out = obj.signatures["serving_default"](**tensors_in) संबंधित इनपुट और आउटपुट द्वारा tensors_out = obj.signatures["serving_default"](**tensors_in) के शब्दकोशों के साथ tensors_out = obj.signatures["serving_default"](**tensors_in) कहा जा सकता है। नाम और हस्ताक्षर के आकार और dtype बाधाओं के अधीन।

  • सहेजे गए ऑब्जेक्ट के @tf.function -decorated तरीके (यदि कोई हो) को tf.function ऑब्जेक्ट के रूप में पुनर्स्थापित किया जाता है जिसे Tensor और गैर-Tensor तर्कों के सभी संयोजनों द्वारा बुलाया जा सकता है, जिसके लिए tf.function को सहेजने से पहले पता लगाया गया था। विशेष रूप से, अगर वहाँ एक निशान है। उपयुक्त obj.__call__ साथ obj.__call__ विधि, obj खुद को पायथन फ़ंक्शन की तरह कहा जा सकता है। एक सरल उदाहरण output_tensor = obj(input_tensor, training=False) तरह लग सकता है।

यह उन इंटरफेसों में भारी स्वतंत्रता छोड़ देता है जिन्हें सेव्डमॉडल लागू कर सकते हैं। पुन: प्रयोज्य SavedModels इंटरफेस के लिए obj सम्मेलनों स्थापित करता है इस तरह के तरह एडेप्टर सहित ग्राहक कोड, कि hub.KerasLayer , पता SavedModel का उपयोग कैसे करें।

कुछ SavedModels उस सम्मेलन का पालन नहीं कर सकते हैं, विशेष रूप से पूरे मॉडल का बड़े मॉडल में पुन: उपयोग नहीं किया जा सकता है, और बस सेवा हस्ताक्षर प्रदान करते हैं।

एक SavedModel में ट्रेन करने योग्य चर को ट्रेन के रूप में पुनः लोड किया जाता है, और tf.GradientTape उन्हें डिफ़ॉल्ट रूप से देखेगा। कुछ कैविएट के लिए नीचे ठीक-ट्यूनिंग पर अनुभाग देखें, और शुरुआत के लिए इससे बचने पर विचार करें। अगर आप फाइन-ट्यून करना चाहते हैं, तब भी आप यह देखना चाहते हैं कि obj.trainable_variables केवल मूल रूप से ट्रेन किए गए वेरिएबल्स के एक उप-समूह को फिर से प्रशिक्षित करने की सलाह देता है या नहीं।

TF हब के लिए SavedModels बनाना

अवलोकन

SavedModel TensorFlow के प्रशिक्षित मॉडल या मॉडल टुकड़ों के लिए मानक क्रमांकन प्रारूप है। यह अपनी गणना करने के लिए सटीक TensorFlow संचालन के साथ मॉडल के प्रशिक्षित भार को एक साथ संग्रहीत करता है। इसे उस कोड से स्वतंत्र रूप से उपयोग किया जा सकता है जिसने इसे बनाया है। विशेष रूप से, इसे विभिन्न उच्च-स्तरीय मॉडल-बिल्डिंग एपीआई जैसे किरस में पुन: उपयोग किया जा सकता है, क्योंकि TensorFlow संचालन उनकी सामान्य बुनियादी भाषा है।

करेस से बचाना

TensorFlow 2 के साथ शुरू, tf.keras.Model.save() और tf.keras.models.save_model() SavedModel प्रारूप के लिए डिफ़ॉल्ट (HDF5 नहीं)। परिणामी SavedModels जो hub.load() , hub.KerasLayer और अन्य उच्च-स्तरीय API के लिए समान एडेप्टर के साथ उपयोग किया जा सकता है क्योंकि वे उपलब्ध हो जाते हैं।

एक पूर्ण केरस मॉडल साझा करने के लिए, बस इसे include_optimizer=False साथ सहेजें।

एक केरस मॉडल का एक टुकड़ा साझा करने के लिए, टुकड़े को अपने आप में एक मॉडल बनाएं और फिर उसे सहेजें। आप या तो शुरू से ही इस तरह का कोड बना सकते हैं ...।

piece_to_share = tf.keras.Model(...)
full_model = tf.keras.Sequential([piece_to_share, ...])
full_model.fit(...)
piece_to_share.save(...)

... या इस तथ्य के बाद साझा करने के लिए टुकड़े को काट दें (यदि यह आपके पूर्ण मॉडल की लेयरिंग के साथ संरेखित हो):

full_model = tf.keras.Model(...)
sharing_input = full_model.get_layer(...).get_output_at(0)
sharing_output = full_model.get_layer(...).get_output_at(0)
piece_to_share = tf.keras.Model(sharing_input, sharing_output)
piece_to_share.save(..., include_optimizer=False)

GitHub पर TensorFlow मॉडल BERT के लिए पूर्व दृष्टिकोण का उपयोग करता है ( nlp / bert / bert_models.py और nlp / bert / export_tfhub.py देखें , core_model और pretrain_model बीच विभाजन पर ध्यान दें) और core_model के लिए बाद का दृष्टिकोण ( विज़न / इमेज_क्लासिफिकेशन / tfhification देखें) । )।

निम्न-स्तरीय TensorFlow से बचत

इसके लिए TensorFlow के SavedModel गाइड के साथ अच्छी पहचान की आवश्यकता है

यदि आप केवल एक सेवारत हस्ताक्षर प्रदान करना चाहते हैं, तो आपको पुन: प्रयोज्य SavedModel इंटरफ़ेस को लागू करना चाहिए। वैचारिक रूप से, यह दिखता है

class MyMulModel(tf.train.Checkpoint):
  def __init__(self, v_init):
    super(MyMulModel, self).__init__()
    self.v = tf.Variable(v_init)
    self.variables = [self.v]
    self.trainable_variables = [self.v]
    self.regularization_losses = [
        tf.function(input_signature=[])(lambda: 0.001 * self.v**2),
    ]

  @tf.function(input_signature=[tf.TensorSpec(shape=None, dtype=tf.float32)])
  def __call__(self, inputs):
    return tf.multiply(inputs, self.v)

tf.saved_model.save(MyMulModel(2.0), "/tmp/my_mul")

layer = hub.KerasLayer("/tmp/my_mul")
print(layer([10., 20.]))  # [20., 40.]
layer.trainable = True
print(layer.trainable_weights)  # [2.]
print(layer.losses)  # 0.004

दहाई कोड में कोड / उदाहरण / save_model / एकीकरण_tests / बड़े उदाहरण हैं। export_mnist.py और use_mnist.py जोड़ी।

फ़ाइन ट्यूनिंग

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

ठीक-ट्यूनिंग "निरंतर" मॉडल मापदंडों को बदलता है जो प्रशिक्षित हैं। यह हार्ड-कोडित परिवर्तनों को परिवर्तित नहीं करता है, जैसे कि टेक्स्ट इनपुट को टोकन करना और एम्बेडिंग मैट्रिक्स में उनकी संबंधित प्रविष्टियों को टोकन को मैप करना।

SavedModel उपभोक्ताओं के लिए

एक hub.KerasLayer बनाना

layer = hub.KerasLayer(..., trainable=True)

परत द्वारा लोड SavedModel के ठीक ट्यूनिंग सक्षम करता है। यह सेवडमॉडल में घोषित ट्रेन वेट और वेट रेग्युलर को कार्स मॉडल में जोड़ता है, और ट्रेनिंग मोड (ड्रॉपआउट इत्यादि के बारे में) में सेव्डमॉडल की गणना करता है।

छवि वर्गीकरण कोलाब में वैकल्पिक फाइन-ट्यूनिंग के साथ अंत-टू-एंड उदाहरण शामिल है।

ठीक-ट्यूनिंग परिणाम का फिर से निर्यात करना

उन्नत उपयोगकर्ता ठीक-ठीक ट्यूनिंग के परिणामों को सहेजकर सहेजना चाहते हैं जो मूल रूप से लोड किए गए एक के बजाय इस्तेमाल किया जा सकता है। ऐसा कोड के साथ किया जा सकता है

loaded_obj = hub.load("https://tfhub.dev/...")
hub_layer = hub.KerasLayer(loaded_obj, trainable=True, ...)

model = keras.Sequential([..., hub_layer, ...])
model.compile(...)
model.fit(...)

export_module_dir = os.path.join(os.getcwd(), "finetuned_model_export")
tf.saved_model.save(loaded_obj, export_module_dir)

SavedModel रचनाकारों के लिए

TensorFlow हब पर साझा करने के लिए एक SavedModel बनाते समय, आगे सोचें कि क्या और कैसे इसके उपभोक्ताओं को इसे ठीक करना चाहिए, और प्रलेखन में मार्गदर्शन प्रदान करना चाहिए।

केरस मॉडल से बचत करना, ठीक-ठाक काम के सभी यांत्रिकी को बनाना चाहिए (वजन नियमितीकरण के नुकसान को बचाने, प्रशिक्षण योग्य चर घोषित करना, training=True लिए __call__ को ट्रेस __call__ training=True और training=False , आदि)

एक मॉडल इंटरफ़ेस चुनें जो ढाल प्रवाह के साथ अच्छी तरह से खेलता है, उदाहरण के लिए, सॉफ्टमैक्स प्रायिकताओं या टॉप-के भविष्यवाणियों के बजाय आउटपुट लॉग।

यदि मॉडल ड्रॉपआउट, बैच सामान्यीकरण, या हाइपरपैरामीटर शामिल करने वाली समान प्रशिक्षण तकनीकों का उपयोग करता है, तो उन्हें उन मानों पर सेट करें जो कई अपेक्षित लक्ष्य समस्याओं और बैच आकारों में समझ में आते हैं। (इस लेखन के रूप में, केरस से बचत करने से उपभोक्ताओं को उन्हें समायोजित करने में आसानी नहीं होती है, लेकिन कुछ क्रोड वर्कअराउंड के लिए टेंसरफ़्लो / उदाहरण / save_model / एकीकरण_tests / export_mnist_cnn.py देखें)।

अलग-अलग परतों पर वजन नियमित करने वालों को बचाया जाता है (उनकी नियमितीकरण शक्ति गुणांक के साथ), लेकिन अनुकूलन के भीतर से वजन नियमितीकरण (जैसे tf.keras.optimizers.Ftrl.l1_regularization_strength=...) खो जाता है। तदनुसार अपने SavedModel के उपभोक्ताओं को सलाह दें।