יום הקהילה ML הוא 9 בנובמבר! הצטרפו אלינו עדכונים מ- TensorFlow, JAX, ועוד למידע נוסף

שימוש בפורמט SavedModel

צפה ב- TensorFlow.org הפעל ב- Google Colab צפה במקור ב- GitHub הורד מחברת

SavedModel מכיל תוכנית TensorFlow שלמה, כולל פרמטרים מאומנים (כלומר, tf.Variable ים) ו חישוב. היא אינה דורשת את קוד בניין מודל המקורי כדי ריצה, מה שהופך אותו לשימושי עבור שיתוף או פריסה עם TFLite , TensorFlow.js , TensorFlow הגשה , או TensorFlow Hub .

ניתן לשמור ולטעון דגם בפורמט SavedModel באמצעות ממשקי ה- API הבאים:

יצירת SavedModel מקרס

להקדמה מהירה, חלק זה מייצא דגם Keras שהוכשר מראש ומגיש איתו בקשות לסיווג תמונות. שאר המדריך ימלא פרטים וידון בדרכים אחרות ליצירת SavedModels.

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

png

אתה תשתמש בתמונה של גרייס הופר כדוגמה פועלת, ובמודל סיווג תמונות של Keras שהוכשר מראש מכיוון שהוא קל לשימוש. דגמים מותאמים אישית עובדים גם הם ומפורטים בפירוט מאוחר יותר.

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 לתוך Python עם 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')}

מסקנות ריצה מה- SavedModel נותנות תוצאה זהה לדגם המקורי.

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']

הפעלת SavedModel ב- TensorFlow הגשה

SavedModels ניתנים לשימוש מ- Python (עוד על כך בהמשך), אך סביבות ייצור בדרך כלל משתמשות בשירות ייעודי להסקת מסקנות ללא הפעלת קוד Python. קל להגדיר זאת מתוך SavedModel באמצעות הגשה של TensorFlow.

עיין TensorFlow הגשת הדרכת REST עבור דוגמא מקצה לקצה tensorflow-המשרתים.

פורמט SavedModel בדיסק

SavedModel היא ספרייה המכילה חתימות מסודרות והמצב הדרוש להפעלתן, כולל ערכים ואוצר מילים משתנים.

ls {mobilenet_save_path}
assets  saved_model.pb  variables

saved_model.pb חנויות קובץ תוכנית TensorFlow בפועל, או מודל, ומערכת של חתימות בשם, כול המזהה פונקציה שמקבלת תשומות מותחות מייצרות מותח פלטים.

SavedModels עשוי להכיל גרסאות מרובות של המודל (מספר v1.MetaGraphDefs , המזוהה עם --tag_set הדגל כדי saved_model_cli ), אבל זה נדיר. APIs היוצרות גרסאות מרובות של מודל כוללים 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 ספריה עבור כל הקבצים שאינם בשימוש גרף TensorFlow, לקבלת מידע לדוגמה עבור הצרכנים לגבי מה לעשות עם SavedModel. TensorFlow עצמה אינה משתמשת בספרייה זו.

שמירת דגם מותאם אישית

tf.saved_model.save תומך חיסכון tf.Module חפצים subclasses שלה, כמו 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 ים מצאו דרך חציית רקורסיבית נשמרים. (עיין הדרכה Checkpoint יותר על חציית רקורסיבית זו.) עם זאת, כל Python מייחס, פונקציות, ונתונים הולכים לאיבוד. אמצעי זה שכאשר tf.function נשמר, שאף קוד פיתון נשמר.

אם לא נשמר קוד Python, כיצד SavedModel יודע כיצד לשחזר את הפונקציה?

