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

सहेजे गए मॉडल प्रारूप का उपयोग करना

TensorFlow.org पर देखें

Google Colab में चलाएं

GitHub पर स्रोत देखें

नोटबुक डाउनलोड करें

एक सहेजे गए मॉडल में प्रशिक्षित पैरामीटर (यानी, tf.Variable s) और गणना सहित एक पूर्ण TensorFlow प्रोग्राम होता है। इसे चलाने के लिए मूल मॉडल बिल्डिंग कोड की आवश्यकता नहीं होती है, जो इसे TFLite , TensorFlow.js , TensorFlow Serving , या TensorFlow हब के साथ साझा या परिनियोजित करने के लिए उपयोगी बनाता है।

आप निम्न API का उपयोग करके सहेजे गए मॉडल प्रारूप में एक मॉडल को सहेज और लोड कर सकते हैं:

निम्न-स्तरीय tf.saved_model API। यह दस्तावेज़ बताता है कि इस एपीआई का विस्तार से उपयोग कैसे करें।
- सहेजें: tf.saved_model.save(model, path_to_dir)
- लोड: model = tf.saved_model.load(path_to_dir)
उच्च स्तरीय tf.keras.Model API। केरस सेव और सीरियलाइज़ गाइड देखें।
यदि आप प्रशिक्षण के दौरान केवल वज़न बचाना/लोड करना चाहते हैं, तो चेकपॉइंट गाइड देखें।

केरास से एक सहेजा गया मॉडल बनाना

एक त्वरित परिचय के लिए, यह खंड एक पूर्व-प्रशिक्षित केरस मॉडल का निर्यात करता है और इसके साथ छवि वर्गीकरण अनुरोधों को पूरा करता है। शेष मार्गदर्शिका विवरण भरेगी और सहेजे गए मॉडल बनाने के अन्य तरीकों पर चर्चा करेगी।

import os
import tempfile

from matplotlib import pyplot as plt
import numpy as np
import tensorflow as tf

tmpdir = tempfile.mkdtemp()

physical_devices = tf.config.list_physical_devices('GPU')
for device in physical_devices:
  tf.config.experimental.set_memory_growth(device, True)

file = tf.keras.utils.get_file(
    "grace_hopper.jpg",
    "https://storage.googleapis.com/download.tensorflow.org/example_images/grace_hopper.jpg")
img = tf.keras.utils.load_img(file, target_size=[224, 224])
plt.imshow(img)
plt.axis('off')
x = tf.keras.utils.img_to_array(img)
x = tf.keras.applications.mobilenet.preprocess_input(
    x[tf.newaxis,...])

Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/grace_hopper.jpg
65536/61306 [================================] - 0s 0us/step
73728/61306 [====================================] - 0s 0us/step

पीएनजी

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

labels_path = tf.keras.utils.get_file(
    'ImageNetLabels.txt',
    'https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt')
imagenet_labels = np.array(open(labels_path).read().splitlines())

Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt
16384/10484 [==============================================] - 0s 0us/step
24576/10484 [======================================================================] - 0s 0us/step

pretrained_model = tf.keras.applications.MobileNet()
result_before_save = pretrained_model(x)

decoded = imagenet_labels[np.argsort(result_before_save)[0,::-1][:5]+1]

print("Result before saving:\n", decoded)

Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/mobilenet/mobilenet_1_0_224_tf.h5
17227776/17225924 [==============================] - 0s 0us/step
17235968/17225924 [==============================] - 0s 0us/step
Result before saving:
 ['military uniform' 'bow tie' 'suit' 'bearskin' 'pickelhaube']

इस छवि के लिए शीर्ष भविष्यवाणी "सैन्य वर्दी" है।

mobilenet_save_path = os.path.join(tmpdir, "mobilenet/1/")
tf.saved_model.save(pretrained_model, mobilenet_save_path)

2021-10-27 01:24:27.831628: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: /tmp/tmpbf9fpzwt/mobilenet/1/assets

