Aide à protéger la Grande barrière de corail avec tensorflow sur Kaggle Rejoignez Défi

Utilisation du format SavedModel

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

Un SavedModel contient un programme de tensorflow complet, y compris les paramètres formés (c. -à- tf.Variable s) et le calcul. Il ne nécessite pas le code de la construction du modèle d' origine à terme, ce qui le rend utile pour le partage ou le déploiement avec TFLite , TensorFlow.js , tensorflow service ou tensorflow Hub .

Vous pouvez enregistrer et charger un modèle au format SavedModel à l'aide des API suivantes :

Création d'un modèle enregistré à partir de Keras

Pour une introduction rapide, cette section exporte un modèle Keras pré-entraîné et sert des requêtes de classification d'images avec lui. 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.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

Vous utiliserez une image de Grace Hopper comme exemple d'exécution et un modèle de classification d'images 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
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']

La prédiction la plus élevée pour cette image est "uniforme militaire".

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

La sauvegarde suit-chemin d' une convention utilisée par tensorflow service où le dernier composant ( 1/ ici) est un numéro de version pour votre modèle - il permet des outils tels que tensorflow service à la raison de la fraîcheur relative.

Vous pouvez charger le dos SavedModel en Python avec tf.saved_model.load et voir comment l'image de l' amiral Hopper est classé.

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 de l'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 modèle enregistré dans TensorFlow Serving

Les SavedModels sont utilisables à partir de Python (plus de détails 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 modèle enregistré à l'aide de TensorFlow Serving.

Voir le tensorflow service tutoriel REST pour un bout en bout exemple tensorflow-service.

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 des variables et les vocabulaires.

ls {mobilenet_save_path}
assets  saved_model.pb  variables

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

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. API qui créent de multiples variantes d'un modèle comprennent 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
The given SavedModel MetaGraphDef contains SignatureDefs with the following keys:
SignatureDef key: "__saved_model_init_op"
SignatureDef key: "serving_default"

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

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

L' assets répertoire contient des fichiers utilisés par le graphique de tensorflow, par exemple des fichiers texte utilisés pour initialiser des tableaux de vocabulaire. Il n'est pas utilisé dans cet exemple.

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

Enregistrer un modèle personnalisé

tf.saved_model.save soutient les économies tf.Module objets et ses sous - classes, comme tf.keras.Layer et tf.keras.Model .

Le regard Let un exemple de sauvegarde et la 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 tutoriel Checkpoint pour plus sur ce parcours récursif.) Cependant, tous les attributs Python, les fonctions et les données sont perdues. Cela signifie que lorsqu'un tf.function est enregistré, pas de code Python 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 un ConcreteFunction (un callable wrapper autour tf.Graph ). Lorsque vous enregistrez un tf.function , vous enregistrez vraiment le tf.function le cache de ConcreteFunctions de ».

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/tmpbf9fpzwt/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

Parce qu'aucun code Python est enregistré, appeler un 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 effectuer une backprop via des fonctions importées. C'est suffisant 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

Ajustement général

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

  • Si le modèle utilise le décrochage ou d'une autre technique dans laquelle les diffère passe en avant entre la formation et l' inférence (comme la normalisation des lots), la __call__ méthode prend une option, à valeurs Python training= argument par défaut False mais peut être réglé sur True .
  • A côté de l' __call__ attribut, il y a .variable et .trainable_variable attributs avec les listes correspondantes des variables. Une variable qui était à l' origine , mais trainable est destiné à être congelé pendant peaufinage est omis de .trainable_variables .
  • Par souci de cadres comme Keras qui représentent de poids comme régularisations de couches ou attributs des sous-modèles, il peut aussi être un .regularization_losses attribut. Il contient une liste de fonctions sans argument dont les valeurs sont destinées à être ajoutées à la perte totale.

Pour en revenir à l'exemple initial de MobileNet, vous pouvez en voir quelques-uns 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 service et saved_model_cli peuvent interagir avec SavedModels. Pour aider ces outils à déterminer quelles ConcreteFunctions utiliser, vous devez spécifier des signatures de service. tf.keras.Model s indiquer automatiquement au service des signatures, mais vous devrez déclarer explicitement une signature servant à nos modules personnalisés.

