לשמור את התאריך! קלט / פלט של Google חוזר 18-20 במאי הירשם עכשיו
דף זה תורגם על ידי Cloud Translation API.
Switch to English

שימוש בפורמט 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 Serving.

עיין במדריך הגשת 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 ), אבל זה נדיר. ממשקי 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 , לא נשמר קוד פייתון.

אם לא נשמר קוד פייתון, איך 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

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

התקן את ה- 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

כדי להעביר קלטים דרך ביטויי Python, ציין את האפשרות --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 להחליף כדי להחליף קבצי פלט קיימים.