Cette page a été traduite par l'API Cloud Translation.
Switch to English

Utilisation du format SavedModel

Voir sur TensorFlow.org Exécuter dans Google Colab Afficher la source sur GitHub Télécharger le carnet

Un SavedModel contient un programme TensorFlow complet, comprenant des poids et des calculs. Il ne nécessite pas le code de construction du modèle d'origine pour s'exécuter, ce qui le rend utile pour le partage ou le déploiement (avec TFLite , TensorFlow.js , TensorFlow Serving ou TensorFlow Hub ).

Ce document décrit certains des détails sur l'utilisation de l' tf.saved_model bas niveau tf.saved_model :

Création d'un SavedModel à partir de Keras

Pour une introduction rapide, cette section exporte un modèle Keras pré-entraîné et sert avec lui les demandes de classification d'image. Le reste du guide fournira des détails et discutera d'autres façons de créer des modèles enregistrés.

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

Vous utiliserez une image de Grace Hopper comme exemple en cours d'exécution et un modèle de classification d'image pré-entraîné Keras car il est facile à utiliser. Les modèles personnalisés fonctionnent également et sont traités en détail plus tard.

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 [==============================] - 1s 0us/step
Result before saving:
 ['military uniform' 'bow tie' 'suit' 'bearskin' 'pickelhaube']

La principale prédiction pour cette image est "uniforme militaire".

mobilenet_save_path = os.path.join(tmpdir, "mobilenet/1/")
tf.saved_model.save(pretrained_model, mobilenet_save_path)
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: /tmp/tmpqrbxtm18/mobilenet/1/assets

Le chemin de sauvegarde suit une convention utilisée par TensorFlow Serving où le dernier composant du chemin ( 1/ ici) est un numéro de version pour votre modèle - il permet à des outils comme Tensorflow Serving de raisonner sur la fraîcheur relative.

Vous pouvez charger à nouveau SavedModel dans Python avec tf.saved_model.load et voir comment l'image de Admiral Hopper est classée.

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

Les signatures importées renvoient toujours des dictionnaires. Pour personnaliser les noms de signature et les clés de dictionnaire de sortie, voir Spécification des signatures lors de l'exportation .

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

L'exécution d'une inférence à partir du SavedModel donne le même résultat que le modèle d'origine.

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

Exécution d'un SavedModel dans le traitement TensorFlow

Les SavedModels sont utilisables à partir de Python (plus d'informations ci-dessous), mais les environnements de production utilisent généralement un service dédié pour l'inférence sans exécuter de code Python. Ceci est facile à configurer à partir d'un SavedModel à l'aide de TensorFlow Serving.

Consultez le didacticiel TensorFlow Serving REST pour un exemple de service Tensorflow de bout en bout.

Le format SavedModel sur disque

Un SavedModel est un répertoire contenant des signatures sérialisées et l'état nécessaire pour les exécuter, y compris les valeurs de variables et les vocabulaires.

ls {mobilenet_save_path}
assets  saved_model.pb  variables

Le fichier saved_model.pb stocke le programme ou modèle TensorFlow réel et un ensemble de signatures nommées, chacune identifiant une fonction qui accepte les entrées de tenseur et produit des sorties de tenseur.

SavedModels peuvent contenir plusieurs variantes du modèle (plusieurs v1.MetaGraphDefs , identifiés avec le --tag_set drapeau saved_model_cli ), mais cela est rare. Les API qui créent plusieurs variantes d'un modèle incluent tf.Estimator.experimental_export_all_saved_models et dans TensorFlow 1.x tf.saved_model.Builder .

saved_model_cli show --dir {mobilenet_save_path} --tag_set serve
2020-10-13 01:23:41.728141: I tensorflow/stream_executor/platform/default/dso_loader.cc:48] Successfully opened dynamic library libcudart.so.10.1
The given SavedModel MetaGraphDef contains SignatureDefs with the following keys:
SignatureDef key: "__saved_model_init_op"
SignatureDef key: "serving_default"

Le répertoire des variables contient un point de contrôle de formation standard (voir le guide des points de contrôle de formation ).

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

Le répertoire assets contient les fichiers utilisés par le graphe TensorFlow, par exemple les fichiers texte utilisés pour initialiser les tables de vocabulaire. Il n'est pas utilisé dans cet exemple.

SavedModels peut avoir un répertoire assets.extra pour tous les fichiers non utilisés par le graphique TensorFlow, par exemple des informations destinées aux consommateurs sur ce qu'il faut faire avec SavedModel. TensorFlow lui-même n'utilise pas ce répertoire.

Enregistrer un modèle personnalisé

tf.saved_model.save prend en charge l'enregistrement des objets tf.Module et de ses sous-classes, comme tf.keras.Layer et tf.keras.Model .

Regardons un exemple de sauvegarde et de restauration d'un 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()

Lorsque vous enregistrez un tf.Module , les tf.Variable attributs, tf.function méthodes -decorated et tf.Module s trouvé via traversal récursive sont enregistrés. (Voir le didacticiel Checkpoint pour plus d'informations sur ce parcours récursif.) Cependant, tous les attributs, fonctions et données Python sont perdus. Cela signifie que lorsqu'une fonction tf.function est enregistrée, aucun code Python n'est enregistré.

Si aucun code Python n'est enregistré, comment SavedModel sait-il comment restaurer la fonction?

En bref, tf.function fonctionne en traçant le code Python pour générer une ConcreteFunction (un wrapper appelable autour de tf.Graph ). Lorsque vous enregistrez une tf.function , vous enregistrez vraiment le cache de ConcreteFunctions de la tf.function .

Pour en savoir plus sur la relation entre tf.function et ConcreteFunctions, consultez le guide 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/tmpqrbxtm18/module_no_signatures/assets

Chargement et utilisation d'un modèle personnalisé

Lorsque vous chargez un SavedModel en Python, tous tf.Variable attributs, tf.function méthodes -decorated et tf.Module s sont restaurés dans la même structure d'objet que l'original a sauvé 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

Comme aucun code Python n'est enregistré, l'appel d'une fonction tf.function avec une nouvelle signature d'entrée échouera:

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

Réglage fin de base

Des objets variables sont disponibles et vous pouvez revenir en arrière via les fonctions importées. Cela suffit pour affiner (c'est-à-dire recycler) un SavedModel dans des cas simples.

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

Réglage fin général

Un SavedModel de Keras fournit plus de détails qu'un simple __call__ pour traiter des cas plus avancés de réglage fin. TensorFlow Hub recommande de fournir les éléments suivants, le cas échéant, dans SavedModels partagés à des fins de réglage fin:

  • Si le modèle utilise l'abandon ou une autre technique dans laquelle la passe avant diffère entre l'entraînement et l'inférence (comme la normalisation par lots), la méthode __call__ prend un argument optionnel de training= valeur Python qui vaut par défaut False mais peut être défini sur True .
  • À côté de l'attribut __call__ , il y a les .variable et .trainable_variable avec les listes de variables correspondantes. Une variable qui était à l'origine entraînable mais qui est censée être gelée pendant le réglage fin est omise de .trainable_variables .
  • Dans l'intérêt des frameworks comme Keras qui représentent les régularisateurs de poids en tant qu'attributs de couches ou de sous-modèles, il peut également y avoir un attribut .regularization_losses . Il contient une liste de fonctions à argument nul dont les valeurs sont destinées à s'ajouter à la perte totale.

En revenant à l'exemple initial de MobileNet, vous pouvez voir certains d'entre eux en action:

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

Spécification des signatures lors de l'exportation

Des outils tels que TensorFlow Serving et saved_model_cli peuvent interagir avec SavedModels. Pour aider ces outils à déterminer les ConcreteFunctions à utiliser, vous devez spécifier des signatures de diffusion. tf.keras.Model s spécifie automatiquement les signatures de tf.keras.Model , mais vous devrez déclarer explicitement une signature de diffusion pour nos modules personnalisés.

Par défaut, aucune signature n'est déclarée dans un tf.Module personnalisé.

assert len(imported.signatures) == 0

Pour déclarer une signatures diffusion, spécifiez une ConcreteFunction à l'aide des signatures kwarg. Lors de la spécification d'une seule signature, sa clé de signature sera 'serving_default' , qui est enregistrée sous la constante 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/tmpqrbxtm18/module_with_signature/assets

imported_with_signatures = tf.saved_model.load(module_with_signature_path)
list(imported_with_signatures.signatures.keys())
['serving_default']

Pour exporter plusieurs signatures, transmettez un dictionnaire de clés de signature à ConcreteFunctions. Chaque clé de signature correspond à une 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/tmpqrbxtm18/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']

Par défaut, les noms des tenseurs de sortie sont assez génériques, comme output_0 . Pour contrôler les noms des sorties, modifiez votre tf.function pour renvoyer un dictionnaire qui mappe les noms de sortie aux sorties. Les noms des entrées sont dérivés des noms d'argument de la fonction 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/tmpqrbxtm18/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')}

Charger un SavedModel en C ++

La version C ++ du chargeur SavedModel fournit une API pour charger un SavedModel à partir d'un chemin, tout en autorisant SessionOptions et RunOptions. Vous devez spécifier les balises associées au graphique à charger. La version chargée de SavedModel est appelée SavedModelBundle et contient le MetaGraphDef et la session dans laquelle il est chargé.

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

Détails de l'interface de ligne de commande SavedModel

Vous pouvez utiliser l'interface de ligne de commande (CLI) SavedModel pour inspecter et exécuter un SavedModel. Par exemple, vous pouvez utiliser la CLI pour inspecter les SignatureDef du modèle. L'interface de ligne de commande vous permet de confirmer rapidement que le type et la forme du Tensor d'entrée correspondent au modèle. De plus, si vous souhaitez tester votre modèle, vous pouvez utiliser la CLI pour effectuer une vérification de cohérence en passant des exemples d'entrées dans différents formats (par exemple, des expressions Python), puis en récupérant la sortie.

Installez la CLI SavedModel

De manière générale, vous pouvez installer TensorFlow de l'une des deux manières suivantes:

  • En installant un binaire TensorFlow pré-construit.
  • En créant TensorFlow à partir du code source.

Si vous avez installé TensorFlow via un binaire TensorFlow pré-construit, alors la CLI SavedModel est déjà installée sur votre système à pathname bin/saved_model_cli .

Si vous avez créé TensorFlow à partir du code source, vous devez exécuter la commande supplémentaire suivante pour créer saved_model_cli :

$ bazel build tensorflow/python/tools:saved_model_cli

Vue d'ensemble des commandes

La CLI SavedModel prend en charge les deux commandes suivantes sur un SavedModel:

  • show , qui montre les calculs disponibles à partir d'un SavedModel.
  • run , qui exécute un calcul à partir d'un SavedModel.

commande show

Un SavedModel contient une ou plusieurs variantes de modèle (techniquement, v1.MetaGraphDef s), identifiées par leurs ensembles de balises. Pour servir un modèle, vous pourriez vous demander quel type de SignatureDef trouve dans chaque variante de modèle, et quelles sont leurs entrées et sorties. La commande show vous permet d'examiner le contenu du SavedModel dans l'ordre hiérarchique. Voici la syntaxe:

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

Par exemple, la commande suivante affiche tous les jeux de balises disponibles dans SavedModel:

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

La commande suivante affiche toutes les clés SignatureDef disponibles pour un jeu de balises:

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

S'il y a plusieurs balises dans le jeu de balises, vous devez spécifier toutes les balises, chaque balise étant séparée par une virgule. Par exemple:

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

