דף זה תורגם על ידי Cloud Translation API.

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

הצג באתר TensorFlow.org

הפעל בגוגל קולאב

צפה במקור ב-GitHub

הורד מחברת

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

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

ממשק API של tf.saved_model ברמה נמוכה. מסמך זה מתאר כיצד להשתמש ב-API זה בפירוט.
- שמור: tf.saved_model.save(model, path_to_dir)
- טען: model = tf.saved_model.load(path_to_dir)
ממשק API של tf.keras.Model ברמה גבוהה. עיין במדריך השמירה והסדרה של keras .
אם אתה רק רוצה לחסוך/להעמיס משקלים במהלך האימון, עיין במדריך המחסומים .

יצירת SavedModel מ-Keras

להקדמה מהירה, חלק זה מייצא דגם 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.utils.load_img(file, target_size=[224, 224])
plt.imshow(img)
plt.axis('off')
x = tf.keras.utils.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-10-27 01:24:27.831628: 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/tmpbf9fpzwt/mobilenet/1/assets

ה-save-path עוקב אחר מוסכמה המשמשת את 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.

ראה את המדריך של TensorFlow Serving REST לקבלת דוגמה להגשת tensorflow מקצה לקצה.

פורמט SavedModel בדיסק

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

ls {mobilenet_save_path}

assets  saved_model.pb  variables

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

SavedModels עשויים להכיל גרסאות מרובות של המודל (מספר v1.MetaGraphDefs , המזוהה עם הדגל --tag_set to 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-00001  variables.index

ספריית assets מכילה קבצים המשמשים את גרף TensorFlow, למשל קבצי טקסט המשמשים לאתחול טבלאות אוצר מילים. הוא אינו בשימוש בדוגמה זו.

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

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

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

למידע נוסף על הקשר בין 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/tmpbf9fpzwt/module_no_signatures/assets

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

כאשר אתה טוען SavedModel ב-Python, כל תכונות tf.Variable , השיטות tf.function ב-tf.function ו- 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__ לוקחת ארגומנט אופציונלי, בעל ערך 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/tmpbf9fpzwt/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/tmpbf9fpzwt/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 כדי להחזיר מילון שממפה את שמות הפלטים לפלטים. שמות הקלט נגזרים מהפונקציה Python arg names.

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/tmpbf9fpzwt/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 כדי לבדוק את s SignatureDef של המודל. ה-CLI מאפשר לך לאשר במהירות שהקלט Tensor dtype והצורה תואמים לדגם. יתרה מכך, אם אתה רוצה לבדוק את המודל שלך, אתה יכול להשתמש ב-CLI כדי לבצע בדיקת שפיות על ידי העברת כניסות לדוגמה בפורמטים שונים (לדוגמה, ביטויי Python) ואז שליפת הפלט.

התקן את SavedModel CLI

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

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

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

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

$ bazel build tensorflow/python/tools:saved_model_cli

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

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

show , המציג את החישובים הזמינים מ-SaveModel.
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 . זה מאוד שימושי כאשר אתה רוצה לדעת את ערך מפתח הטנסור, ה-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 מאפשרת לך להעביר ביטויי Python.
אפשרות --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 numpy. לכן, בעת טעינה מקובץ .npy , התוכן יוקצה ישירות לטנסור הקלט שצוין. אם תציין משתנה_שם עם קובץ .npy זה, תתעלם מ- variable_name ותונפק אזהרה.

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

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

`--input_exprs`

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

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

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