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

tf.saved_model.save

Tensorflow 1 Version Voir la source sur GitHub

Les exportations de l'objet trackable obj à le format SavedModel .

Utilisé dans les ordinateurs portables

Utilisé dans le guide Utilisé dans les tutoriels

Exemple d'utilisation:

 class Adder(tf.Module):

  @tf.function(input_signature=[tf.TensorSpec(shape=None, dtype=tf.float32)])
  def add(self, x):
    return x + x + 1.

to_export = Adder()
tf.saved_model.save(to_export, '/tmp/adder')
 

Le résultat est alors SavedModel pouvant être diffusés avec une entrée nommée « x », sa valeur ayant une forme quelconque et DTYPE float32.

Les options signatures contrôle des arguments les méthodes de obj seront disponibles pour les programmes qui consomment SavedModel s, par exemple, au service des API. Les fonctions Python peuvent être décorées avec @tf.function(input_signature=...) et transmis les signatures directement ou paresseusement avec un appel à get_concrete_function sur la méthode décorée avec @tf.function .

Si la signatures argument est omis, obj sera recherché pour @tf.function méthodes -decorated. Si un seul @tf.function se trouve, cette méthode sera utilisée comme la signature par défaut pour le SavedModel. Ce comportement devrait changer à l'avenir, lorsqu'un correspondant tf.saved_model.load symbole est ajouté. A ce point de signatures sera entièrement facultative et toute @tf.function attaché à obj ou ses dépendances seront exportées pour une utilisation avec la load .

Lors de l' appel d' une signature dans un SavedModel exporté, Tensor arguments sont identifiés par leur nom. Ces noms viendront les noms d'argument de fonction Python par défaut. Ils peuvent être remplacés en spécifiant un name=... argument correspondant tf.TensorSpec objet. Désignation explicite est nécessaire si plusieurs Tensor s sont passés à travers un seul argument de la fonction python.

Les sorties des fonctions utilisées comme signatures doivent être soit des listes plates, dans lequel les sorties de cas seront numérotées, ou les clés de chaîne de mappage dictionnaire à Tensor , auquel cas les clés seront utilisés pour nommer les sorties.

Les signatures sont disponibles dans les objets retournés par tf.saved_model.load comme .signatures attribut. Ceci est un attribut réservé: tf.saved_model.save sur un objet avec une coutume .signatures l'attribut déclenche une exception.

Étant donné que tf.keras.Model objets sont également trackable, cette fonction peut être utilisée pour exporter des modèles KERAS. Par exemple, l'exportation avec une signature spécifiée:

 class Model(tf.keras.Model):

  @tf.function(input_signature=[tf.TensorSpec(shape=[None], dtype=tf.string)])
  def serve(self, serialized):
    ...

m = Model()
tf.saved_model.save(m, '/tmp/saved_model/')
 

Exportation à partir d'une fonction sans signature fixe:

 class Model(tf.keras.Model):

  @tf.function
  def call(self, x):
    ...

m = Model()
tf.saved_model.save(
    m, '/tmp/saved_model/',
    signatures=m.call.get_concrete_function(
        tf.TensorSpec(shape=[None, 3], dtype=tf.float32, name="inp")))
 

tf.keras.Model instances construites à partir des entrées et sorties ont déjà une signature et ne nécessitent donc pas un @tf.function décorateur ou une signatures argument. Si sont spécifiés ni, est exporté passe en avant du modèle.

 x = input_layer.Input((4,), name="x")
y = core.Dense(5, name="out")(x)
model = training.Model(x, y)
tf.saved_model.save(model, '/tmp/saved_model/')
# The exported SavedModel takes "x" with shape [None, 4] and returns "out"
# with shape [None, 5]
 

Les variables doivent être suivis en les affectant à un attribut d'un objet suivi ou à un attribut de obj directement. Tensorflow objets (par exemple des couches de tf.keras.layers , optimiseurs de tf.train ) détecte automatiquement leurs variables. Ceci est le même schéma de suivi qui tf.train.Checkpoint utilisations, et un exporté Checkpoint objet peut être restauré en tant que point de contrôle de la formation en pointant tf.train.Checkpoint.restore à sous - répertoire « variables / » du SavedModel. À l' heure actuelle, les variables sont les objets que stateful pris en charge par tf.saved_model.save , mais d' autres (par exemple , tables) seront pris en charge à l'avenir.

tf.function ne annotations pas de périphérique dur code de l' extérieur du corps de la fonction, au lieu d'utiliser l'appareil du contexte d' appel. Cela signifie par exemple que l'exportation d'un modèle qui fonctionne sur un GPU et le servir sur une CPU fonctionnera généralement, à quelques exceptions près. tf.device annotations à l' intérieur du corps de la fonction sera codée en dur dans le modèle exporté; ce type d'annotation est déconseillée. opérations spécifiques de l'appareil, par exemple avec « cuDNN » au nom ou avec des mises en page spécifiques de l'appareil, peuvent causer des problèmes. À l' heure actuelle un DistributionStrategy est une autre exception: les stratégies de distribution actives entraînent des placements de l' appareil pour être codées en dur dans une fonction. Exportation d' un calcul unique dispositif et l' importation sous DistributionStrategy ne sont pas actuellement pris en charge, mais peut - être à l'avenir.

SavedModels exportés avec tf.saved_model.save attributs par défaut à valeurs bande automatiquement, qui supprime une source d'incompatibilités lorsque le consommateur d'un SavedModel exécute une version plus ancienne de tensorflow que le producteur. Il existe cependant d'autres sources d'incompatibilités qui ne sont pas traitées automatiquement, par exemple lorsque le modèle exporté contient les opérations que le consommateur n'ont pas de définition pour.

Un tf.function unique peut générer de nombreux ConcreteFunctions. Si un outil en aval veut se référer à toutes les fonctions de béton générées par un seul tf.function vous pouvez utiliser le function_aliases argument pour stocker une carte du nom d'alias à tous les noms de fonction de béton. Par exemple

 class MyModel:
@tf.function
def func():
  ...

@tf.function
def serve():
  ...
  func()

model = MyModel()
signatures = {
    'serving_default': model.serve.get_concrete_function(),
}
options = tf.saved_model.SaveOptions(function_aliases={
    'my_func': func,
})
tf.saved_model.save(model, export_dir, signatures, options)
 

obj Un objet traçable à exporter.
export_dir Un répertoire dans lequel pour écrire le SavedModel.
signatures En option, soit un tf.function avec une signature d'entrée spécifiée ou le résultat de f.get_concrete_function sur un @tf.function fonction -decorated f , auquel cas f sera utilisée pour générer une signature pour le SavedModel sous le défaut servant clé de signature . signatures peuvent aussi être un dictionnaire, auquel cas il mappe de clés de signature soit à tf.function cas avec des signatures d'entrée ou des fonctions concrètes. Les clés du dictionnaire une telle peuvent être des chaînes, mais seront généralement du tf.saved_model.signature_constants module.
options En option, tf.saved_model.SaveOptions objet qui spécifie les options d'enregistrement.

ValueError Si obj n'est pas traçable.

Compatibilité Désireuse

Pas bien pris en charge lorsque la construction graphique. De tensorflow 1.x, tf.compat.v1.enable_eager_execution() devrait fonctionner d' abord. Appel tf.saved_model.save dans une boucle lorsque la construction graphique de 1.x tensorflow ajoutera de nouvelles opérations de sauvegarde au graphique par défaut chaque itération.

Ne peut pas être appelé à partir d'un corps de la fonction.