सेव-पथ TensorFlow सर्विंग द्वारा उपयोग किए जाने वाले एक सम्मेलन का अनुसरण करता है जहां अंतिम पथ घटक ( 1/ यहां) आपके मॉडल के लिए एक संस्करण संख्या है - यह Tensorflow Serving जैसे उपकरणों को सापेक्ष ताजगी के बारे में तर्क करने की अनुमति देता है।

आप सहेजे गए मॉडल को tf.saved_model.load के साथ वापस पायथन में लोड कर सकते हैं और देख सकते हैं कि एडमिरल हूपर की छवि को कैसे वर्गीकृत किया जाता है।

loaded = tf.saved_model.load(mobilenet_save_path)
print(list(loaded.signatures.keys()))  # ["serving_default"]

['serving_default']

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

infer = loaded.signatures["serving_default"]
print(infer.structured_outputs)

{'predictions': TensorSpec(shape=(None, 1000), dtype=tf.float32, name='predictions')}

सहेजे गए मॉडल से चल रहा निष्कर्ष मूल मॉडल के समान परिणाम देता है।

labeling = infer(tf.constant(x))[pretrained_model.output_names[0]]

decoded = imagenet_labels[np.argsort(labeling)[0,::-1][:5]+1]

print("Result after saving and loading:\n", decoded)

Result after saving and loading:
 ['military uniform' 'bow tie' 'suit' 'bearskin' 'pickelhaube']

TensorFlow सर्विंग में एक सहेजा गया मॉडल चलाना

सहेजे गए मॉडल पायथन से उपयोग करने योग्य हैं (उस पर अधिक नीचे), लेकिन उत्पादन वातावरण आमतौर पर पायथन कोड को चलाए बिना अनुमान के लिए एक समर्पित सेवा का उपयोग करते हैं। TensorFlow सर्विंग का उपयोग करके सहेजे गए मॉडल से इसे स्थापित करना आसान है।

एंड-टू-एंड टेंसरफ़्लो-सर्विंग उदाहरण के लिए TensorFlow सर्विंग REST ट्यूटोरियल देखें।

डिस्क पर सहेजा गया मॉडल प्रारूप

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

ls {mobilenet_save_path}

assets  saved_model.pb  variables

saved_model.pb फ़ाइल वास्तविक TensorFlow प्रोग्राम, या मॉडल, और नामित हस्ताक्षरों का एक सेट संग्रहीत करती है, प्रत्येक एक फ़ंक्शन की पहचान करता है जो टेंसर इनपुट स्वीकार करता है और टेंसर आउटपुट उत्पन्न करता है।

सहेजे गए मॉडल में मॉडल के कई प्रकार हो सकते हैं (एकाधिक v1.MetaGraphDefs , जिसे --tag_set ध्वज से saved_model_cli ) पहचाना जाता है, लेकिन यह दुर्लभ है। एपीआई जो एक मॉडल के कई प्रकार बनाते हैं उनमें tf.Estimator.experimental_export_all_saved_models और TensorFlow 1.x tf.saved_model.Builder शामिल हैं।

saved_model_cli show --dir {mobilenet_save_path} --tag_set serve

The given SavedModel MetaGraphDef contains SignatureDefs with the following keys:
SignatureDef key: "__saved_model_init_op"
SignatureDef key: "serving_default"

variables निर्देशिका में एक मानक प्रशिक्षण चेकपॉइंट होता है (प्रशिक्षण चौकियों के लिए मार्गदर्शिका देखें)।

ls {mobilenet_save_path}/variables

variables.data-00000-of-00001  variables.index

प्लेसहोल्डर22

assets निर्देशिका में TensorFlow ग्राफ़ द्वारा उपयोग की जाने वाली फ़ाइलें होती हैं, उदाहरण के लिए शब्दावली तालिकाओं को प्रारंभ करने के लिए उपयोग की जाने वाली टेक्स्ट फ़ाइलें। इस उदाहरण में इसका उपयोग नहीं किया गया है।

SavedModels में TensorFlow ग्राफ़ द्वारा उपयोग नहीं की जाने वाली किसी भी फ़ाइल के लिए assets.extra निर्देशिका हो सकती है, उदाहरण के लिए उपभोक्ताओं के लिए जानकारी के बारे में कि SavedModel के साथ क्या करना है। TensorFlow स्वयं इस निर्देशिका का उपयोग नहीं करता है।

एक कस्टम मॉडल सहेजा जा रहा है

tf.saved_model.save tf.Module ऑब्जेक्ट और उसके उपवर्गों को सहेजने का समर्थन करता है, जैसे tf.keras.Layer और tf.keras.Model ।

आइए tf.Module को सहेजने और पुनर्स्थापित करने का एक उदाहरण देखें।

class CustomModule(tf.Module):

  def __init__(self):
    super(CustomModule, self).__init__()
    self.v = tf.Variable(1.)

  @tf.function
  def __call__(self, x):
    print('Tracing with', x)
    return x * self.v

  @tf.function(input_signature=[tf.TensorSpec([], tf.float32)])
  def mutate(self, new_v):
    self.v.assign(new_v)

module = CustomModule()

जब आप एक tf.Module हैं, तो कोई भी tf.Variable विशेषताएँ, tf.function -सज्जित विधियाँ, और tf.Module पुनरावर्ती ट्रैवर्सल के माध्यम से सहेजे जाते हैं। (इस पुनरावर्ती ट्रैवर्सल के बारे में अधिक के लिए चेकपॉइंट ट्यूटोरियल देखें।) हालांकि, कोई भी पायथन विशेषता, कार्य और डेटा खो जाता है। इसका मतलब है कि जब कोई tf.function सहेजा जाता है, तो कोई भी पायथन कोड सहेजा नहीं जाता है।

यदि कोई पायथन कोड सहेजा नहीं गया है, तो सहेजे गए मॉडल को फ़ंक्शन को पुनर्स्थापित करने का तरीका कैसे पता चलता है?

संक्षेप में, tf.function एक ConcreteFunction ( tf.Graph के चारों ओर एक कॉल करने योग्य आवरण) उत्पन्न करने के लिए पायथन कोड को ट्रेस करके काम करता है। tf.function सहेजते समय, आप वास्तव में tf.function के ConcreteFunctions के कैश को सहेज रहे हैं।

tf.function और ConcreteFunctions के बीच संबंध के बारे में अधिक जानने के लिए, tf.function गाइड देखें।

module_no_signatures_path = os.path.join(tmpdir, 'module_no_signatures')
module(tf.constant(0.))
print('Saving model...')
tf.saved_model.save(module, module_no_signatures_path)

Tracing with Tensor("x:0", shape=(), dtype=float32)
Saving model...
Tracing with Tensor("x:0", shape=(), dtype=float32)
INFO:tensorflow:Assets written to: /tmp/tmpbf9fpzwt/module_no_signatures/assets

एक कस्टम मॉडल लोड करना और उसका उपयोग करना

जब आप Python में एक SavedModel लोड करते हैं, तो सभी tf.Variable विशेषताएँ, tf.function -decorated तरीके, और tf.Module s को उसी ऑब्जेक्ट संरचना में पुनर्स्थापित किया जाता है, जिसमें मूल सहेजा tf.Module है।

imported = tf.saved_model.load(module_no_signatures_path)
assert imported(tf.constant(3.)).numpy() == 3
imported.mutate(tf.constant(2.))
assert imported(tf.constant(3.)).numpy() == 6

चूंकि कोई पायथन कोड सहेजा नहीं गया है, इसलिए एक नए इनपुट हस्ताक्षर के साथ tf.function को कॉल करना विफल हो जाएगा:

imported(tf.constant([3.]))

ValueError: Could not find matching function to call for canonicalized inputs ((,), {}). Only existing signatures are [((TensorSpec(shape=(), dtype=tf.float32, name=u'x'),), {})].

बेसिक फाइन-ट्यूनिंग

परिवर्तनीय वस्तुएं उपलब्ध हैं, और आप आयातित कार्यों के माध्यम से बैकप्रॉप कर सकते हैं। यह साधारण मामलों में एक सहेजे गए मॉडल को ठीक करने (यानी फिर से प्रशिक्षित) करने के लिए पर्याप्त है।

optimizer = tf.optimizers.SGD(0.05)

def train_step():
  with tf.GradientTape() as tape:
    loss = (10. - imported(tf.constant(2.))) ** 2
  variables = tape.watched_variables()
  grads = tape.gradient(loss, variables)
  optimizer.apply_gradients(zip(grads, variables))
  return loss

for _ in range(10):
  # "v" approaches 5, "loss" approaches 0
  print("loss={:.2f} v={:.2f}".format(train_step(), imported.v.numpy()))

loss=36.00 v=3.20
loss=12.96 v=3.92
loss=4.67 v=4.35
loss=1.68 v=4.61
loss=0.60 v=4.77
loss=0.22 v=4.86
loss=0.08 v=4.92
loss=0.03 v=4.95
loss=0.01 v=4.97
loss=0.00 v=4.98

सामान्य फाइन-ट्यूनिंग

केरस का एक सेव्डमॉडल फाइन-ट्यूनिंग के अधिक उन्नत मामलों को संबोधित करने के लिए एक सादे __call__ की तुलना में अधिक विवरण प्रदान करता है। TensorFlow हब फाइन-ट्यूनिंग के उद्देश्य से साझा किए गए सहेजे गए मॉडल में, यदि लागू हो, उनमें से निम्नलिखित प्रदान करने की अनुशंसा करता है:

यदि मॉडल ड्रॉपआउट या किसी अन्य तकनीक का उपयोग करता है जिसमें फॉरवर्ड पास प्रशिक्षण और अनुमान (जैसे बैच सामान्यीकरण) के बीच भिन्न होता है, तो __call__ विधि एक वैकल्पिक, पायथन-मूल्यवान training= तर्क लेती है जो डिफ़ॉल्ट रूप से False है लेकिन इसे True पर सेट किया जा सकता है।
__call__ विशेषता के आगे, चर की संबंधित सूचियों के साथ .variable और .trainable_variable विशेषताएँ हैं। एक वैरिएबल जिसे मूल रूप से प्रशिक्षित किया जा सकता था, लेकिन फ़ाइन-ट्यूनिंग के दौरान फ़्रीज़ होने के लिए होता है, .trainable_variables से हटा दिया जाता है।
केरस जैसे ढांचे के लिए, जो परतों या उप-मॉडल की विशेषताओं के रूप में वजन नियमित करने वालों का प्रतिनिधित्व करते हैं, वहां एक .regularization_losses विशेषता भी हो सकती है। इसमें शून्य-तर्क कार्यों की एक सूची है, जिनके मूल्य कुल नुकसान के अतिरिक्त हैं।

प्रारंभिक MobileNet उदाहरण पर वापस जाने पर, आप उनमें से कुछ को कार्य करते हुए देख सकते हैं:

loaded = tf.saved_model.load(mobilenet_save_path)
print("MobileNet has {} trainable variables: {}, ...".format(
          len(loaded.trainable_variables),
          ", ".join([v.name for v in loaded.trainable_variables[:5]])))

MobileNet has 83 trainable variables: conv1/kernel:0, conv1_bn/gamma:0, conv1_bn/beta:0, conv_dw_1/depthwise_kernel:0, conv_dw_1_bn/gamma:0, ...

trainable_variable_ids = {id(v) for v in loaded.trainable_variables}
non_trainable_variables = [v for v in loaded.variables
                           if id(v) not in trainable_variable_ids]
print("MobileNet also has {} non-trainable variables: {}, ...".format(
          len(non_trainable_variables),
          ", ".join([v.name for v in non_trainable_variables[:3]])))

MobileNet also has 54 non-trainable variables: conv1_bn/moving_mean:0, conv1_bn/moving_variance:0, conv_dw_1_bn/moving_mean:0, ...

निर्यात के दौरान हस्ताक्षर निर्दिष्ट करना

TensorFlow Serving और saved_model_cli जैसे टूल SavedModels के साथ इंटरैक्ट कर सकते हैं। इन उपकरणों को यह निर्धारित करने में मदद करने के लिए कि कौन से ConcreteFunctions का उपयोग करना है, आपको सेवारत हस्ताक्षर निर्दिष्ट करने की आवश्यकता है। tf.keras.Model स्वचालित रूप से सेवारत हस्ताक्षर निर्दिष्ट करता है, लेकिन आपको हमारे कस्टम मॉड्यूल के लिए स्पष्ट रूप से एक सेवारत हस्ताक्षर घोषित करना होगा।

डिफ़ॉल्ट रूप से, कस्टम tf.Module में कोई हस्ताक्षर घोषित नहीं किया जाता है।

assert len(imported.signatures) == 0

एक सेवारत हस्ताक्षर घोषित करने के लिए, kwarg signatures का उपयोग करके एक ConcreteFunction निर्दिष्ट करें। किसी एकल हस्ताक्षर को निर्दिष्ट करते समय, उसकी हस्ताक्षर कुंजी 'serving_default' होगी, जिसे स्थिर tf.saved_model.DEFAULT_SERVING_SIGNATURE_DEF_KEY के रूप में सहेजा जाता है।

module_with_signature_path = os.path.join(tmpdir, 'module_with_signature')
call = module.__call__.get_concrete_function(tf.TensorSpec(None, tf.float32))
tf.saved_model.save(module, module_with_signature_path, signatures=call)

Tracing with Tensor("x:0", dtype=float32)
Tracing with Tensor("x:0", dtype=float32)
INFO:tensorflow:Assets written to: /tmp/tmpbf9fpzwt/module_with_signature/assets

imported_with_signatures = tf.saved_model.load(module_with_signature_path)
list(imported_with_signatures.signatures.keys())

['serving_default']

एक से अधिक हस्ताक्षर निर्यात करने के लिए, ConcreteFunctions को हस्ताक्षर कुंजियों का एक शब्दकोश पास करें। प्रत्येक हस्ताक्षर कुंजी एक ConcreteFunction से मेल खाती है।

module_multiple_signatures_path = os.path.join(tmpdir, 'module_with_multiple_signatures')
signatures = {"serving_default": call,
              "array_input": module.__call__.get_concrete_function(tf.TensorSpec([None], tf.float32))}

tf.saved_model.save(module, module_multiple_signatures_path, signatures=signatures)

Tracing with Tensor("x:0", shape=(None,), dtype=float32)
Tracing with Tensor("x:0", shape=(None,), dtype=float32)
INFO:tensorflow:Assets written to: /tmp/tmpbf9fpzwt/module_with_multiple_signatures/assets

imported_with_multiple_signatures = tf.saved_model.load(module_multiple_signatures_path)
list(imported_with_multiple_signatures.signatures.keys())

['serving_default', 'array_input']

डिफ़ॉल्ट रूप से, आउटपुट टेंसर नाम काफी सामान्य होते हैं, जैसे output_0 । आउटपुट के नामों को नियंत्रित करने के लिए, अपने tf.function को संशोधित करके एक डिक्शनरी लौटाएं जो आउटपुट नामों को आउटपुट में मैप करता है। इनपुट के नाम पायथन फ़ंक्शन arg नामों से लिए गए हैं।

class CustomModuleWithOutputName(tf.Module):
  def __init__(self):
    super(CustomModuleWithOutputName, self).__init__()
    self.v = tf.Variable(1.)

  @tf.function(input_signature=[tf.TensorSpec([], tf.float32)])
  def __call__(self, x):
    return {'custom_output_name': x * self.v}

module_output = CustomModuleWithOutputName()
call_output = module_output.__call__.get_concrete_function(tf.TensorSpec(None, tf.float32))
module_output_path = os.path.join(tmpdir, 'module_with_output_name')
tf.saved_model.save(module_output, module_output_path,
                    signatures={'serving_default': call_output})

INFO:tensorflow:Assets written to: /tmp/tmpbf9fpzwt/module_with_output_name/assets

imported_with_output_name = tf.saved_model.load(module_output_path)
imported_with_output_name.signatures['serving_default'].structured_outputs

{'custom_output_name': TensorSpec(shape=(), dtype=tf.float32, name='custom_output_name')}

सी ++ में एक सहेजा गया मॉडल लोड करें

सेव्डमॉडल लोडर का सी ++ संस्करण सेशनऑप्शन और रनऑप्शन की अनुमति देते हुए एक पथ से एक सेव्डमॉडल को लोड करने के लिए एक एपीआई प्रदान करता है। आपको ग्राफ़ से जुड़े टैग को लोड करने के लिए निर्दिष्ट करना होगा। SavedModel के लोड किए गए संस्करण को SavedModelBundle के रूप में संदर्भित किया जाता है और इसमें MetaGraphDef और वह सत्र होता है जिसके भीतर इसे लोड किया जाता है।

const string export_dir = ...
SavedModelBundle bundle;
...
LoadSavedModel(session_options, run_options, export_dir, {kSavedModelTagTrain},
               &bundle);

सेव्डमॉडल कमांड लाइन इंटरफेस का विवरण

सहेजे गए मॉडल का निरीक्षण और निष्पादन करने के लिए आप सहेजे गए मॉडल कमांड लाइन इंटरफेस (सीएलआई) का उपयोग कर सकते हैं। उदाहरण के लिए, आप मॉडल के SignatureDef s का निरीक्षण करने के लिए CLI का उपयोग कर सकते हैं। सीएलआई आपको जल्दी से पुष्टि करने में सक्षम बनाता है कि इनपुट टेंसर प्रकार और आकार मॉडल से मेल खाते हैं। इसके अलावा, यदि आप अपने मॉडल का परीक्षण करना चाहते हैं, तो आप विभिन्न प्रारूपों (उदाहरण के लिए, पायथन एक्सप्रेशन) में नमूना इनपुट पास करके और फिर आउटपुट प्राप्त करके एक विवेक जांच करने के लिए सीएलआई का उपयोग कर सकते हैं।

सहेजे गए मॉडल सीएलआई स्थापित करें

मोटे तौर पर, आप TensorFlow को निम्नलिखित दो तरीकों में से किसी एक में स्थापित कर सकते हैं:

एक पूर्व-निर्मित TensorFlow बाइनरी स्थापित करके।
स्रोत कोड से TensorFlow का निर्माण करके।

यदि आपने पूर्व-निर्मित TensorFlow बाइनरी के माध्यम से TensorFlow स्थापित किया है, तो आपके सिस्टम पर पथनाम bin/saved_model_cli पर SavedModel CLI पहले से ही स्थापित है।

यदि आपने स्रोत कोड से TensorFlow बनाया है, तो आपको saved_model_cli बनाने के लिए निम्नलिखित अतिरिक्त कमांड चलानी होगी:

$ bazel build tensorflow/python/tools:saved_model_cli

आदेशों का अवलोकन

सहेजे गए मॉडल सीएलआई सहेजे गए मॉडल पर निम्नलिखित दो आदेशों का समर्थन करता है:

show , जो एक सहेजे गए मॉडल से उपलब्ध गणनाओं को दिखाता है।
run , जो एक सहेजे गए मॉडल से गणना चलाता है।

कमांड `show`

एक सहेजे गए मॉडल में एक या अधिक मॉडल प्रकार होते हैं (तकनीकी रूप से, v1.MetaGraphDef s), उनके टैग-सेट द्वारा पहचाने जाते हैं। एक मॉडल की सेवा के लिए, आपको आश्चर्य हो सकता है कि प्रत्येक मॉडल संस्करण में किस प्रकार के SignatureDef हैं, और उनके इनपुट और आउटपुट क्या हैं। show कमांड आपको सहेजे गए मॉडल की सामग्री को पदानुक्रमित क्रम में जांचने देता है। यहाँ वाक्य रचना है:

usage: saved_model_cli show [-h] --dir DIR [--all]
[--tag_set TAG_SET] [--signature_def SIGNATURE_DEF_KEY]

उदाहरण के लिए, निम्न आदेश सहेजे गए मॉडल में सभी उपलब्ध टैग-सेट दिखाता है:

$ saved_model_cli show --dir /tmp/saved_model_dir
The given SavedModel contains the following tag-sets:
serve
serve, gpu

निम्न कमांड एक टैग सेट के लिए सभी उपलब्ध SignatureDef कुंजियाँ दिखाता है:

$ saved_model_cli show --dir /tmp/saved_model_dir --tag_set serve
The given SavedModel `MetaGraphDef` contains `SignatureDefs` with the
following keys:
SignatureDef key: "classify_x2_to_y3"
SignatureDef key: "classify_x_to_y"
SignatureDef key: "regress_x2_to_y3"
SignatureDef key: "regress_x_to_y"
SignatureDef key: "regress_x_to_y2"
SignatureDef key: "serving_default"

यदि टैग-सेट में एक से अधिक टैग हैं, तो आपको सभी टैग निर्दिष्ट करने होंगे, प्रत्येक टैग अल्पविराम से अलग किया जाएगा। उदाहरण के लिए:

$ saved_model_cli show --dir /tmp/saved_model_dir --tag_set serve,gpu

एक विशिष्ट SignatureDef के लिए सभी इनपुट और आउटपुट TensorInfo दिखाने के लिए, SignatureDef कुंजी को signature_def विकल्प में पास करें। यह बहुत उपयोगी है जब आप बाद में गणना ग्राफ को निष्पादित करने के लिए टेन्सर कुंजी मान, dtype और इनपुट टेंसर के आकार को जानना चाहते हैं। उदाहरण के लिए:

$ saved_model_cli show --dir \
/tmp/saved_model_dir --tag_set serve --signature_def serving_default
The given SavedModel SignatureDef contains the following input(s):
  inputs['x'] tensor_info:
      dtype: DT_FLOAT
      shape: (-1, 1)
      name: x:0
The given SavedModel SignatureDef contains the following output(s):
  outputs['y'] tensor_info:
      dtype: DT_FLOAT
      shape: (-1, 1)
      name: y:0
Method name is: tensorflow/serving/predict

सहेजे गए मॉडल में सभी उपलब्ध जानकारी दिखाने के लिए --all विकल्प का उपयोग करें। उदाहरण के लिए:

$ saved_model_cli show --dir /tmp/saved_model_dir --all
MetaGraphDef with tag-set: 'serve' contains the following SignatureDefs:

signature_def['classify_x2_to_y3']:
  The given SavedModel SignatureDef contains the following input(s):
    inputs['inputs'] tensor_info:
        dtype: DT_FLOAT
        shape: (-1, 1)
        name: x2:0
  The given SavedModel SignatureDef contains the following output(s):
    outputs['scores'] tensor_info:
        dtype: DT_FLOAT
        shape: (-1, 1)
        name: y3:0
  Method name is: tensorflow/serving/classify

...

signature_def['serving_default']:
  The given SavedModel SignatureDef contains the following input(s):
    inputs['x'] tensor_info:
        dtype: DT_FLOAT
        shape: (-1, 1)
        name: x:0
  The given SavedModel SignatureDef contains the following output(s):
    outputs['y'] tensor_info:
        dtype: DT_FLOAT
        shape: (-1, 1)
        name: y:0
  Method name is: tensorflow/serving/predict

`run` कमांड

ग्राफ़ गणना चलाने, इनपुट पास करने और फिर आउटपुट प्रदर्शित करने (और वैकल्पिक रूप से सहेजने) के लिए run कमांड को आमंत्रित करें। यहाँ वाक्य रचना है:

usage: saved_model_cli run [-h] --dir DIR --tag_set TAG_SET --signature_def
                           SIGNATURE_DEF_KEY [--inputs INPUTS]
                           [--input_exprs INPUT_EXPRS]
                           [--input_examples INPUT_EXAMPLES] [--outdir OUTDIR]
                           [--overwrite] [--tf_debug]

run कमांड मॉडल को इनपुट पास करने के लिए निम्नलिखित तीन तरीके प्रदान करता है:

--inputs विकल्प आपको फाइलों में numpy ndarray पास करने में सक्षम बनाता है।
--input_exprs विकल्प आपको पायथन एक्सप्रेशन पास करने में सक्षम बनाता है।
--input_examples विकल्प आपको tf.train.Example पास करने में सक्षम बनाता है।

`--inputs`

फ़ाइलों में इनपुट डेटा पास करने के लिए, --inputs विकल्प निर्दिष्ट करें, जो निम्न सामान्य प्रारूप लेता है:

--inputs <INPUTS>

जहां इनपुट निम्नलिखित प्रारूपों में से एक है:

<input_key>=<filename>
<input_key>=<filename>[<variable_name>]

आप कई इनपुट पास कर सकते हैं। यदि आप एकाधिक इनपुट पास करते हैं, तो प्रत्येक इनपुट को अलग करने के लिए अर्धविराम का उपयोग करें।

saved_model_cli फ़ाइल नाम लोड करने के लिए numpy.load का उपयोग करता है। फ़ाइल नाम निम्न में से किसी भी प्रारूप में हो सकता है:

.npy
.npz
अचार प्रारूप

एक .npy फ़ाइल में हमेशा एक numpy ndarray होता है। इसलिए, .npy फ़ाइल से लोड करते समय, सामग्री को सीधे निर्दिष्ट इनपुट टेंसर को सौंपा जाएगा। यदि आप उस .npy फ़ाइल के साथ एक चर_नाम निर्दिष्ट करते हैं, तो चर_नाम को अनदेखा कर दिया जाएगा और एक चेतावनी जारी की जाएगी।

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

अचार फ़ाइल से लोड करते समय, यदि वर्ग कोष्ठक में कोई variable_name निर्दिष्ट नहीं है, तो अचार फ़ाइल के अंदर जो कुछ भी है वह निर्दिष्ट इनपुट टेंसर कुंजी को दिया जाएगा। अन्यथा, सेव्डमॉडल सीएलआई मान लेगा कि एक डिक्शनरी अचार फ़ाइल में संग्रहीत है और वेरिएबल_नाम से संबंधित मान का उपयोग किया जाएगा।

`--input_exprs`

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

`<input_key>=[[1],[2],[3]]`

पायथन एक्सप्रेशन के अलावा, आप numpy फंक्शन भी पास कर सकते हैं। उदाहरण के लिए:

`<input_key>=np.ones((32,32,3))`

(ध्यान दें कि numpy मॉड्यूल आपके लिए पहले से ही np के रूप में उपलब्ध है।)

`--input_examples`

इनपुट के रूप में tf.train.Example पास करने के लिए, --input_examples विकल्प निर्दिष्ट करें। प्रत्येक इनपुट कुंजी के लिए, यह शब्दकोश की एक सूची लेता है, जहां प्रत्येक शब्दकोश tf.train.Example का एक उदाहरण है। शब्दकोश कुंजियाँ विशेषताएँ हैं और मान प्रत्येक विशेषता के लिए मूल्य सूची हैं। उदाहरण के लिए:

`<input_key>=[{"age":[22,24],"education":["BS","MS"]}]`

आउटपुट सहेजें

डिफ़ॉल्ट रूप से, SavedModel CLI आउटपुट को stdout में लिखता है। यदि कोई निर्देशिका --outdir विकल्प को पास की जाती है, तो आउटपुट को .npy फ़ाइलों के रूप में सहेजा जाएगा, जिसका नाम दी गई निर्देशिका के तहत आउटपुट टेंसर कुंजियों के नाम पर रखा गया है।

मौजूदा आउटपुट फ़ाइलों को अधिलेखित करने के लिए --overwrite का उपयोग करें।