TensorFlow 2 का सहेजा गया मॉडल प्रारूप TensorFlow हब पर पूर्व-प्रशिक्षित मॉडल और मॉडल के टुकड़े साझा करने का अनुशंसित तरीका है। यह पुराने TF1 हब प्रारूप को प्रतिस्थापित करता है और API के नए सेट के साथ आता है।
यह पृष्ठ निम्न-स्तरीय hub.load() एपीआई और इसके hub.KerasLayer रैपर के साथ TensorFlow 2 प्रोग्राम में TF2 सहेजे गए मॉडल का पुन: उपयोग करने का तरीका बताता है। (आमतौर पर, hub.KerasLayer अन्य tf.keras.layers के साथ मिलाकर एक Keras मॉडल या TF2 एस्टिमेटर के model_fn का निर्माण किया जाता है।) ये API सीमा के भीतर TF1 हब प्रारूप में लीगेसी मॉडल को भी लोड कर सकते हैं, संगतता मार्गदर्शिका देखें।
TensorFlow 1 के उपयोगकर्ता TF 1.15 में अपडेट कर सकते हैं और फिर उसी API का उपयोग कर सकते हैं। TF1 के पुराने संस्करण काम नहीं करते।
टीएफ हब से सहेजे गए मॉडल का उपयोग करना
केरस में सेव्डमॉडल का उपयोग करना
Keras , Keras Layer ऑब्जेक्ट्स की रचना करके गहन शिक्षण मॉडल बनाने के लिए TensorFlow का उच्च-स्तरीय API है। tensorflow_hub लाइब्रेरी क्लास hub.KerasLayer प्रदान करती है। KerasLayer जो एक सहेजे गए मॉडल के URL (या फ़ाइल सिस्टम पथ) के साथ प्रारंभ हो जाता है और फिर सहेजे गए मॉडल से इसकी पूर्व-प्रशिक्षित भार सहित गणना प्रदान करता है।
यहां पूर्व-प्रशिक्षित टेक्स्ट एम्बेडिंग का उपयोग करने का एक उदाहरण दिया गया है:
import tensorflow as tf
import tensorflow_hub as hub
hub_url = "https://tfhub.dev/google/nnlm-en-dim128/2"
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 में वजन करता है। केरसलेयर डिफ़ॉल्ट रूप से गैर-प्रशिक्षण योग्य पर सेट होता है। इसे बदलने के तरीके के लिए नीचे फ़ाइन-ट्यूनिंग पर अनुभाग देखें। केरस में हमेशा की तरह एक ही परत वस्तु के सभी अनुप्रयोगों के बीच वजन साझा किया जाता है।
एस्टीमेटर में सहेजे गए मॉडल का उपयोग करना
वितरित प्रशिक्षण के लिए TensorFlow के एस्टीमेटर API के उपयोगकर्ता अन्य tf.keras.layers के बीच hub.KerasLayer के संदर्भ में अपना model_fn लिखकर TF हब से सहेजे गए मॉडल का उपयोग कर सकते हैं।
पर्दे के पीछे: सेव्डमॉडल डाउनलोडिंग और कैशिंग
TensorFlow हब (या इसके होस्टिंग प्रोटोकॉल को लागू करने वाले अन्य HTTPS सर्वर) से सहेजे गए मॉडल का उपयोग करके इसे स्थानीय फाइल सिस्टम में डाउनलोड और डीकंप्रेस करता है यदि पहले से मौजूद नहीं है। पर्यावरण चर TFHUB_CACHE_DIR डाउनलोड किए गए और असम्पीडित सहेजे गए मॉडलों को कैश करने के लिए डिफ़ॉल्ट अस्थायी स्थान को ओवरराइड करने के लिए सेट किया जा सकता है। विवरण के लिए, कैशिंग देखें।
निम्न-स्तरीय TensorFlow में सहेजे गए मॉडल का उपयोग करना
मॉडल हैंडल
सहेजे गए मॉडल को एक निर्दिष्ट handle से लोड किया जा सकता है, जहां handle एक फ़ाइल सिस्टम पथ है, मान्य TFhub.dev मॉडल URL (जैसे "https://tfhub.dev/ ...")। कागल मॉडल यूआरएल मिरर टीएफहब.देव हमारी शर्तों और मॉडल संपत्तियों से जुड़े लाइसेंस के अनुसार संभालता है, उदाहरण के लिए "https://www.kaggle.com/..."। कागल मॉडल्स के हैंडल उनके संबंधित TFhub.dev हैंडल के समतुल्य हैं।
फ़ंक्शन hub.load(handle) डाउनलोड करता है और सहेजे गए मॉडल को डीकंप्रेस करता है (जब तक कि handle पहले से ही फाइल सिस्टम पथ नहीं है) और फिर इसे TensorFlow के अंतर्निर्मित फ़ंक्शन tf.saved_model.load() के साथ लोड करने का परिणाम देता है। इसलिए, hub.load() किसी भी वैध सहेजे गए मॉडल को संभाल सकता है (इसके पूर्ववर्ती हब के विपरीत। TF1 के लिए hub.Module )।
उन्नत विषय: लोड होने के बाद सहेजे गए मॉडल से क्या अपेक्षा करें
SavedModel की सामग्री के आधार पर, obj = hub.load(...) के परिणाम को विभिन्न तरीकों से लागू किया जा सकता है (जैसा कि TensorFlow's SavedModel Guide में बहुत अधिक विस्तार से बताया गया है:
SavedModel (यदि कोई हो) के सर्विंग सिग्नेचर को ठोस कार्यों के शब्दकोश के रूप में दर्शाया जाता है और
tensors_out = obj.signatures["serving_default"](**tensors_in)की तरह कहा जा सकता है, संबंधित इनपुट और आउटपुट द्वारा टेंसर के शब्दकोशों के साथ नाम और हस्ताक्षर के आकार और dtype बाधाओं के अधीन।सहेजे गए ऑब्जेक्ट (यदि कोई हो) के
@tf.function-सजाए गए तरीकों को tf.function ऑब्जेक्ट्स के रूप में पुनर्स्थापित किया जाता है, जिसे Tensor और गैर-Tensor तर्कों के सभी संयोजनों द्वारा बुलाया जा सकता है, जिसके लिए tf.function को सहेजने से पहले पता लगाया गया था। विशेष रूप से, यदि उपयुक्त निशान के साथ एकobj.__call__विधि है,objको स्वयं को पायथन फ़ंक्शन की तरह कहा जा सकता है। एक साधारण उदाहरण ऐसा लग सकता है जैसेoutput_tensor = obj(input_tensor, training=False)
यह इंटरफेस में भारी स्वतंत्रता छोड़ देता है जिसे सेवमॉडल लागू कर सकता है। obj के लिए पुन: प्रयोज्य सहेजे गए मॉडल इंटरफ़ेस ऐसे सम्मेलनों को स्थापित करता है जैसे क्लाइंट कोड, hub.KerasLayer जैसे एडेप्टर सहित, सहेजे गए मॉडल का उपयोग कैसे करें।
कुछ सहेजे गए मॉडल उस सम्मेलन का पालन नहीं कर सकते हैं, विशेष रूप से पूरे मॉडल बड़े मॉडल में पुन: उपयोग करने के लिए नहीं हैं, और केवल सिग्नेचर प्रदान करते हैं।
एक सहेजे गए मॉडल में प्रशिक्षित करने योग्य चर को प्रशिक्षित करने योग्य के रूप में पुनः लोड किया जाता है, और tf.GradientTape उन्हें डिफ़ॉल्ट रूप से देखेगा। कुछ चेतावनियों के लिए नीचे फाइन-ट्यूनिंग पर अनुभाग देखें, और शुरुआत करने वालों के लिए इससे बचने पर विचार करें। यहां तक कि अगर आप ठीक-ठाक करना चाहते हैं, तो आप यह देखना चाह सकते हैं कि क्या obj.trainable_variables मूल रूप से प्रशिक्षित चर के केवल एक सबसेट को फिर से प्रशिक्षित करने की सलाह देता है।
TF हब के लिए सहेजे गए मॉडल बनाना
अवलोकन
सेव्डमॉडल प्रशिक्षित मॉडल या मॉडल टुकड़ों के लिए TensorFlow का मानक क्रमांकन प्रारूप है। यह अपनी गणना करने के लिए सटीक TensorFlow संचालन के साथ मॉडल के प्रशिक्षित वज़न को एक साथ संग्रहीत करता है। इसे बनाने वाले कोड से स्वतंत्र रूप से इसका उपयोग किया जा सकता है। विशेष रूप से, इसे केरस जैसे विभिन्न उच्च-स्तरीय मॉडल-निर्माण एपीआई में पुन: उपयोग किया जा सकता है, क्योंकि TensorFlow संचालन उनकी सामान्य मूल भाषा है।
केरस से बचत
TensorFlow 2 से शुरू होकर, tf.keras.Model.save() और tf.keras.models.save_model() डिफ़ॉल्ट रूप से SavedModel प्रारूप (HDF5 नहीं) के लिए। परिणामी सहेजे गए मॉडल जिनका उपयोग अन्य उच्च-स्तरीय एपीआई के लिए hub.load() , hub.KerasLayer और इसी तरह के एडेप्टर के साथ किया जा सकता है, क्योंकि वे उपलब्ध हो जाते हैं।
एक पूर्ण केरस मॉडल साझा करने के लिए, बस इसे 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/tools/export_tfhub_lib.py देखें, निर्यात के लिए core_model और चेकपॉइंट को पुनर्स्थापित करने के लिए pretrainer के बीच विभाजन पर ध्यान दें) और ResNet के लिए बाद वाला दृष्टिकोण (देखें विरासत/image_classification/tfhub_export.py ).
निम्न-स्तरीय TensorFlow से बचत
इसके लिए TensorFlow के सेव्डमॉडल गाइड की अच्छी जानकारी होनी चाहिए।
यदि आप केवल एक सेवारत हस्ताक्षर से अधिक प्रदान करना चाहते हैं, तो आपको पुन: प्रयोज्य सहेजे गए मॉडल इंटरफ़ेस को लागू करना चाहिए। संकल्पनात्मक रूप से, ऐसा दिखता है
class MyMulModel(tf.train.Checkpoint):
def __init__(self, v_init):
super().__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
फ़ाइन ट्यूनिंग
आयातित सहेजे गए मॉडल के पहले से प्रशिक्षित चर को इसके आसपास के मॉडल के साथ प्रशिक्षण देना सहेजे गए मॉडल को ठीक-ट्यूनिंग कहा जाता है। इसका परिणाम बेहतर गुणवत्ता में हो सकता है, लेकिन अक्सर प्रशिक्षण को और अधिक मांग वाला बना देता है (अधिक समय लग सकता है, ऑप्टिमाइज़र और इसके हाइपरपैरामीटर पर अधिक निर्भर करता है, ओवरफिटिंग के जोखिम को बढ़ाता है और डेटासेट वृद्धि की आवश्यकता होती है, विशेष रूप से सीएनएन के लिए)। हम सेव्डमॉडल उपभोक्ताओं को सलाह देते हैं कि वे एक अच्छा प्रशिक्षण व्यवस्था स्थापित करने के बाद ही फाइन-ट्यूनिंग पर ध्यान दें, और केवल तभी जब सेव्डमॉडल प्रकाशक इसकी अनुशंसा करता है।
फाइन-ट्यूनिंग प्रशिक्षित किए गए "निरंतर" मॉडल पैरामीटर को बदलता है। यह हार्ड-कोडेड ट्रांसफ़ॉर्मेशन को नहीं बदलता है, जैसे टेक्स्ट इनपुट को टोकनाइज़ करना और एम्बेडिंग मैट्रिक्स में संबंधित प्रविष्टियों के लिए टोकन मैप करना।
सेव्डमॉडल उपभोक्ताओं के लिए
hub.KerasLayer बनाना। केरसलेयर लाइक
layer = hub.KerasLayer(..., trainable=True)
परत द्वारा लोड किए गए सहेजे गए मॉडल के ठीक-ट्यूनिंग को सक्षम करता है। यह सहेजे गए मॉडल में केरास मॉडल में घोषित ट्रेन योग्य वजन और वजन नियमितता जोड़ता है, और सहेजे गए मॉडल की गणना प्रशिक्षण मोड में चलाता है (ड्रॉपआउट इत्यादि के बारे में सोचें)।
छवि वर्गीकरण कोलाब में वैकल्पिक फ़ाइन-ट्यूनिंग के साथ शुरू से अंत तक का उदाहरण है।
फ़ाइन-ट्यूनिंग परिणाम को पुनः निर्यात करना
उन्नत उपयोगकर्ता फ़ाइन-ट्यूनिंग के परिणामों को सहेजे गए मॉडल में वापस सहेजना चाह सकते हैं जिसका उपयोग मूल रूप से लोड किए गए के बजाय किया जा सकता है। यह जैसे कोड के साथ किया जा सकता है
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)
सेव्डमॉडल क्रिएटर्स के लिए
TensorFlow हब पर साझा करने के लिए एक सहेजा गया मॉडल बनाते समय, आगे सोचें कि क्या और कैसे इसके उपभोक्ताओं को इसे ठीक करना चाहिए, और दस्तावेज़ीकरण में मार्गदर्शन प्रदान करना चाहिए।
एक केरास मॉडल से बचत को ठीक-ट्यूनिंग कार्य के सभी यांत्रिकी बनाना चाहिए (वजन नियमितीकरण के नुकसान को बचाना, प्रशिक्षण योग्य चर घोषित करना, training=True और training=False , आदि दोनों के लिए __call__ पता लगाना)
एक मॉडल इंटरफ़ेस चुनें जो ढाल प्रवाह के साथ अच्छा खेलता है, उदाहरण के लिए, सॉफ्टमैक्स संभावनाओं या टॉप-के भविष्यवाणियों के बजाय आउटपुट लॉग्स।
यदि मॉडल ड्रॉपआउट, बैच सामान्यीकरण, या इसी तरह की प्रशिक्षण तकनीकों का उपयोग करता है जिसमें हाइपरपरमेटर्स शामिल हैं, तो उन्हें उन मानों पर सेट करें जो कई अपेक्षित लक्ष्य समस्याओं और बैच आकारों में समझ में आते हैं। (इस लेखन के अनुसार, केरस से बचत करना उपभोक्ताओं को उन्हें समायोजित करने देना आसान नहीं बनाता है।)
अलग-अलग परतों पर वजन नियमित करने वाले सहेजे जाते हैं (उनके नियमितीकरण शक्ति गुणांक के साथ), लेकिन अनुकूलक के भीतर से वजन नियमितीकरण (जैसे tf.keras.optimizers.Ftrl.l1_regularization_strength=...) ) खो जाता है। तदनुसार अपने सहेजे गए मॉडल के उपभोक्ताओं को सलाह दें।