Yardım Kaggle üzerinde TensorFlow ile Büyük Bariyer Resifi korumak Meydan Üyelik

Eğitim kontrol noktaları

TensorFlow.org'da görüntüleyin Google Colab'da çalıştırın Kaynağı GitHub'da görüntüleyin Not defterini indir

"Bir TensorFlow modelini kaydetme" ifadesi tipik olarak iki şeyden biri anlamına gelir:

  1. Kontrol noktaları, VEYA
  2. Kayıtlı Model.

Kontrol noktaları tüm parametrelerin (tam değer yakalama tf.Variable bir modeli tarafından kullanılan nesneler). Kontrol noktaları, model tarafından tanımlanan hesaplamanın herhangi bir tanımını içermez ve bu nedenle, genellikle yalnızca kaydedilen parametre değerlerini kullanacak kaynak kodu mevcut olduğunda kullanışlıdır.

SavedModel formatı ise parametre değerlerine (kontrol noktası) ek olarak model tarafından tanımlanan hesaplamanın serileştirilmiş bir açıklamasını içerir. Bu formattaki modeller, modeli oluşturan kaynak koddan bağımsızdır. Bu nedenle TensorFlow Serving, TensorFlow Lite, TensorFlow.js veya diğer programlama dillerindeki programlar (C, C++, Java, Go, Rust, C# vb. TensorFlow API'leri) aracılığıyla dağıtım için uygundurlar.

Bu kılavuz, kontrol noktaları yazmak ve okumak için API'leri kapsar.

Kurmak

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()

Dan tasarruf tf.keras eğitim API'leri

Bkz tf.keras kaydetme ve geri yükleme konusunda yol gösterir.

tf.keras.Model.save_weights bir TensorFlow kontrol noktasına kaydeder.

net.save_weights('easy_checkpoint')

Kontrol noktaları yazma

Bir TensorFlow modelinin kalıcı durumu depolanır tf.Variable nesne. Bunlar doğrudan yapılabilir, ancak genellikle gibi üst düzey API'ler aracılığıyla oluşturulan tf.keras.layers veya tf.keras.Model .

Değişkenleri yönetmenin en kolay yolu, onları Python nesnelerine eklemek ve ardından bu nesnelere referans vermektir.

Alt sınıfları tf.train.Checkpoint , tf.keras.layers.Layer ve tf.keras.Model otomatik olarak niteliklere tahsis değişkenleri izleyecek. Aşağıdaki örnek, basit bir doğrusal model oluşturur, ardından modelin tüm değişkenleri için değerler içeren kontrol noktaları yazar.

Kolayca ile bir model-denetim noktası kaydedebilirsiniz Model.save_weights .

Manuel kontrol noktası

Kurmak

Yardım için tüm özellikleri gösteren tf.train.Checkpoint , bir oyuncak veri kümesi ve optimizasyon adımı tanımlar:

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

Kontrol noktası nesnelerini oluşturun

Bir kullan tf.train.Checkpoint elle kontrol noktasına istediğiniz nesneleri nesne üzerinde özellikler olarak ayarlanır bir kontrol noktası oluşturmak için nesneyi.

Bir tf.train.CheckpointManager aynı zamanda birden fazla kontrol noktaları yönetmek için yararlı olabilir.

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)

Modeli eğitin ve kontrol edin

Aşağıdaki eğitim döngü modelinin bir örneğini oluşturur ve bir optimizasyon birleştirdikten sonra bunları toplar tf.train.Checkpoint nesne. Her veri grubu üzerinde eğitim adımını bir döngü içinde çağırır ve diske periyodik olarak kontrol noktaları yazar.

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)
Initializing from scratch.
Saved checkpoint for step 10: ./tf_ckpts/ckpt-1
loss 30.37
Saved checkpoint for step 20: ./tf_ckpts/ckpt-2
loss 23.79
Saved checkpoint for step 30: ./tf_ckpts/ckpt-3
loss 17.23
Saved checkpoint for step 40: ./tf_ckpts/ckpt-4
loss 10.72
Saved checkpoint for step 50: ./tf_ckpts/ckpt-5
loss 4.44

Eğitimi geri yükle ve devam et

İlk eğitim döngüsünden sonra yeni bir model ve yöneticiye geçebilirsiniz, ancak eğitime tam olarak kaldığınız yerden devam edebilirsiniz:

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)
Restored from ./tf_ckpts/ckpt-5
Saved checkpoint for step 60: ./tf_ckpts/ckpt-6
loss 1.33
Saved checkpoint for step 70: ./tf_ckpts/ckpt-7
loss 1.02
Saved checkpoint for step 80: ./tf_ckpts/ckpt-8
loss 0.68
Saved checkpoint for step 90: ./tf_ckpts/ckpt-9
loss 0.34
Saved checkpoint for step 100: ./tf_ckpts/ckpt-10
loss 0.16

tf.train.CheckpointManager nesne eski kontrol noktaları siler. Yukarıda, yalnızca en son üç kontrol noktasını tutacak şekilde yapılandırılmıştır.

print(manager.checkpoints)  # List the three remaining checkpoints
['./tf_ckpts/ckpt-8', './tf_ckpts/ckpt-9', './tf_ckpts/ckpt-10']

Bu yollar, örneğin './tf_ckpts/ckpt-10' , değil diskte dosyaları. Bunun yerine bir önekleri olan index dosyası ve değişken değerleri içeren bir veya daha fazla veri dosyaları. Bu önekler tek gruplanıyor checkpoint dosyası ( './tf_ckpts/checkpoint' ) CheckpointManager onun durumunu kaydeder.

ls ./tf_ckpts
checkpoint           ckpt-8.data-00000-of-00001  ckpt-9.index
ckpt-10.data-00000-of-00001  ckpt-8.index
ckpt-10.index            ckpt-9.data-00000-of-00001

Yükleme mekaniği

TensorFlow, yüklenen nesneden başlayarak, adlandırılmış kenarlara sahip yönlendirilmiş bir grafiğin üzerinden geçerek değişkenleri kontrol noktası değerleriyle eşleştirir. Kenar adları tipik olarak örneğin, nesne içindeki nitelik adları gelen "l1" olarak self.l1 = tf.keras.layers.Dense(5) . tf.train.Checkpoint olarak, onun anahtar kelime argüman isimlerini kullanır "step" in tf.train.Checkpoint(step=...) .

Yukarıdaki örnekteki bağımlılık grafiği şöyle görünür:

Örnek eğitim döngüsü için bağımlılık grafiğinin görselleştirilmesi

Optimize edici kırmızı, normal değişkenler mavi ve optimize edici slot değişkenleri turuncu. Diğer düğümlerin örneğin, temsil tf.train.Checkpoint siyah misin.

Yuva değişkenleri, optimize edicinin durumunun bir parçasıdır, ancak belirli bir değişken için oluşturulur. Örneğin 'm' ivme yukarıda anlatılmış olan, kenarları, her hangi bir değişken için, Adam iyileştirici izler. Yuva değişkenleri, yalnızca değişken ve optimize edicinin her ikisi de, dolayısıyla kesikli kenarlar kaydedilecekse bir kontrol noktasına kaydedilir.

Çağrı restore bir üzerinde tf.train.Checkpoint , nesne kuyruklar istenen restorasyon gelen eşleşen bir yolu var en kısa sürede değişken değerleri yeniden Checkpoint nesne. Örneğin, ağ ve katman üzerinden bir yolu yeniden yapılandırarak yukarıda tanımladığınız modelden yalnızca sapmayı yükleyebilirsiniz.

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.
[0. 0. 0. 0. 0.]
[2.9910686 3.8070676 3.252836  4.277522  3.8073184]

Bu yeni nesneler için bağımlılık grafiği, yukarıda yazdığınız daha büyük kontrol noktasının çok daha küçük bir alt grafiğidir. O tezgahın tasarruf sadece önyargı ve içerir tf.train.Checkpoint sayı kontrol noktaları kullanır.

Önyargı değişkeni için bir alt grafiğin görselleştirilmesi

restore döndürür isteğe bağlı iddialarını içeren bir durum nesnesi. Yeni oluşturulan nesneler tüm Checkpoint , restore böylece edilmiş status.assert_existing_objects_matched geçer.

status.assert_existing_objects_matched()
<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f898454bed0>

Kontrol noktasında, katmanın çekirdeği ve optimize edicinin değişkenleri dahil, eşleşmeyen birçok nesne var. status.assert_consumed yalnızca kontrol noktası ve program maçı tam geçer ve burada bir istisna olacaktır.

Gecikmeli restorasyonlar

Layer TensorFlow nesneler giriş şekilleri mevcuttur ilk çağrı, değişkenlerin oluşturulmasını geciktirebilir. Örneğin bir şekli Dense katmanın kernel hem katmanın giriş ve çıkış şekilleri bağlıdır ve bir yapıcı argüman olarak gerekli çıkış şekli böylece kendi başına değişken oluşturmak için yeterli bilgi yoktur. Bir çağırarak yana Layer da değişkenin değerini okur, geri bir değişkenin oluşturulması ve ilk kullanımı arasında gerçekleşmesi gerekir.

Bu deyim desteklemek için, tf.train.Checkpoint henüz eşleşen bir değişkeni yok geri yüklemeler sıralar.

delayed_restore = tf.Variable(tf.zeros([1, 5]))
print(delayed_restore.numpy())  # Not restored; still zeros
fake_layer.kernel = delayed_restore
print(delayed_restore.numpy())  # Restored
[[0. 0. 0. 0. 0.]]
[[4.5344105 4.5929823 4.7816424 4.758177  5.007635 ]]

Kontrol noktalarını manuel olarak denetleme

tf.train.load_checkpoint bir döndüren CheckpointReader kontrol noktası içeriğine alt düzey erişim sağlar. Her bir değişkenin anahtarından, kontrol noktasındaki her bir değişkenin şekline ve tipine eşlemeler içerir. Bir değişkenin anahtarı, yukarıda gösterilen grafiklerde olduğu gibi nesne yoludur.

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())
['_CHECKPOINTABLE_OBJECT_GRAPH',
 'iterator/.ATTRIBUTES/ITERATOR_STATE',
 'net/l1/bias/.ATTRIBUTES/VARIABLE_VALUE',
 'net/l1/bias/.OPTIMIZER_SLOT/optimizer/m/.ATTRIBUTES/VARIABLE_VALUE',
 'net/l1/bias/.OPTIMIZER_SLOT/optimizer/v/.ATTRIBUTES/VARIABLE_VALUE',
 'net/l1/kernel/.ATTRIBUTES/VARIABLE_VALUE',
 'net/l1/kernel/.OPTIMIZER_SLOT/optimizer/m/.ATTRIBUTES/VARIABLE_VALUE',
 'net/l1/kernel/.OPTIMIZER_SLOT/optimizer/v/.ATTRIBUTES/VARIABLE_VALUE',
 'optimizer/beta_1/.ATTRIBUTES/VARIABLE_VALUE',
 'optimizer/beta_2/.ATTRIBUTES/VARIABLE_VALUE',
 'optimizer/decay/.ATTRIBUTES/VARIABLE_VALUE',
 'optimizer/iter/.ATTRIBUTES/VARIABLE_VALUE',
 'optimizer/learning_rate/.ATTRIBUTES/VARIABLE_VALUE',
 'save_counter/.ATTRIBUTES/VARIABLE_VALUE',
 'step/.ATTRIBUTES/VARIABLE_VALUE']

Eğer değeri ilgilenen Yani eğer net.l1.kernel aşağıdaki kodla değer elde edebilirsiniz:

key = 'net/l1/kernel/.ATTRIBUTES/VARIABLE_VALUE'

print("Shape:", shape_from_key[key])
print("Dtype:", dtype_from_key[key].name)
Shape: [1, 5]
Dtype: float32

Ayrıca içerir get_tensor bir değişkenin değeri kontrol sağlayan bir yöntem:

reader.get_tensor(key)
array([[4.5344105, 4.5929823, 4.7816424, 4.758177 , 5.007635 ]],
      dtype=float32)

nesne izleme

Kontrol noktaları tasarrufu ve değerleri geri tf.Variable özelliklerinden birine de "izleme" Herhangi bir değişken veya izlenebilir nesne kümesi tarafından itiraz ediyor. Bir kaydetme yürütülürken, değişkenler, erişilebilir tüm izlenen nesnelerden özyinelemeli olarak toplanır.

Gibi direkt nitelik atamaları gibi self.l1 = tf.keras.layers.Dense(5) , özelliklerine listeleri ve sözlükleri atama içeriklerini takip edecektir.

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()

Listeler ve sözlükler için sarmalayıcı nesneler görebilirsiniz. Bu sarmalayıcılar, temel alınan veri yapılarının denetlenebilir sürümleridir. Öznitelik tabanlı yükleme gibi, bu sarmalayıcılar, kapsayıcıya eklenir eklenmez bir değişkenin değerini geri yükler.

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()
ListWrapper([])

Takip edilebilir nesneler dahil tf.train.Checkpoint , tf.Module ve alt sınıfları (örneğin, keras.layers.Layer ve keras.Model ) ve kabul Python kaplar:

  • dict (ve collections.OrderedDict )
  • list
  • tuple (ve collections.namedtuple , typing.NamedTuple )

Diğer kap tipleri de dahil olmak üzere desteklenmez:

  • collections.defaultdict
  • set

Diğer tüm Python nesneleri de dahil olmak üzere göz ardı edilir:

  • int
  • string
  • float

Özet

TensorFlow nesneleri, kullandıkları değişkenlerin değerlerini kaydetmek ve geri yüklemek için kolay bir otomatik mekanizma sağlar.