יש שאלה? התחבר לקהילה בפורום הביקור של TensorFlow

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

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

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

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

יצירת מודל שמור מ 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

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
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
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)
INFO:tensorflow:Assets written to: /tmp/tmpfcgkddlh/mobilenet/1/assets

נתיב השמירה עוקב אחר מוסכמה בה משתמשים TensorFlow Serving כאשר רכיב הנתיב האחרון ( 1/ כאן) הוא מספר גרסה עבור המודל שלך - הוא מאפשר לכלים כמו Tensorflow Serving לחשוב על הרעננות היחסית.

באפשרותך לטעון את ה- 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')}

הסקת ריצה מה- 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.

עיין במדריך הגשת REST של TensorFlow לקבלת דוגמה להגשת זרימת tensor מקצה לקצה.

הפורמט SavedModel בדיסק

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

ls {mobilenet_save_path}
assets  saved_model.pb  variables

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

SavedModels עשוי להכיל גרסאות מרובות של המודל (מספר v1.MetaGraphDefs , המזוהה עם --tag_set הדגל כדי 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
2021-02-11 02:25:22.757135: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.11.0
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 שלה, כמו tf.keras.Layer ו- tf.keras.Model .

בואו נסתכל על דוגמה לשמירה ושחזור של tf.Module .

class CustomModule(tf.Module):

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

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

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

module = CustomModule()

כאשר אתה שומר tf.Module , כל המאפיינים tf.Variable , tf.function שיטות tf.Module ו- tf.Module s שנמצאים באמצעות מעבר רקורסיבי נשמרים. (עיין במדריך Checkpoint לקבלת מידע נוסף על מעבר רקורסיבי זה.) עם זאת, כל תכונות, פונקציות ונתונים של Python אבדו. המשמעות היא שכאשר tf.function , לא נשמר קוד פייתון.

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

בקצרה, tf.function עובד על ידי מעקב אחר קוד הפייתון כדי ליצור ConcreteFunction (עטיפה tf.Graph סביב tf.Graph ). כשאתה שומר tf.function אתה באמת שומר את המטמון של tf.function של ConcreteFunctions.

למידע נוסף על הקשר בין tf.function ו- ConcreteFuntions, עיין במדריך 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/tmpfcgkddlh/module_no_signatures/assets

טוען ומשתמש בדגם מותאם אישית

כאשר אתה טוען SavedModel ב- Python, כל התכונות tf.Variable , tf.function שיטות tf.Module ו- 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

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

אם נחזור לדוגמא MobileNet הראשונית, תוכל לראות כמה מאלה שפועלים:

loaded = tf.saved_model.load(mobilenet_save_path)
print("MobileNet has {} trainable variables: {}, ...".format(
          len(loaded.trainable_variables),
          ", ".join([v.name for v in loaded.trainable_variables[:5]])))
MobileNet has 83 trainable variables: conv1/kernel:0, conv1_bn/gamma:0, conv1_bn/beta:0, conv_dw_1/depthwise_kernel:0, conv_dw_1_bn/gamma:0, ...
trainable_variable_ids = {id(v) for v in loaded.trainable_variables}
non_trainable_variables = [v for v in loaded.variables
                           if id(v) not in trainable_variable_ids]
print("MobileNet also has {} non-trainable variables: {}, ...".format(
          len(non_trainable_variables),
          ", ".join([v.name for v in non_trainable_variables[:3]])))
MobileNet also has 54 non-trainable variables: conv1_bn/moving_mean:0, conv1_bn/moving_variance:0, conv_dw_1_bn/moving_mean:0, ...

ציון חתימות במהלך הייצוא

כלים כמו TensorFlow Serving ו- saved_model_cli יכולים לתקשר עם SavedModels. כדי לעזור לכלים אלה לקבוע באילו ConcreteFunctions להשתמש, עליך לציין חתימות הגשה. tf.keras.Model 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/tmpfcgkddlh/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/tmpfcgkddlh/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 הפונקציה Python.

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/tmpfcgkddlh/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 לביצוע בדיקת שפיות על ידי העברת תשומות לדוגמא בפורמטים שונים (למשל, ביטויים של Python) ואז אחזור הפלט.

התקן את ה- SavedModel CLI

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

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

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

074020 דאה 0

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 מאפשרת לך להעביר מערך נדוש בקבצים.
  • האפשרות --input_exprs מאפשרת לך להעביר ביטויי פייתון.
  • אפשרות - --input_examples מאפשרת לך להעביר את tf.train.Example .

--inputs

כדי להעביר נתוני קלט לקבצים, ציין את האפשרות - --inputs , שלוקחת את הפורמט הכללי הבא:

--inputs <INPUTS>

כאשר INPUTS הוא מהפורמטים הבאים:

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

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

saved_model_cli משתמש ב- numpy.load לטעינת שם הקובץ . שם הקובץ יכול להיות בכל אחד מהפורמטים הבאים:

  • .npy
  • .npz
  • פורמט מלפפון חמוץ

קובץ .npy מכיל תמיד מערך נדוש. לכן, בעת טעינה מקובץ .npy , התוכן יוקצה ישירות .npy הקלט שצוין. אם תציין VARIABLE_NAME עם זה .npy קובץ, VARIABLE_NAME יתעלם ואזהרה תונפק.

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

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

--input_exprs

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

`<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"]}]`

שמור פלט

כברירת מחדל, ה- CLI של SavedModel כותב פלט ל- stdout. אם ספריה מועברת לאפשרות --outdir , הפלטים יישמרו .npy שם מקשי טנסור הפלט תחת הספריה הנתונה.

השתמש --overwrite להחליף כדי להחליף קבצי פלט קיימים.