Pour afficher toutes les entrées et sorties TensorInfo pour un SignatureDef spécifique, passez la clé SignatureDef à l'option signature_def . Ceci est très utile lorsque vous souhaitez connaître la valeur de la clé de tenseur, le type et la forme des tenseurs d'entrée pour exécuter le graphe de calcul ultérieurement. Par exemple:

$ 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

Pour afficher toutes les informations disponibles dans SavedModel, utilisez l'option --all . Par exemple:

$ 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

commande run

Appelez la commande run pour exécuter un calcul de graphe, en passant des entrées, puis en affichant (et éventuellement en enregistrant) les sorties. Voici la syntaxe:

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]

La commande run fournit les trois méthodes suivantes pour transmettre des entrées au modèle:

  • --inputs option --inputs vous permet de transmettre numpy ndarray dans les fichiers.
  • --input_exprs option --input_exprs vous permet de transmettre des expressions Python.
  • --input_examples option --input_examples vous permet de transmettre tf.train.Example .

--inputs

Pour transmettre les données d'entrée dans des fichiers, spécifiez l'option --inputs , qui prend le format général suivant:

--inputs <INPUTS>

INPUTS est l'un des formats suivants:

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

Vous pouvez passer plusieurs ENTRÉES . Si vous faites passer plusieurs entrées, utilisez un point - virgule pour séparer chacun des ENTREES.

saved_model_cli utilise numpy.load pour charger le nom de fichier . Le nom de fichier peut être dans l'un des formats suivants:

  • .npy
  • .npz
  • format de cornichon

Un fichier .npy contient toujours un ndarray numpy. Par conséquent, lors du chargement à partir d'un fichier .npy , le contenu sera directement affecté au tenseur d'entrée spécifié. Si vous spécifiez un variable_name avec ce .npy fichier, le variable_name sera ignorée et un avertissement sera émis.

Lors du chargement à partir d'un .npz (zip), vous pouvez éventuellement spécifier un nom_variable pour identifier la variable dans le fichier zip à charger pour la clé de tension d'entrée. Si vous ne spécifiez pas de variable_name, la CLI SavedModel vérifiera que un seul fichier est inclus dans le fichier zip et charger la clé tenseur d'entrée spécifiée.

Lors du chargement à partir d'un fichier pickle, si aucun variable_name n'est spécifié entre les crochets, tout ce qui se trouve à l'intérieur du fichier pickle sera passé à la clé de tension d'entrée spécifiée. Sinon, la CLI SavedModel supposera qu'un dictionnaire est stocké dans le fichier pickle et la valeur correspondant au nom_variable sera utilisée.

--input_exprs

Pour transmettre des entrées via des expressions Python, spécifiez l'option --input_exprs . Cela peut être utile lorsque vous ne disposez pas de fichiers de données, mais que vous souhaitez tout de même vérifier la cohérence du modèle avec des entrées simples qui correspondent au type et à la forme des SignatureDef du modèle. Par exemple:

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

En plus des expressions Python, vous pouvez également transmettre des fonctions numpy. Par exemple:

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

(Notez que le module numpy est déjà disponible pour vous en tant que np .)

--input_examples

Pour transmettre tf.train.Example comme entrées, spécifiez l'option --input_examples . Pour chaque clé d'entrée, il prend une liste de dictionnaire, où chaque dictionnaire est une instance de tf.train.Example . Les clés du dictionnaire sont les fonctionnalités et les valeurs sont les listes de valeurs pour chaque fonctionnalité. Par exemple:

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

Enregistrer la sortie

Par défaut, la CLI SavedModel écrit la sortie sur stdout. Si un répertoire est passé à l'option --outdir , les sorties seront enregistrées sous .npy fichiers .npy nommés d'après les clés de .npy de sortie dans le répertoire donné.

Utilisez --overwrite pour écraser les fichiers de sortie existants.