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

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

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

आप निम्न 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.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
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-09-22 20:37:56.476712: 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/tmpiq7_1gwc/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 सर्विंग में एक सहेजा गया मॉडल चलाना

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

देखें TensorFlow बाकी ट्यूटोरियल सेवित एंड-टू-एंड tensorflow सेवारत उदाहरण के लिए।

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

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

ls {mobilenet_save_path}
assets  saved_model.pb  variables

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

SavedModels (कई मॉडल के कई वेरिएंट हो सकती है 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

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

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

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

संक्षेप में, 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/tmpiq7_1gwc/module_no_signatures/assets

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

जब आप अजगर में एक SavedModel, सभी लोड tf.Variable गुण, tf.function -decorated विधियों, और tf.Module रों एक ही वस्तु संरचना में बहाल कर रहे हैं के रूप में मूल बचाया 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

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

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

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

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

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

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

assert len(imported.signatures) == 0

एक सेवारत हस्ताक्षर की घोषणा करने के लिए, एक ConcreteFunction का उपयोग कर निर्दिष्ट 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/tmpiq7_1gwc/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/tmpiq7_1gwc/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/tmpiq7_1gwc/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 के संस्करण लोडर SessionOptions और RunOptions अनुमति, एक पथ से एक SavedModel लोड करने के लिए एपीआई प्रदान करता है। आपको ग्राफ़ से जुड़े टैग को लोड करने के लिए निर्दिष्ट करना होगा। SavedModel के लोड किए गए संस्करण को SavedModelBundle के रूप में संदर्भित किया जाता है और इसमें MetaGraphDef और वह सत्र होता है जिसके भीतर इसे लोड किया जाता है।

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

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

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

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

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

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

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

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

$ bazel build tensorflow/python/tools:saved_model_cli

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

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

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

show आदेश

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

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

सभी आदानों दिखाने के लिए और एक विशिष्ट के लिए 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 विकल्प फाइलों में 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 फ़ाइल, सामग्री सीधे निर्दिष्ट इनपुट टेन्सर को सौंपा जाएगा। आपको लगता है कि के साथ एक variable_name निर्दिष्ट करते हैं .npy फ़ाइल, variable_name नजरअंदाज कर दिया जाएगा और एक चेतावनी जारी किए जाएंगे।

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

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

--input_exprs

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

`<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 मौजूदा उत्पादन फ़ाइलें अधिलेखित करने के लिए।