Vue d'ensemble du contenu 
 
 
 
 
 
 
 
 
 
 établissement Enregistrer avec les API de formation tf.keras Écrire des points de contrôle Manuel de vérification Mécanique de chargement Restauration reportée Inspection manuelle des points de contrôle Objet de suivi Résumé L’expression « Enregistrer un modèle TensorFlow » signifie généralement l’une des deux choses : 
 
 
 points de contrôle, ou modèle de sauvetage. Les points de contrôle captent la valeur exacte de tous les paramètres ( Les points de contrôle ne contiennent aucune description du calcul défini par le modèle et ne sont donc généralement utiles que lorsque le code source qui utilisera les valeurs de paramètre enregistrées est disponible. tf.Variable Le format SavedModel, en revanche, comprend une description sérialisée du calcul défini par le modèle en plus des valeurs de paramètre (checkpoint). Les modèles dans ce format sont indépendants du code source qui a créé le modèle. Ils conviennent donc pour le déploiement via TensorFlow Serving, TensorFlow Lite, TensorFlow.js, ou des programmes dans d'autres langages de programmation (les C, C++, Java, Go, Rust, C# etc. API TensorFlow). Ce guide couvre les API pour l'écriture et la lecture des points de contrôle. établissement import tensorflow as tf
 class Net(tf.keras.Model):
  """A simple linear model."""

  def __init__(self):
    super(Net, self).__init__()
    self.l1 = tf.keras.layers.Dense(5)

  def call(self, x):
    return self.l1(x)
 net = Net()
 Épargner de Formation aux APIs tf. chercheurs tf. chercheurs Voir le Guide sur le sauvetage et la restauration. tf.keras enregistre un point de contrôle TensorFlow. tf.keras.Model.save_weights net.save_weights('easy_checkpoint')
 Écrire des points de contrôle L'état persistant d'un modèle TensorFlow est stocké dans Ceux-ci peuvent être construits directement, mais sont souvent créés à travers des API de haut niveau tels que ou . tf.Variable tf.keras.layers tf.keras.Model La façon la plus simple de gérer les variables est de les attacher aux objets Python, puis de les référencer. Les sous-classes de , à et suit automatiquement les variables attribuées à leurs attributs.L'exemple suivant construit un modèle linéaire simple, puis écrit des points de contrôle qui contiennent des valeurs pour toutes les variables du modèle. tf.train.Checkpoint tf.keras.layers.Layer tf.keras.Model Vous pouvez facilement enregistrer un modèle-point de contrôle avec . Model.save_weights Manuel de vérification établissement Aider à démontrer toutes les caractéristiques de , définir un ensemble de données de jouets et une étape d'optimisation : tf.train.Checkpoint def toy_dataset():
  inputs = tf.range(10.)[:, None]
  labels = inputs * 5. + tf.range(5.)[None, :]
  return tf.data.Dataset.from_tensor_slices(
    dict(x=inputs, y=labels)).repeat().batch(2)
 def train_step(net, example, optimizer):
  """Trains `net` on `example` using `optimizer`."""
  with tf.GradientTape() as tape:
    output = net(example['x'])
    loss = tf.reduce_mean(tf.abs(output - example['y']))
  variables = net.trainable_variables
  gradients = tape.gradient(loss, variables)
  optimizer.apply_gradients(zip(gradients, variables))
  return loss
 Créer des objets de checkpoint Utilisez A Objet pour créer manuellement un point de contrôle, où les objets que vous voulez contrôler sont définis comme des attributs sur l'objet. tf.train.Checkpoint à Il peut également être utile pour gérer plusieurs points de contrôle. tf.train.CheckpointManager opt = tf.keras.optimizers.Adam(0.1)
dataset = toy_dataset()
iterator = iter(dataset)
ckpt = tf.train.Checkpoint(step=tf.Variable(1), optimizer=opt, net=net, iterator=iterator)
manager = tf.train.CheckpointManager(ckpt, './tf_ckpts', max_to_keep=3)
 Train et point de contrôle le modèle La boucle de formation suivante crée une instance du modèle et d'un optimiseur, puis les rassemble dans une Il appelle l'étape de formation dans une boucle sur chaque lot de données et écrit périodiquement des points de contrôle sur le disque. tf.train.Checkpoint def train_and_checkpoint(net, manager):
  ckpt.restore(manager.latest_checkpoint)
  if manager.latest_checkpoint:
    print("Restored from {}".format(manager.latest_checkpoint))
  else:
    print("Initializing from scratch.")

  for _ in range(50):
    example = next(iterator)
    loss = train_step(net, example, opt)
    ckpt.step.assign_add(1)
    if int(ckpt.step) % 10 == 0:
      save_path = manager.save()
      print("Saved checkpoint for step {}: {}".format(int(ckpt.step), save_path))
      print("loss {:1.2f}".format(loss.numpy()))
 train_and_checkpoint(net, manager)
 Rétablir et poursuivre la formation Après le premier cycle de formation, vous pouvez passer un nouveau modèle et manager, mais prendre la formation exactement là où vous avez arrêté: opt = tf.keras.optimizers.Adam(0.1)
net = Net()
dataset = toy_dataset()
iterator = iter(dataset)
ckpt = tf.train.Checkpoint(step=tf.Variable(1), optimizer=opt, net=net, iterator=iterator)
manager = tf.train.CheckpointManager(ckpt, './tf_ckpts', max_to_keep=3)

train_and_checkpoint(net, manager)
 Le Objet supprime les anciens points de contrôle. Au-dessus, il est configuré pour ne conserver que les trois derniers points de contrôle. tf.train.CheckpointManager print(manager.checkpoints)  # List the three remaining checkpoints
 Ces chemins, par exemple , ne sont pas des fichiers sur le disque. Au lieu de cela, ils sont des préfixes pour un fichier et un ou plusieurs fichiers de données qui contiennent les valeurs variables. Ces préfixes sont regroupés dans un Le fichier ( ) où le sauver son pays. './tf_ckpts/ckpt-10' index checkpoint './tf_ckpts/checkpoint' CheckpointManager ls ./tf_ckpts
 Mécanique de chargement TensorFlow correspond aux variables aux valeurs marquées en traversant un graphique dirigé avec des bords nommés, à partir de l'objet chargé. dans Le . utilisent leurs noms de mots clés, comme dans le cas de dans . "l1" self.l1 = tf.keras.layers.Dense(5) tf.train.Checkpoint "step" tf.train.Checkpoint(step=...) Le graphique de dépendance de l'exemple ci-dessus ressemble à ceci: L'optimisateur est en rouge, les variables régulières sont en bleu, et les variables de fente de l'optimisateur sont en orange. Il est en noir. tf.train.Checkpoint Les variables de fente font partie de l'état de l'optimisateur, mais sont créées pour une variable spécifique. Les bords ci-dessus correspondent à l'élan, que l'optimisateur Adam suit pour chaque variable. Les variables de slot ne sont enregistrées dans un point de contrôle que si la variable et l'optimisateur seraient tous les deux enregistrés, donc les bords découpés. 'm' appeler est a l'objet fait la queue des restaurations demandées, restaurant les valeurs variables dès qu'il y a un chemin de correspondance à partir du Par exemple, vous pouvez charger uniquement le biais du modèle que vous avez défini ci-dessus en reconstruisant un chemin vers lui à travers le réseau et la couche. restore tf.train.Checkpoint Checkpoint to_restore = tf.Variable(tf.zeros([5]))
print(to_restore.numpy())  # All zeros
fake_layer = tf.train.Checkpoint(bias=to_restore)
fake_net = tf.train.Checkpoint(l1=fake_layer)
new_root = tf.train.Checkpoint(net=fake_net)
status = new_root.restore(tf.train.latest_checkpoint('./tf_ckpts/'))
print(to_restore.numpy())  # This gets the restored value.
 Le graphique de dépendance pour ces nouveaux objets est un sous-graphique beaucoup plus petit du plus grand point de contrôle que vous avez écrit ci-dessus. Utilisez le nombre de points de contrôle. tf.train.Checkpoint renvoie un objet d'état, qui a des affirmations facultatives. Tous les objets créés dans le nouveau Elle a été restaurée, donc Les passes. restore Checkpoint status.assert_existing_objects_matched status.assert_existing_objects_matched()
 Il y a beaucoup d'objets dans le point de contrôle qui ne correspondent pas, y compris le noyau de la couche et les variables de l'optimiseur. ne passe que si le point de contrôle et le programme correspondent exactement, et jetterait une exception ici. status.assert_consumed Restauration reportée Les objets de TensorFlow peuvent reporter la création de variables à leur première appel, lorsque des formes d'entrée sont disponibles. Le noyau de la couche dépend des formes d'entrée et de sortie de la couche, de sorte que la forme de sortie requise en tant qu'argument constructeur n'est pas suffisante pour créer la variable elle-même. La valeur de la variable est également lue, une restauration doit se produire entre la création de la variable et sa première utilisation. Layer Dense Layer Pour soutenir cette langue, Rétablissement des défenses qui n'ont pas encore de variable correspondante. tf.train.Checkpoint deferred_restore = tf.Variable(tf.zeros([1, 5]))
print(deferred_restore.numpy())  # Not restored; still zeros
fake_layer.kernel = deferred_restore
print(deferred_restore.numpy())  # Restored
 Inspection manuelle des points de contrôle Retour à qui donne un accès de niveau inférieur au contenu du point de contrôle. Il contient des cartographies de la clé de chaque variable, de la forme et du type d de chaque variable dans le point de contrôle. La clé d'une variable est son chemin d'objet, comme dans les graphiques affichés ci-dessus. tf.train.load_checkpoint CheckpointReader 
 
 Remarque : Il n'y a pas de structure de niveau supérieur au point de contrôle. Il ne connaît que les chemins et les valeurs des variables, et n'a pas de concept de modèles, de couches ou de la façon dont ils sont connectés. Il n'y a pas de structure de niveau supérieur au point de contrôle. Il ne connaît que les chemins et les valeurs des variables, et n'a pas de concept de , à Ou comment ils sont liés. Note: models layers reader = tf.train.load_checkpoint('./tf_ckpts/')
shape_from_key = reader.get_variable_to_shape_map()
dtype_from_key = reader.get_variable_to_dtype_map()

sorted(shape_from_key.keys())
 Si vous êtes intéressé par la valeur de Vous pouvez obtenir la valeur avec le code suivant : net.l1.kernel key = 'net/l1/kernel/.ATTRIBUTES/VARIABLE_VALUE'

print("Shape:", shape_from_key[key])
print("Dtype:", dtype_from_key[key].name)
 Il prévoit également une méthode vous permettant d'inspecter la valeur d'une variable: get_tensor reader.get_tensor(key)
 Objet de suivi Les points de contrôle enregistrent et restaurent les valeurs de Objets par "tracking" tout objet variable ou traçable mis en place dans l'un de ses attributs. Lors de l'exécution d'un sauvegarde, les variables sont recueillies récurremment de tous les objets traçables atteignables. tf.Variable Comme avec les attributions directes comme , attribuer des listes et des dictionnaires à des attributs permettra de suivre leur contenu. self.l1 = tf.keras.layers.Dense(5) save = tf.train.Checkpoint()
save.listed = [tf.Variable(1.)]
save.listed.append(tf.Variable(2.))
save.mapped = {'one': save.listed[0]}
save.mapped['two'] = save.listed[1]
save_path = save.save('./tf_list_example')

restore = tf.train.Checkpoint()
v2 = tf.Variable(0.)
assert 0. == v2.numpy()  # Not restored yet
restore.mapped = {'two': v2}
restore.restore(save_path)
assert 2. == v2.numpy()
 Vous remarquerez peut-être des objets d'enveloppe pour les listes et les dictionnaires. Ces enveloppeurs sont des versions ponctuables des structures de données sous-jacentes. Tout comme le chargement basé sur les attributs, ces enveloppeurs restaurent la valeur d'une variable dès qu'elle est ajoutée au conteneur. restore.listed = []
print(restore.listed)  # ListWrapper([])
v1 = tf.Variable(0.)
restore.listed.append(v1)  # Restores v1, from restore() in the previous cell
assert 1. == v1.numpy()
 Les objets traçables comprennent , à et ses sous-classes (par ex. et Les conteneurs Python : tf.train.Checkpoint tf.Module keras.layers.Layer keras.Model 
 
 
 
 dict (et collections.OrderedDict) Liste Tuple (et collections.namedtuple, typing.NamedTuple) Les autres types de conteneurs sont , y compris : not supported 
 
 
 collections.defaultdict Séance Tous les autres objets Python sont , y compris : ignored 
 
 
 
 int String à flottant Résumé Les objets TensorFlow fournissent un mécanisme automatique facile pour enregistrer et restaurer les valeurs des variables qu’ils utilisent. 
 
 Publié à l'origine sur le site Web de TensorFlow, cet article apparaît ici sous un nouveau titre et est sous licence CC BY 4.0. Publié à l'origine sur le site Web de TensorFlow, cet article apparaît ici sous un nouveau titre et est sous licence CC BY 4.0. TensorFlow TensorFlow

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Cet audio est produit dans la langue originale de l'histoire !

Comment enregistrer et charger des modèles TensorFlow

About Author

COMMENTAIRES

ÉTIQUETTES

CET ARTICLE A ÉTÉ PARU DANS

Related Stories

Les couches invisibles : pourquoi les entretiens avec les utilisateurs sont un atout irremplaçable

Des forums aux flux : comment les algorithmes des réseaux sociaux façonnent l'interaction numérique

Appuyez pour gagner : Telegram pourrait intégrer les 10 prochains milliards d'utilisateurs de crypto avant Solana

Naviguer sur les eaux : développer des applications RAG de qualité production avec des lacs de données

Les couches invisibles : pourquoi les entretiens avec les utilisateurs sont un atout irremplaçable

Des forums aux flux : comment les algorithmes des réseaux sociaux façonnent l'interaction numérique

Appuyez pour gagner : Telegram pourrait intégrer les 10 prochains milliards d'utilisateurs de crypto avant Solana

Naviguer sur les eaux : développer des applications RAG de qualité production avec des lacs de données

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps