Verwenden des SavedModel-Formats

Auf TensorFlow.org ansehen In Google Colab ausführen Quelle auf GitHub anzeigen Notizbuch herunterladen

Ein SavedModel enthält ein vollständiges TensorFlow-Programm, einschließlich trainierter Parameter (dh tf.Variable s) und Berechnung. Es erfordert nicht, dass der ursprüngliche Modellerstellungscode ausgeführt wird, was es für die gemeinsame Nutzung oder Bereitstellung mit TFLite , TensorFlow.js , TensorFlow Serving oder TensorFlow Hub nützlich macht.

Sie können ein Modell im SavedModel-Format mit den folgenden APIs speichern und laden:

Erstellen eines gespeicherten Modells aus Keras

Für eine schnelle Einführung exportiert dieser Abschnitt ein vortrainiertes Keras-Modell und bedient damit Bildklassifizierungsanfragen. Der Rest des Handbuchs wird Details ausfüllen und andere Möglichkeiten zum Erstellen von SavedModels besprechen.

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

Als laufendes Beispiel verwenden Sie ein Bild von Grace Hopper und ein vortrainiertes Bildklassifizierungsmodell von Keras, da es einfach zu verwenden ist. Benutzerdefinierte Modelle funktionieren auch und werden später ausführlich behandelt.

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

Die Top-Vorhersage für dieses Bild ist "Militäruniform".

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

Der Speicherpfad folgt einer von TensorFlow Serving verwendeten Konvention, bei der die letzte Pfadkomponente ( 1/ hier) eine Versionsnummer für Ihr Modell ist - es ermöglicht Tools wie Tensorflow Serving, über die relative Aktualität nachzudenken.

Sie können das SavedModel mit tf.saved_model.load wieder in Python tf.saved_model.load und sehen, wie das Bild von Admiral Hopper klassifiziert wird.

loaded = tf.saved_model.load(mobilenet_save_path)
print(list(loaded.signatures.keys()))  # ["serving_default"]
['serving_default']

Importierte Signaturen geben immer Wörterbücher zurück. Informationen zum Anpassen von Signaturnamen und Ausgabewörterbuchschlüsseln finden Sie unter Angeben von Signaturen während des Exports .

infer = loaded.signatures["serving_default"]
print(infer.structured_outputs)
{'predictions': TensorSpec(shape=(None, 1000), dtype=tf.float32, name='predictions')}

Das Ausführen der Inferenz aus dem SavedModel liefert das gleiche Ergebnis wie das Originalmodell.

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

Ausführen eines SavedModel in TensorFlow Serving

SavedModels können von Python aus verwendet werden (mehr dazu weiter unten), aber Produktionsumgebungen verwenden normalerweise einen dedizierten Dienst für die Inferenz, ohne Python-Code auszuführen. Dies ist mithilfe von TensorFlow Serving einfach von einem SavedModel aus einzurichten.

Im TensorFlow Serving REST-Tutorial finden Sie ein End-to-End-Tensorflow-Serving-Beispiel.

Das SavedModel-Format auf der Festplatte

Ein SavedModel ist ein Verzeichnis, das serialisierte Signaturen und den für deren Ausführung erforderlichen Status enthält, einschließlich Variablenwerten und Vokabularen.

ls {mobilenet_save_path}
assets  saved_model.pb  variables

Die Datei saved_model.pb speichert das eigentliche TensorFlow-Programm oder -Modell und einen Satz benannter Signaturen, die jeweils eine Funktion identifizieren, die Tensoreingaben akzeptiert und Tensorausgaben erzeugt.

SavedModels können mehrere Varianten des Modells enthalten (mehrere v1.MetaGraphDefs , identifiziert mit dem --tag_set Flag für saved_model_cli ), aber dies ist selten. APIs, die mehrere Varianten eines Modells erstellen, umfassen tf.Estimator.experimental_export_all_saved_models und in 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"

Das variables enthält einen Standard-Trainings-Checkpoint (siehe Anleitung zu Trainings-Checkpoints ).

ls {mobilenet_save_path}/variables
variables.data-00000-of-00001  variables.index

Das assets Verzeichnis enthält Dateien, die vom TensorFlow-Graphen verwendet werden, beispielsweise Textdateien, die zum Initialisieren von Vokabulartabellen verwendet werden. Es wird in diesem Beispiel nicht verwendet.

