इस पेज का अनुवाद 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')
if physical_devices:
  tf.config.experimental.set_memory_growth(physical_devices[0], 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/ops/resource_variable_ops.py:1817: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.
Instructions for updating:
If using Keras pass *_constraint arguments to layers.
INFO:tensorflow:Assets written to: /tmp/tmpmjpd1j0o/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 पायथन (उस से अधिक पर) से उपयोग करने योग्य हैं, लेकिन उत्पादन वातावरण आमतौर पर पायथन कोड को चलाने के बिना अनुमान के लिए एक समर्पित सेवा का उपयोग करते हैं। यह TensorFlow सर्विंग का उपयोग करके एक SavedModel से सेट करना आसान है।

सेवा के बारे में अधिक जानकारी के लिए TensorFlow सर्विसिंग REST ट्यूटोरियल देखें, जिसमें नोटबुक में या अपने स्थानीय मशीन पर tensorflow_model_server स्थापित करने के निर्देश शामिल हैं। एक त्वरित स्केच के रूप में, ऊपर दिए गए mobilenet मॉडल की सेवा करने के लिए, SavedModel निर्देशिका में मॉडल सर्वर को इंगित करें:

 nohup tensorflow_model_server \
  --rest_api_port=8501 \
  --model_name=mobilenet \
  --model_base_path="/tmp/mobilenet" >server.log 2>&1
 

फिर एक अनुरोध भेजें।

 !pip install -q requests
import json
import numpy
import requests
data = json.dumps({"signature_name": "serving_default",
                   "instances": x.tolist()})
headers = {"content-type": "application/json"}
json_response = requests.post('http://localhost:8501/v1/models/mobilenet:predict',
                              data=data, headers=headers)
predictions = numpy.array(json.loads(json_response.text)["predictions"])
 

परिणामी predictions पायथन के परिणामों के समान हैं।

डिस्क पर 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
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-00002  variables.data-00001-of-00002  variables.index

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

SavedModels में ऐसी कोई भी संपत्ति हो सकती है जो assets.extra ग्राफ द्वारा उपयोग की गई किसी भी फाइल के लिए न हो, उदाहरण के लिए उपभोक्ताओं के लिए जानकारी कि SavedModel के साथ क्या करना है। 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.Variable 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/tmpmjpd1j0o/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 Hub ने फाइन-ट्यूनिंग के उद्देश्य के लिए साझा किए गए SavedModels में, यदि लागू हो, तो निम्नलिखित में से कुछ प्रदान करने की सिफारिश की है:

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

अनुमानकर्ताओं से SavedModels

अनुमानक tf.Estimator.export_saved_model के माध्यम से tf.Estimator.export_saved_model निर्यात tf.Estimator.export_saved_model । विवरण के लिए अनुमानक के लिए गाइड देखें।

 input_column = tf.feature_column.numeric_column("x")
estimator = tf.estimator.LinearClassifier(feature_columns=[input_column])

def input_fn():
  return tf.data.Dataset.from_tensor_slices(
    ({"x": [1., 2., 3., 4.]}, [1, 1, 0, 0])).repeat(200).shuffle(64).batch(16)
estimator.train(input_fn)

serving_input_fn = tf.estimator.export.build_parsing_serving_input_receiver_fn(
  tf.feature_column.make_parse_example_spec([input_column]))
estimator_base_path = os.path.join(tmpdir, 'from_estimator')
estimator_path = estimator.export_saved_model(estimator_base_path, serving_input_fn)
 
INFO:tensorflow:Using default config.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmp65c02lsq
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp65c02lsq', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/feature_column/feature_column_v2.py:540: Layer.add_variable (from tensorflow.python.keras.engine.base_layer_v1) is deprecated and will be removed in a future version.
Instructions for updating:
Please use `layer.add_weight` method instead.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/optimizer_v2/ftrl.py:144: calling Constant.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.
Instructions for updating:
Call initializer instance with the dtype argument instead of passing it to the constructor
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp65c02lsq/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 0.6931472, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 50...
INFO:tensorflow:Saving checkpoints for 50 into /tmp/tmp65c02lsq/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 50...
INFO:tensorflow:Loss for final step: 0.4131384.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/saved_model/signature_def_utils_impl.py:145: build_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version.
Instructions for updating:
This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.build_tensor_info or tf.compat.v1.saved_model.build_tensor_info.
INFO:tensorflow:Signatures INCLUDED in export for Classify: ['serving_default', 'classification']
INFO:tensorflow:Signatures INCLUDED in export for Regress: ['regression']
INFO:tensorflow:Signatures INCLUDED in export for Predict: ['predict']
INFO:tensorflow:Signatures INCLUDED in export for Train: None
INFO:tensorflow:Signatures INCLUDED in export for Eval: None
INFO:tensorflow:Restoring parameters from /tmp/tmp65c02lsq/model.ckpt-50
INFO:tensorflow:Assets added to graph.
INFO:tensorflow:No assets to write.
INFO:tensorflow:SavedModel written to: /tmp/tmpmjpd1j0o/from_estimator/temp-1594862628/saved_model.pb

यह SavedModel क्रमबद्ध tf.Example प्रोटोकॉल बफ़र्स स्वीकार करता है, जो सेवा के लिए उपयोगी होते हैं। लेकिन हम इसे tf.saved_model.load साथ भी लोड कर सकते हैं और इसे पायथन से चला सकते हैं।

 imported = tf.saved_model.load(estimator_path)

def predict(x):
  example = tf.train.Example()
  example.features.feature["x"].float_list.value.extend([x])
  return imported.signatures["predict"](
    examples=tf.constant([example.SerializeToString()]))
 
 print(predict(1.5))
print(predict(3.5))
 
{'all_classes': <tf.Tensor: shape=(1, 2), dtype=string, numpy=array([[b'0', b'1']], dtype=object)>, 'logistic': <tf.Tensor: shape=(1, 1), dtype=float32, numpy=array([[0.5451435]], dtype=float32)>, 'probabilities': <tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[0.45485654, 0.5451435 ]], dtype=float32)>, 'logits': <tf.Tensor: shape=(1, 1), dtype=float32, numpy=array([[0.18106687]], dtype=float32)>, 'class_ids': <tf.Tensor: shape=(1, 1), dtype=int64, numpy=array([[1]])>, 'classes': <tf.Tensor: shape=(1, 1), dtype=string, numpy=array([[b'1']], dtype=object)>, 'all_class_ids': <tf.Tensor: shape=(1, 2), dtype=int32, numpy=array([[0, 1]], dtype=int32)>}
{'all_classes': <tf.Tensor: shape=(1, 2), dtype=string, numpy=array([[b'0', b'1']], dtype=object)>, 'logistic': <tf.Tensor: shape=(1, 1), dtype=float32, numpy=array([[0.21604054]], dtype=float32)>, 'probabilities': <tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[0.7839595 , 0.21604055]], dtype=float32)>, 'logits': <tf.Tensor: shape=(1, 1), dtype=float32, numpy=array([[-1.2888912]], dtype=float32)>, 'class_ids': <tf.Tensor: shape=(1, 1), dtype=int64, numpy=array([[0]])>, 'classes': <tf.Tensor: shape=(1, 1), dtype=string, numpy=array([[b'0']], dtype=object)>, 'all_class_ids': <tf.Tensor: shape=(1, 2), dtype=int32, numpy=array([[0, 1]], dtype=int32)>}

tf.estimator.export.build_raw_serving_input_receiver_fn आपको इनपुट फ़ंक्शंस बनाने की अनुमति देता है जो tf.train.Example s के बजाय कच्चे tf.train.Example

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

SavedModel लोडर का C ++ संस्करण एक सत्र प्रदान करता है जो एक सत्रामोडेल को एक पथ से लोड करने के लिए प्रदान करता है, जबकि SessionOptions और RunOptions को अनुमति देता है। आपको लोड किए जाने वाले ग्राफ़ से जुड़े टैग निर्दिष्ट करने होंगे। 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 कमांड आपको सेवियरोडेल की सामग्री को पदानुक्रमित क्रम में जांचने देता है। यहाँ वाक्यविन्यास है:

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

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