Par défaut, aucune signature sont déclarées dans une coutume tf.Module .

assert len(imported.signatures) == 0

Pour déclarer une signature au service, spécifiez un ConcreteFunction en utilisant les signatures kwarg. Lors de la spécification d' une seule signature, sa clé de signature sera 'serving_default' , qui est enregistré comme 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/tmpbf9fpzwt/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/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']

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

Charger un SavedModel en C++

La version C ++ de la SavedModel chargeur fournit une API pour charger un SavedModel à partir d' un chemin, tout en permettant sessionoptions et RunOptions. Vous devez spécifier les balises associées au graphe à 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 le modèle SignatureDef s. L'interface de ligne de commande vous permet de confirmer rapidement que le type et la forme du tenseur d'entrée correspondent au modèle. De plus, si vous souhaitez tester votre modèle, vous pouvez utiliser l'interface de ligne de commande pour effectuer un contrôle d'intégrité en transmettant des exemples d'entrées dans divers formats (par exemple, des expressions Python), puis en récupérant la sortie.

Installer 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 par un binaire tensorflow pré-construit, le CLI SavedModel est déjà installé sur votre système à chemin bin/saved_model_cli .

Si vous avez construit tensorflow à partir du code source, vous devez exécuter la commande supplémentaire suivante pour construire saved_model_cli :

$ bazel build tensorflow/python/tools:saved_model_cli

Présentation des commandes

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

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

show commande

Un SavedModel contient une ou plusieurs variantes de modèle (techniquement, v1.MetaGraphDef s), identifiés par leur étiquette ensembles. Pour servir un modèle, on peut se demander quel genre de SignatureDef s sont dans chaque variante de modèle, et quelles sont leurs entrées et sorties. Le show commande vous permettent 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 ensembles de balises disponibles dans le 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 tous disponibles SignatureDef clés pour un jeu de tag:

$ 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 la balise-set, vous devez spécifier toutes les balises, chaque balise 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 une spécifique SignatureDef , passer dans la SignatureDef clé de signature_def option. Ceci est très utile lorsque vous souhaitez connaître la valeur de la clé du tenseur, le type et la forme des tenseurs d'entrée pour exécuter le graphe de calcul plus tard. 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 le SavedModel, utilisez la --all option. 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

run commande

Appelez le run commande pour exécuter un calcul de graphique, les entrées passant, puis l' affichage (et éventuellement l' enregistrement) , 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 run commande fournit les trois méthodes suivantes pour passer entrées au modèle:

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

--inputs

Pour transmettre des données d' entrée dans les fichiers, spécifiez l' --inputs option, 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 ENTREES. Si vous faites passer plusieurs entrées, utilisez un point - virgule pour séparer chacun des ENTREES.

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

  • .npy
  • .npz
  • format de cornichon

Un .npy fichier contient toujours un ndarray numpy. Par conséquent, lors du chargement d'un .npy fichier, 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.

Une fois le chargement d'un .npz fichier (zip), vous pouvez éventuellement spécifier un variable_name pour identifier la variable dans le fichier zip pour charger la clé tenseur 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.

Une fois le chargement d'un fichier de conserves au vinaigre, si aucun variable_name est spécifié dans les crochets, quel qu'il soit à l' intérieur du fichier cornichon sera transmis à la clé de tenseur d'entrée spécifié. Dans le cas contraire, la CLI SavedModel prendra un dictionnaire est stocké dans le fichier cornichon et la valeur correspondant au variable_name sera utilisé.

--input_exprs

Pour passer les entrées à travers des expressions Python, spécifiez l' --input_exprs option. Cela peut être utile lorsque vous ne disposez pas de fichiers de données qui traînent, mais veulent toujours vérifier la santé mentale du modèle avec des entrées simples qui correspondent à la DTYPE et la forme du modèle SignatureDef s. Par exemple:

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

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

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

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

--input_examples

Pour passer tf.train.Example comme entrées, spécifiez l' --input_examples option. Pour chaque touche d'entrée, il faut 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é à --outdir option, les sorties seront enregistrés en tant que .npy fichiers nommés après les clés du tenseur de sortie dans le répertoire donné.

Utilisez --overwrite pour remplacer les fichiers de sortie existants.