בקצרה, tf.function עובד על ידי התחקות קוד פיתון ליצור ConcreteFunction (עטיפה callable סביב 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'),), {})].

כוונון בסיסי

קיימים אובייקטים משתנים, ותוכל לבצע גיבוי באמצעות פונקציות מיובאות. זה מספיק כדי לכוונן (כלומר להכשיר מחדש) SavedModel במקרים פשוטים.

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

כוונון כללי עדין

SavedModel מן Keras מספק פרטים נוספים מ מישור __call__ כדי לטפל במקרים מתקדמים יותר של כוונון עדין. TensorFlow Hub ממליץ לספק את הדברים הבאים, במידת הצורך, ב- SavedModels המשותפים לצורך כוונון עדין:

  • אם שימושי המודל נשירים או טכניקה אחרת שבה שונה לעבור קדימה בין אימון היקש (כמו נורמליזציה תצווה), את __call__ שיטת לוקח אופציונלי, Python-מוערך training= טענה כי ברירת מחדל הוא False אבל יכול להיות מוגדרת True .
  • ליד __call__ התכונה, יש .variable ו .trainable_variable מאפיין עם הרשימות המקבילות של משתנים. משתנה זה היה שאפשר לאלף במקור אבל אמור להיות קפוא במהלך הכוונון העדין מושמט מן .trainable_variables .
  • למען מסגרות כמו Keras המייצגים regularizers משקל כמו תכונות של שכבות או תת-דגמים, ייתכנו גם .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. כדי לעזור לכלים אלה לקבוע באילו 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 לחזור מילון ממפה שמות פלט יציאות. שמות התשומות נגזרים משמות ארג הפונקציה של פייתון.

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 ב- C ++

++ C בגרסה של SavedModel מטעין מספקת API לטעון SavedModel מנתיב, תוך מתן אפשרות SessionOptions ו RunOptions. עליך לציין את התגים המשויכים לגרף שיש לטעון. הגרסה הטעונה של SavedModel מכונה SavedModelBundle ומכילה את MetaGraphDef ואת ההפעלה שבתוכה היא נטענת.

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

פרטים על ממשק שורת הפקודה SavedModel

אתה יכול להשתמש בממשק שורת הפקודה SavedModel (CLI) כדי לבדוק ולבצע SavedModel. לדוגמה, אתה יכול להשתמש CLI לבדוק את הדגם של SignatureDef ים. CLI מאפשר לך לאשר במהירות שהקובץ מסוג Tensor והצורה תואמים את הדגם. יתר על כן, אם ברצונך לבדוק את המודל שלך, תוכל להשתמש ב- CLI כדי לבצע בדיקת שפיות על ידי העברת קלטי מדגם בפורמטים שונים (למשל ביטויי פייתון) ולאחר מכן הבאת הפלט.

התקן את CLI SavedModel

בגדול, אתה יכול להתקין את TensorFlow באחת משתי הדרכים הבאות:

  • על ידי התקנת בינארי TensorFlow שנבנה מראש.
  • על ידי בניית TensorFlow מקוד המקור.

אם התקנת TensorFlow באמצעות בינארי TensorFlow שנבנו מראש, אז CLI SavedModel כבר מותקן על המערכת שלך על הנתיב bin/saved_model_cli .

אם אתה בנוי TensorFlow מקוד המקור, עליך להפעיל את פקוד נוספת הבאה כדי לבנות saved_model_cli :

$ bazel build tensorflow/python/tools:saved_model_cli

סקירה כללית של הפקודות

SavedModel CLI תומך בשתי הפקודות הבאות ב- SavedModel:

  • 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]

לדוגמה, הפקודה הבאה מציגה את כל ערכי התגים הזמינים ב- 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 האופציה. זה שימושי מאוד כאשר אתה רוצה לדעת את ערך מפתח הטנסור, סוג dt וצורת טנסורי הקלט לביצוע גרף החישוב מאוחר יותר. לדוגמה:

$ 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 numpy קבצים.
  • --input_exprs האופציה מאפשרת לכם להעביר ביטויי Python.
  • --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 הקובץ תמיד מכיל ndarray numpy. לכן, כאשר הטעינה של .npy קובץ, תוכן יוקצה ישירות מותח קלט שצוין. אם תציין VARIABLE_NAME עם זה .npy קובץ, VARIABLE_NAME יתעלם ואזהרה תונפק.

כאשר הטעינה של .npz הקובץ (zip), יש לך אפשרות לציין VARIABLE_NAME לזהות את המשתנה בתוך קובץ zip לטעון את המפתח מותח קלט. אם לא תציין VARIABLE_NAME, את SavedModel CLI יבדוק שרק אחד בקובץ נכלל בקובץ zip לטעון אותו עבור המפתח מותח קלט שצוין.

כאשר טעינת מקובץ חמוץ, אם לא variable_name צוין בסוגריים המרובעים, מה שזה לא יהיה בתוך הקובץ החמוץ תועבר המפתח המותח קלט שצוין. אחרת, SavedModel CLI תיטול מילון מאוחסן בקובץ החמוץ ואת הערך המתאים VARIABLE_NAME ישמש.

--input_exprs

כדי לעבור תשומות באמצעות ביטויים Python, לציין את --input_exprs האופציה. זה יכול להיות שימושי כאשר אין לך קבצי נתונים זרוק, אבל עדיין רוצה שפיות לבדוק את הדגם עם כמה כניסות פשוט שמתאימות dtype וצורה של המודל של SignatureDef ים. לדוגמה:

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

בנוסף לביטויי Python, תוכל גם לעבור פונקציות חסרות תחושה. לדוגמה:

`<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 לדרוס קבצי תפוקה קיימות.