SavedModels kann ein assets.extra Verzeichnis für alle Dateien haben, die nicht vom TensorFlow-Diagramm verwendet werden, zum Beispiel Informationen für Verbraucher darüber, was mit dem SavedModel zu tun ist. TensorFlow selbst verwendet dieses Verzeichnis nicht.

Speichern eines benutzerdefinierten Modells

tf.saved_model.save unterstützt das Speichern von tf.Module Objekten und deren Unterklassen, wie tf.keras.Layer und tf.keras.Model .

Sehen wir uns ein Beispiel für das Speichern und Wiederherstellen eines 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()

Wenn Sie ein tf.Module , werden alle tf.Variable Attribute, tf.function -decorated-Methoden und tf.Module s tf.Module die durch rekursives Durchlaufen gefunden wurden. (Weitere Informationen zu diesem rekursiven Durchlauf finden Sie im Checkpoint-Lernprogramm .) Alle Python-Attribute, -Funktionen und -Daten gehen jedoch verloren. Das bedeutet, dass beim tf.function einer tf.function kein Python-Code gespeichert wird.

Wenn kein Python-Code gespeichert wird, woher weiß SavedModel dann, wie die Funktion wiederhergestellt wird?

Kurz tf.function funktioniert tf.function indem es den Python-Code verfolgt, um eine ConcreteFunction (einen aufrufbaren Wrapper um tf.Graph ) zu generieren. Wenn Sie eine tf.function speichern, tf.function Sie wirklich den Cache der tf.function von ConcreteFunctions.

Weitere tf.function zur Beziehung zwischen tf.function und ConcreteFunctions finden Sie im tf.function-Leitfaden .

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

Laden und Verwenden eines benutzerdefinierten Modells

Wenn Sie ein SavedModel in Python laden, werden alle tf.Variable Attribute, tf.function -decorated-Methoden und tf.Module s in derselben Objektstruktur wie das ursprünglich gespeicherte 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

Da kein Python-Code gespeichert wird, tf.function das Aufrufen einer tf.function mit einer neuen Eingabesignatur fehl:

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'),), {})].

Grundlegende Feinabstimmung

Variable Objekte sind verfügbar, und Sie können durch importierte Funktionen Backproping durchführen. Das reicht in einfachen Fällen aus, um ein SavedModel zu verfeinern (dh umzutrainieren).

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

Allgemeine Feinabstimmung

Ein SavedModel von Keras bietet mehr Details als ein einfacher __call__ , um fortgeschrittenere Fälle der Feinabstimmung zu behandeln. TensorFlow Hub empfiehlt, gegebenenfalls die folgenden in SavedModels bereitzustellen, die zum Zwecke der Feinabstimmung freigegeben sind:

  • Wenn die Modell Verwendungen Ausfall oder eine andere Technik , bei der die Vorwärtsdurchlauf unterscheidet sich zwischen Ausbildung und Inferenz (wie Batch - Normalisierung), die __call__ nimmt Methode eine optionale, Python-wertige training= Argument , dass standardmäßig auf False aber kann eingestellt werden auf True .
  • Neben dem Attribut __call__ gibt es die Attribute .variable und .trainable_variable mit den entsprechenden Variablenlisten. Eine Variable, die ursprünglich trainierbar war, aber während der Feinabstimmung eingefroren werden soll, wird in .trainable_variables weggelassen.
  • Für Frameworks wie Keras, die Gewichtungsregularisierer als Attribute von Ebenen oder Untermodellen darstellen, kann es auch ein Attribut .regularization_losses . Es enthält eine Liste von Null-Argument-Funktionen, deren Werte zum Totalverlust addiert werden sollen.

Wenn Sie zum ersten MobileNet-Beispiel zurückkehren, können Sie einige davon in Aktion sehen:

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, ...

Signaturen beim Export angeben during

Tools wie TensorFlow Serving und saved_model_cli können mit SavedModels interagieren. Damit diese Tools bestimmen können, welche ConcreteFunctions verwendet werden sollen, müssen Sie Serving-Signaturen angeben. tf.keras.Model automatisch Serving-Signaturen an, aber Sie müssen eine Serving-Signatur für unsere benutzerdefinierten Module explizit deklarieren.

Standardmäßig werden in einem benutzerdefinierten tf.Module keine Signaturen deklariert.

assert len(imported.signatures) == 0

