Content Overzicht 
 
 
 
 
 
 
 
 
 
 instellen Besparen van tf.keras training API's Schrijven van checkpoints Handmatige checkpointing Laden Mechanica Uitgestelde restauraties Handmatig inspecteren van checkpoints Object volgen Samenvatting De uitdrukking "een TensorFlow-model opslaan" betekent meestal een van twee dingen: 
 
 
 Checkpoints of Het reddingsmodel. Checkpoints registreren de exacte waarde van alle parameters ( Checkpoints bevatten geen beschrijving van de berekening gedefinieerd door het model en zijn dus meestal alleen nuttig wanneer broncode die de opgeslagen parameterwaarden zal gebruiken beschikbaar is. tf.Variable Het SavedModel-formaat daarentegen bevat een seriale beschrijving van de berekening die door het model wordt gedefinieerd naast de parameterwaarden (checkpoint). Modellen in dit formaat zijn onafhankelijk van de broncode die het model heeft gecreëerd. ze zijn dus geschikt voor implementatie via TensorFlow Serving, TensorFlow Lite, TensorFlow.js, of programma's in andere programmeertaal (de C, C++, Java, Go, Rust, C# enz. Deze gids behandelt API's voor het schrijven en lezen van checkpoints. instellen 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()
 Besparen van Opleiding APIs Tf. keras Tf. keras Zie de Gids voor het redden en herstellen. tf.keras een TensorFlow checkpoint opslaan. tf.keras.Model.save_weights net.save_weights('easy_checkpoint')
 Schrijven van checkpoints De persistente staat van een TensorFlow-model wordt opgeslagen in Deze kunnen direct worden geconstrueerd, maar worden vaak gemaakt door middel van high-level APIs zoals of . tf.Variable tf.keras.layers tf.keras.Model De gemakkelijkste manier om variabelen te beheren is door ze aan Python-objecten aan te sluiten en vervolgens deze objecten te verwijzen. Subklassen van - het en Het volgende voorbeeld bouwt een eenvoudig lineair model op en schrijft vervolgens checkpoints die waarden bevatten voor alle variabelen van het model. tf.train.Checkpoint tf.keras.layers.Layer tf.keras.Model U kunt eenvoudig een model-checkpoint opslaan met . Model.save_weights Handmatige checkpointing instellen Om alle kenmerken van de , definieer een speelgoeddataset en optimalisatie stap: 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
 Het maken van de checkpoint objecten Gebruik a object om handmatig een controlepunt te maken, waarbij de objecten die u wilt controlepunt worden ingesteld als attributen op het object. tf.train.Checkpoint a Het kan ook nuttig zijn voor het beheren van meerdere checkpoints. 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 en checkpoint het model De volgende trainingsloop creëert een voorbeeld van het model en van een optimizer en verzamelt deze vervolgens in een Het noemt de trainingsstap in een loop op elke partij gegevens en schrijft periodiek checkpoints op de schijf. 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)
 Herstel en voortzetting van de training Na de eerste trainingscyclus kun je een nieuw model en manager passeren, maar neem de training precies op waar je bent gestopt: 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)
 De object verwijdert oude checkpoints. Boven is het geconfigureerd om alleen de drie meest recente checkpoints te behouden. tf.train.CheckpointManager print(manager.checkpoints)  # List the three remaining checkpoints
 Deze wegen, bijv. , zijn geen bestanden op een schijf. In plaats daarvan zijn ze prefixen voor een bestand en een of meer gegevensbestanden die de variabele waarden bevatten. Het bestand ( ) waar de Zijn staat redden. './tf_ckpts/ckpt-10' index checkpoint './tf_ckpts/checkpoint' CheckpointManager ls ./tf_ckpts
 Laden Mechanica TensorFlow matches variabelen met gecontroleerde waarden door een gericht grafiek met benoemde randen te kruisen, te beginnen met het object dat wordt geladen. in . . gebruikt zijn sleutelwoorden argumentennamen, zoals in de in . "l1" self.l1 = tf.keras.layers.Dense(5) tf.train.Checkpoint "step" tf.train.Checkpoint(step=...) De afhankelijkheidsgrafiek van het bovenstaande voorbeeld ziet er als volgt uit: De optimizer is in rood, de reguliere variabelen zijn in blauw en de slotvariabelen van de optimizer zijn in oranje. Het is in zwart. tf.train.Checkpoint Slotvariabelen maken deel uit van de staat van de optimizer, maar worden gemaakt voor een specifieke variabele. De bovenstaande randen komen overeen met het momentum, dat de Adam optimizer voor elke variabele volgt. Slot variabelen worden alleen opgeslagen in een checkpoint als zowel de variabele als de optimizer zouden worden opgeslagen, dus de gesplitste randen. 'm' bellen is een object wacht op de gevraagde restauraties, waarbij variabele waarden worden hersteld zodra er een overeenkomend pad van de U kunt bijvoorbeeld alleen de vooroordelen van het model laden dat u hierboven hebt gedefinieerd door één pad naar het model te reconstrueren via het netwerk en de laag. 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.
 De afhankelijkheidsgrafiek voor deze nieuwe objecten is een veel kleinere subgraaf van het grotere controlepunt dat u hierboven hebt geschreven. Gebruik het aantal checkpoints. tf.train.Checkpoint retourneert een statusobject met optionele beweringen.Alle objecten die zijn gemaakt in de nieuwe Het is hersteld, dus De passes. restore Checkpoint status.assert_existing_objects_matched status.assert_existing_objects_matched()
 Er zijn veel objecten in het controlepunt die niet overeenkomen, waaronder de kernel van de laag en de variabelen van de optimizer. Dit gebeurt alleen als het controlepunt en het programma precies overeenkomen, en zou hier een uitzondering gooien. status.assert_consumed Uitgestelde restauraties Objecten in TensorFlow kunnen de creatie van variabelen uitstellen tot hun eerste oproep, wanneer inputvormen beschikbaar zijn. de kernel van de laag is afhankelijk van zowel de input- als de outputvormen van de laag, en dus is de uitvoervorm die vereist is als een constructor-argument niet voldoende informatie om de variabele op zichzelf te maken. ook de waarde van de variabele leest, een restauratie moet plaatsvinden tussen de creatie van de variabele en het eerste gebruik ervan. Layer Dense Layer Om dit idioom te ondersteunen, Defers herstelt die nog geen overeenkomende variabele hebben. 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
 Handmatig inspecteren van checkpoints Terug naar A Dat geeft lagere niveaus toegang tot de inhoud van de checkpoint. Het bevat mappen van de sleutel van elke variabele, naar de vorm en dtype voor elke variabele in de checkpoint. De sleutel van een variabele is het objectpad, zoals in de grafieken die hierboven worden weergegeven. tf.train.load_checkpoint CheckpointReader 
 
 Opmerking: Er is geen hoger niveau structuur voor het controlepunt. Het kent alleen de paden en waarden voor de variabelen, en heeft geen concept van modellen, lagen of hoe ze zijn verbonden. Het kent alleen de paden en waarden van de variabelen, en heeft geen concept van - het Of hoe ze met elkaar verbonden zijn. 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())
 Dus als je geïnteresseerd bent in de waarde van U kunt de waarde krijgen met de volgende code: net.l1.kernel key = 'net/l1/kernel/.ATTRIBUTES/VARIABLE_VALUE'

print("Shape:", shape_from_key[key])
print("Dtype:", dtype_from_key[key].name)
 Het biedt ook een methode waarmee u de waarde van een variabele kunt inspecteren: get_tensor reader.get_tensor(key)
 Object volgen Checkpoints opslaan en herstellen van de waarden van objecten door elke variabele of traceerbare object in een van zijn attributen te "tracken".Wanneer u een opslag uitvoert, worden variabelen recursief verzameld van alle bereikbare traceerbare objecten. tf.Variable Net als bij directe attribute-toewijzingen zoals , het toewijzen van lijsten en woordenboeken aan attributen zal hun inhoud bijhouden. 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()
 U kunt wrapper-objecten voor lijsten en woordenboeken opmerken. Deze wrappers zijn checkpointable versies van de onderliggende gegevensstructuren. Net als de attribuutgebaseerde lading, herstellen deze wrappers de waarde van een variabele zodra deze aan de container wordt toegevoegd. 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()
 Traceerbare objecten omvatten - het en zijn subklassen (bv. en , en erkend Python containers: tf.train.Checkpoint tf.Module keras.layers.Layer keras.Model 
 
 
 
 dict (en collections.OrderedDict) Lijst tuple (en collections.namedtuple, typing.NamedTuple) Andere containers zijn met inbegrip van: not supported 
 
 
 Collectie.defaultdict Set Alle andere Python-objecten zijn met inbegrip van: ignored 
 
 
 
 Int String vloeien Samenvatting TensorFlow-objecten bieden een eenvoudig automatisch mechanisme voor het opslaan en herstellen van de waarden van de variabelen die ze gebruiken. 
 
 Oorspronkelijk gepubliceerd op de website van TensorFlow, verschijnt dit artikel hier onder een nieuwe kop en is gelicentieerd onder CC BY 4.0. Oorspronkelijk gepubliceerd op de website van TensorFlow, verschijnt dit artikel hier onder een nieuwe kop en is gelicentieerd onder CC BY 4.0. De TensorFlow De TensorFlow

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

Deze audio wordt geproduceerd in de originele taal van het verhaal!

Hoe TensorFlow-modellen op te slaan en te laden

About Author

OPMERKINGEN

LABELS

DIT ARTIKEL WERD GEPRESENTEERD IN

Related Stories

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps