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

SavedModel प्रारूप का उपयोग करना

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

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

यह दस्तावेज़ निम्न-स्तरीय tf.saved_model api का उपयोग करने के कुछ विवरणों में tf.saved_model :

करैस से एक सेव्डमॉडल बनाना

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

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.experimental.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.preprocessing.image.load_img(file, target_size=[224, 224])
plt.imshow(img)
plt.axis('off')
x = tf.keras.preprocessing.image.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

png

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

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

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 [==============================] - 1s 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)
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: /tmp/tmpqrbxtm18/mobilenet/1/assets

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

आप के साथ अजगर में SavedModel वापस लोड कर सकते हैं 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 सर्विंग में एक SavedModel चल रहा है

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

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

डिस्क पर SavedModel प्रारूप

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

ls {mobilenet_save_path}
assets  saved_model.pb  variables

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

SavedModels में मॉडल (मल्टीपल v1.MetaGraphDefs , को --tag_set फ्लैग से saved_model_cli ) के रूप में saved_model_cli , लेकिन यह दुर्लभ है। एक मॉडल के कई वेरिएंट बनाने वाले API में 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
2020-10-13 01:23:41.728141: I tensorflow/stream_executor/platform/default/dso_loader.cc:48] Successfully opened dynamic library libcudart.so.10.1
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

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

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

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

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

आइए एक tf.Module को बचाने और पुनर्स्थापित करने का एक उदाहरण 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 -decorated विधियाँ और tf.Module s को पुनरावर्ती ट्रैवर्सल के माध्यम से पाया जाता है। (इस पुनरावर्ती ट्रैवर्सल के बारे में अधिक जानकारी के लिए चेकपॉइंट ट्यूटोरियल देखें।) हालांकि, कोई भी पायथन विशेषताएँ, फ़ंक्शन और डेटा खो गए हैं। इसका मतलब यह है कि जब एक tf.function सहेजा जाता है, तो कोई पायथन कोड सहेजा नहीं जाता है।

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

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

tf.function और tf.function के बीच संबंध के बारे में अधिक जानने के लिए, 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/tmpqrbxtm18/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'),), {})].

बुनियादी ठीक ट्यूनिंग

परिवर्तनीय वस्तुएँ उपलब्ध हैं, और आप आयातित कार्यों के माध्यम से बैकप्रॉप कर सकते हैं। यह साधारण मामलों में ठीक-ठीक ट्यून (यानी मुकरना) करने के लिए पर्याप्त है।

Caf8172127
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__ तुलना में अधिक विवरण प्रदान करता है __call__ फाइन-ट्यूनिंग के अधिक उन्नत मामलों को संबोधित किया जा सके। TensorFlow Hub ने फाइन-ट्यूनिंग के उद्देश्य के लिए साझा किए गए SavedModels में, यदि लागू हो, तो उन्हें निम्नलिखित प्रदान करने की सिफारिश की है:

  • यदि मॉडल ड्रॉपआउट या किसी अन्य तकनीक का उपयोग करता है जिसमें फारवर्ड पास प्रशिक्षण और अनुमान (बैच सामान्यीकरण) के बीच भिन्न होता है, तो __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 सर्विंग और saved_model_cli जैसे टूल, SavedModels के साथ बातचीत कर सकते हैं। इन उपकरणों को यह निर्धारित करने में मदद करने के लिए कि कौन से कंक्रीटफंक्शन का उपयोग करना है, आपको सेवा हस्ताक्षर निर्दिष्ट करने की आवश्यकता है। tf.keras.Model स्वचालित रूप से सेवा हस्ताक्षर निर्दिष्ट करता है, लेकिन आपको स्पष्ट रूप से हमारे कस्टम मॉड्यूल के लिए एक सेवा हस्ताक्षर की घोषणा करनी होगी।

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

assert len(imported.signatures) == 0

सेवारत हस्ताक्षर की घोषणा करने के लिए, signatures kwarg का उपयोग करके एक कांक्रीट निर्दिष्ट करें। एकल हस्ताक्षर निर्दिष्ट करते समय, इसकी हस्ताक्षर कुंजी '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/tmpqrbxtm18/module_with_signature/assets

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

['serving_default']

एकाधिक हस्ताक्षरों को निर्यात करने के लिए, कंक्रीटफंक्शन के लिए हस्ताक्षर कुंजियों का एक शब्दकोश पारित करें। प्रत्येक सिग्नेचर की कुंजी एक कंक्रीटफंक्शन से संबंधित है।

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/tmpqrbxtm18/module_with_multiple_signatures/assets

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

डिफ़ॉल्ट रूप से, आउटपुट टेंसर नाम काफी सामान्य हैं, जैसे output_0 । आउटपुट के नामों को नियंत्रित करने के लिए, अपने tf.function को एक ऐसे शब्दकोश में 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/tmpqrbxtm18/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')}

C ++ में SavedModel लोड करें

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

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

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

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

SavedModel CLI स्थापित करें

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

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

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

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

$ bazel build tensorflow/python/tools:saved_model_cli

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

SavedModel CLI, SavedModel पर निम्नलिखित दो आदेशों का समर्थन करता है:

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

show कमांड

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

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

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

$ 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

सभी आदानों दिखाने के लिए और एक विशिष्ट के लिए TensorInfo आउटपुट से SignatureDef , में पारित 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

SavedModel में सभी उपलब्ध जानकारी दिखाने के लिए, --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 विकल्प आपको फाइलों में सुन्न ndarray पास करने में सक्षम बनाता है।
  • --input_exprs विकल्प आपको पायथन एक्सप्रेशन पास करने में सक्षम बनाता है।
  • --input_examples विकल्प आपको tf.train.Example पास करने में सक्षम बनाता है।

--inputs

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

--inputs <INPUTS>

जहाँ INPUTS या तो निम्न प्रारूप हैं:

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

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

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

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

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

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

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

--input_exprs

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

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

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

`<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 विकल्प में पारित किया --outdir है, तो आउटपुट को दी गई निर्देशिका के तहत आउटपुट टेंसर कुंजियों के नाम वाली .npy फ़ाइलों के रूप में सहेजा जाएगा।

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