Um eine Serving-Signatur zu deklarieren, geben Sie eine ConcreteFunction mit den signatures kwarg an. Wenn eine einzelne Signatur angegeben wird 'serving_default' ihr Signaturschlüssel 'serving_default' , der als Konstante 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']

Um mehrere Signaturen zu exportieren, übergeben Sie ein Wörterbuch mit Signaturschlüsseln an ConcreteFunctions. Jeder Signaturschlüssel entspricht einer 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']

Standardmäßig sind die Namen der Ausgabetensoren ziemlich allgemein gehalten, wie zum Beispiel output_0 . Um die Namen von Ausgaben zu steuern, ändern Sie Ihre tf.function , um ein Wörterbuch zurückzugeben, das Ausgabenamen Ausgaben tf.function . Die Namen der Eingaben werden von den Argumentnamen der Python-Funktion abgeleitet.

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')}

Laden Sie ein SavedModel in C++

Die C ++ Version des SavedModel Loader bietet eine API einen SavedModel von einem Pfad zu laden, während SessionOptions und RunOptions ermöglicht. Sie müssen die Tags angeben, die dem zu ladenden Graphen zugeordnet sind. Die geladene Version von SavedModel wird als SavedModelBundle bezeichnet und enthält die MetaGraphDef und die Sitzung, in der sie geladen wird.

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

Details der SavedModel-Befehlszeilenschnittstelle

Sie können das SavedModel Command Line Interface (CLI) verwenden, um ein SavedModel zu überprüfen und auszuführen. Sie können beispielsweise die CLI verwenden, um die SignatureDef s des Modells zu überprüfen. Mit der CLI können Sie schnell bestätigen, dass der eingegebene Tensor dtype und die Form mit dem Modell übereinstimmen. Wenn Sie Ihr Modell testen möchten, können Sie außerdem die CLI verwenden, um eine Plausibilitätsprüfung durchzuführen, indem Sie Beispieleingaben in verschiedenen Formaten (z. B. Python-Ausdrücke) übergeben und dann die Ausgabe abrufen.

Installieren Sie die SavedModel-CLI

Im Großen und Ganzen können Sie TensorFlow auf eine der folgenden zwei Arten installieren:

  • Durch die Installation einer vorgefertigten TensorFlow-Binärdatei.
  • Durch Erstellen von TensorFlow aus dem Quellcode.

Wenn Sie TensorFlow über eine vorgefertigte TensorFlow-Binärdatei installiert haben, ist die SavedModel-CLI bereits auf Ihrem System unter Pfadname bin/saved_model_cli .

Wenn Sie TensorFlow aus dem Quellcode erstellt haben, müssen Sie den folgenden zusätzlichen Befehl saved_model_cli , um saved_model_cli zu saved_model_cli :

$ bazel build tensorflow/python/tools:saved_model_cli

Übersicht der Befehle

Die SavedModel-CLI unterstützt die folgenden zwei Befehle für ein SavedModel:

  • show , die die von einem SavedModel verfügbaren Berechnungen anzeigt.
  • run , das eine Berechnung von einem SavedModel ausführt.

show - Befehl

Ein SavedModel enthält eine oder mehrere Modellvarianten (technisch v1.MetaGraphDef s), identifiziert durch ihre Tag-Sets. Um ein Modell zu bedienen, fragen Sie sich vielleicht, welche Art von SignatureDef s in jeder Modellvariante enthalten sind und was ihre Eingaben und Ausgaben sind. Mit dem Befehl show Sie den Inhalt des SavedModel in hierarchischer Reihenfolge untersuchen. Hier ist die Syntax:

usage: saved_model_cli show [-h] --dir DIR [--all]
[--tag_set TAG_SET] [--signature_def SIGNATURE_DEF_KEY]

Der folgende Befehl zeigt beispielsweise alle verfügbaren Tag-Sets im SavedModel:

$ saved_model_cli show --dir /tmp/saved_model_dir
The given SavedModel contains the following tag-sets:
serve
serve, gpu

Der folgende Befehl zeigt alle verfügbaren SignatureDef Schlüssel für einen Tag-Satz:

$ 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"

Wenn das Tag-Set mehrere Tags enthält, müssen Sie alle Tags angeben, wobei jedes Tag durch ein Komma getrennt ist. Beispielsweise:

$ saved_model_cli show --dir /tmp/saved_model_dir --tag_set serve,gpu

Um alle Eingaben und Ausgaben von TensorInfo für eine bestimmte SignatureDef anzuzeigen, übergeben Sie den SignatureDef Schlüssel an die Option signature_def . Dies ist sehr nützlich, wenn Sie den Tensorschlüsselwert, dtype und die Form der Eingabetensoren kennen möchten, um den Berechnungsgraphen später auszuführen. Beispielsweise:

$ 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

Um alle verfügbaren Informationen im SavedModel anzuzeigen, verwenden Sie die Option --all . Beispielsweise:

$ 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

Befehl run

Rufen Sie den Befehl run auf, um eine Graphberechnung run , Eingaben zu übergeben und dann die Ausgaben anzuzeigen (und optional zu speichern). Hier ist die Syntax:

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]

Der Befehl run bietet die folgenden drei Möglichkeiten, um Eingaben an das Modell zu übergeben:

  • --inputs Option --inputs ermöglicht es Ihnen, numpy ndarray in Dateien zu übergeben.
  • --input_exprs Option --input_exprs können Sie Python-Ausdrücke übergeben.
  • --input_examples Option --input_examples können Sie tf.train.Example .

--inputs

Um Eingabedaten in Dateien zu übergeben, geben Sie die Option --inputs , die das folgende allgemeine Format annimmt:

--inputs <INPUTS>

wobei INPUTS eines der folgenden Formate hat:

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

Sie können mehrere INPUTS übergeben . Wenn Sie mehrere Eingaben übergeben, verwenden Sie ein Semikolon, um die einzelnen INPUTS zu trennen.

saved_model_cli verwendet numpy.load , um den Dateinamen zu laden. Der Dateiname kann eines der folgenden Formate haben:

  • .npy
  • .npz
  • Gurkenformat

Eine .npy Datei enthält immer ein numpy-ndarray. Daher wird der Inhalt beim Laden aus einer .npy Datei direkt dem angegebenen Eingabetensor zugewiesen. Wenn Sie in dieser .npy Datei einen Variablennamen .npy , wird der Variablenname ignoriert und eine Warnung ausgegeben.

Beim Laden aus einer .npz Datei (zip) können Sie optional einen Variablennamen angeben, um die Variable in der Zip-Datei zu identifizieren, die für den Eingabetensorschlüssel geladen werden soll. Wenn Sie keinen Variablennamen angeben, überprüft die SavedModel-CLI, ob nur eine Datei in der ZIP-Datei enthalten ist, und lädt sie für den angegebenen Eingabetensorschlüssel.

Wenn beim Laden aus einer Pickle-Datei kein variable_name in den eckigen Klammern angegeben ist, wird alles, was sich in der Pickle-Datei befindet, an den angegebenen Eingabetensorschlüssel übergeben. Andernfalls geht die SavedModel-CLI davon aus, dass ein Wörterbuch in der Pickle-Datei gespeichert ist, und der dem Variablenname entsprechende Wert wird verwendet.

--input_exprs

Um Eingaben über Python-Ausdrücke zu übergeben, geben Sie die Option --input_exprs . Dies kann nützlich sein, wenn Sie keine Datendateien herumliegen haben, aber dennoch das Modell mit einigen einfachen Eingaben überprüfen möchten, die dem dtype und der Form der SignatureDef s des Modells entsprechen. Beispielsweise:

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

Zusätzlich zu Python-Ausdrücken können Sie auch numpy-Funktionen übergeben. Beispielsweise:

`<input_key>=np.ones((32,32,3))`

(Beachten Sie, dass numpy das numpy Modul bereits als np .)

--input_examples

Um tf.train.Example als Eingaben zu übergeben, geben Sie die Option --input_examples . Für jeden Eingabeschlüssel wird eine Wörterbuchliste benötigt, wobei jedes Wörterbuch eine Instanz von tf.train.Example . Die Wörterbuchschlüssel sind die Funktionen und die Werte sind die Wertelisten für jede Funktion. Beispielsweise:

`<input_key>=[{"age":[22,24],"education":["BS","MS"]}]`

Ausgabe speichern

Standardmäßig schreibt die SavedModel-CLI die Ausgabe in stdout. Wenn ein Verzeichnis an die Option --outdir , werden die Ausgaben als .npy Dateien gespeichert, die nach den Ausgabetensorschlüsseln im angegebenen Verzeichnis benannt sind.

Verwenden Sie --overwrite , um vorhandene Ausgabedateien zu überschreiben.