Etkili Tensorflow 2

TensorFlow.org'da görüntüleyin

Google Colab'da çalıştırın

GitHub'da görüntüle

Not defterini indir

genel bakış

Bu kılavuz, TensorFlow 2 (TF2) kullanarak kod yazmak için en iyi uygulamaların bir listesini sağlar, yakın zamanda TensorFlow 1'den (TF1) geçiş yapan kullanıcılar için yazılmıştır. TF1 kodunuzu TF2'ye taşıma hakkında daha fazla bilgi için kılavuzun taşıma bölümüne bakın.

Kurmak

Bu kılavuzdaki örnekler için TensorFlow ve diğer bağımlılıkları içe aktarın.

import tensorflow as tf
import tensorflow_datasets as tfds

Deyimsel TensorFlow 2 için öneriler

Kodunuzu daha küçük modüllere dönüştürün

İyi bir uygulama, kodunuzu gerektiğinde çağrılan daha küçük işlevlere dönüştürmektir. En iyi performans için, bir tf.function içinde yapabileceğiniz en büyük hesaplama bloklarını dekore etmeye çalışmalısınız (farklı jit_compile kullanmak istemiyorsanız, bir tf.function tarafından çağrılan iç içe python işlevlerinin kendi ayrı dekorasyonlarını gerektirmediğine dikkat edin). tf.function için ayarlar). Kullanım durumunuza bağlı olarak bu, birden fazla eğitim adımı veya hatta tüm eğitim döngünüz olabilir. Çıkarım kullanım durumları için, tek bir model ileri geçiş olabilir.

Bazı tf.keras.optimizer s için varsayılan öğrenme oranını ayarlayın

Bazı Keras optimize ediciler, TF2'de farklı öğrenme oranlarına sahiptir. Modelleriniz için yakınsama davranışında bir değişiklik görürseniz, varsayılan öğrenme oranlarını kontrol edin.

optimizers.SGD , optimizers.Adam veya optimizers.RMSprop için herhangi bir değişiklik yoktur.

Aşağıdaki varsayılan öğrenme oranları değişti:

• optimizers.Adagrad 0.01 0.001
• optimizers.Adadelta 1.0 0.001
• optimizers.Adamax 0.002 0.001
• optimizers.Nadam 0.002 0.001

Değişkenleri yönetmek için tf.Module s ve Keras katmanlarını kullanın

tf.Module s ve tf.keras.layers.Layer s, tüm bağımlı değişkenleri yinelemeli olarak toplayan uygun variables ve trainable_variables özellikleri sunar. Bu, değişkenleri kullanıldıkları yere göre yerel olarak yönetmeyi kolaylaştırır.

Keras katmanları/modelleri, tf.train.Checkpointable devralır ve @tf.function ile entegredir; bu, Keras nesnelerinden SavedModel'leri doğrudan denetlemeyi veya dışa aktarmayı mümkün kılar. Bu entegrasyonlardan yararlanmak için mutlaka Keras' Model.fit API'sini kullanmanız gerekmez.

Keras kullanarak ilgili değişkenlerin bir alt kümesini nasıl toplayacağınızı öğrenmek için Keras kılavuzundaki aktarım öğrenimi ve ince ayar bölümünü okuyun.

tf.data.Dataset s ve tf.function birleştirin

TensorFlow Veri Kümeleri paketi ( tfds ), önceden tanımlanmış veri kümelerini tf.data.Dataset nesneleri olarak yüklemek için yardımcı programları içerir. Bu örnek için, MNIST veri kümesini tfds kullanarak yükleyebilirsiniz:

datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
mnist_train, mnist_test = datasets['train'], datasets['test']

Ardından verileri eğitim için hazırlayın:

• Her görüntüyü yeniden ölçeklendirin.
• Örneklerin sırasını karıştırın.
• Toplu resim ve etiket toplayın.

BUFFER_SIZE = 10 # Use a much larger value for real code
BATCH_SIZE = 64
NUM_EPOCHS = 5


def scale(image, label):
  image = tf.cast(image, tf.float32)
  image /= 255

  return image, label

Örneği kısa tutmak için veri kümesini yalnızca 5 grup döndürecek şekilde kırpın:

train_data = mnist_train.map(scale).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
test_data = mnist_test.map(scale).batch(BATCH_SIZE)

STEPS_PER_EPOCH = 5

train_data = train_data.take(STEPS_PER_EPOCH)
test_data = test_data.take(STEPS_PER_EPOCH)

image_batch, label_batch = next(iter(train_data))

-yer tutucu5 l10n-yer

2021-12-08 17:15:01.637157: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

Belleğe sığan eğitim verilerini yinelemek için normal Python yinelemesini kullanın. Aksi takdirde, tf.data.Dataset , eğitim verilerini diskten aktarmanın en iyi yoludur. Veri kümeleri yinelenebilirdir (yineleyiciler değil) ve istekli yürütmede diğer Python yinelenebilirleri gibi çalışır. Kodunuzu, tf.function kullanarak Python yinelemesini eşdeğer grafik işlemleriyle değiştiren tf.function içine sararak veri kümesi zaman uyumsuz önceden getirme/akış özelliklerini tam olarak kullanabilirsiniz.

@tf.function
def train(model, dataset, optimizer):
  for x, y in dataset:
    with tf.GradientTape() as tape:
      # training=True is only needed if there are layers with different
      # behavior during training versus inference (e.g. Dropout).
      prediction = model(x, training=True)
      loss = loss_fn(prediction, y)
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))

Model.fit API'sini kullanırsanız, veri kümesi yinelemesi konusunda endişelenmenize gerek kalmaz.

model.compile(optimizer=optimizer, loss=loss_fn)
model.fit(dataset)

Keras eğitim döngülerini kullanın

Eğitim sürecinizin düşük düzeyde kontrolüne ihtiyacınız yoksa, Keras'ın yerleşik fit , evaluate ve predict yöntemlerini kullanmanız önerilir. Bu yöntemler, uygulamadan (sıralı, işlevsel veya alt sınıflı) bağımsız olarak modeli eğitmek için tek tip bir arabirim sağlar.

Bu yöntemlerin avantajları şunları içerir:

• Numpy dizilerini, Python jeneratörlerini ve tf.data.Datasets kabul ederler.
• Düzenleme ve aktivasyon kayıplarını otomatik olarak uygularlar.
• Donanım yapılandırmasından bağımsız olarak eğitim kodunun aynı kaldığı tf.distribute desteklerler.
• Kayıplar ve metrikler olarak isteğe bağlı çağrılabilirleri desteklerler.
• tf.keras.callbacks.TensorBoard gibi geri aramaları ve özel geri aramaları desteklerler.
• TensorFlow grafiklerini kullanarak otomatik olarak performans gösterirler.

İşte bir Dataset kullanarak bir modelin eğitimine bir örnek. Bunun nasıl çalıştığıyla ilgili ayrıntılar için öğreticilere bakın.

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
])

# Model is the full model w/o custom layers
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

model.fit(train_data, epochs=NUM_EPOCHS)
loss, acc = model.evaluate(test_data)

print("Loss {}, Accuracy {}".format(loss, acc))

tutucu9 l10n-yer

Epoch 1/5
5/5 [==============================] - 9s 7ms/step - loss: 1.5762 - accuracy: 0.4938
Epoch 2/5
2021-12-08 17:15:11.145429: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
5/5 [==============================] - 0s 6ms/step - loss: 0.5087 - accuracy: 0.8969
Epoch 3/5
2021-12-08 17:15:11.559374: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
5/5 [==============================] - 2s 5ms/step - loss: 0.3348 - accuracy: 0.9469
Epoch 4/5
2021-12-08 17:15:13.860407: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
5/5 [==============================] - 0s 5ms/step - loss: 0.2445 - accuracy: 0.9688
Epoch 5/5
2021-12-08 17:15:14.269850: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
5/5 [==============================] - 0s 6ms/step - loss: 0.2006 - accuracy: 0.9719
2021-12-08 17:15:14.717552: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
5/5 [==============================] - 1s 4ms/step - loss: 1.4553 - accuracy: 0.5781
Loss 1.4552843570709229, Accuracy 0.578125
2021-12-08 17:15:15.862684: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

Eğitimi özelleştirin ve kendi döngünüzü yazın

Keras modelleri sizin için çalışıyorsa, ancak eğitim adımı veya dış eğitim döngüleri üzerinde daha fazla esnekliğe ve kontrole ihtiyacınız varsa, kendi eğitim adımlarınızı veya hatta tüm eğitim döngülerini uygulayabilirsiniz. Daha fazla bilgi edinmek için fit özelleştirmeyle ilgili Keras kılavuzuna bakın.

Bir çok şeyi tf.keras.callbacks.Callback olarak da uygulayabilirsiniz.

Bu yöntemin daha önce bahsedilen birçok avantajı vardır, ancak size tren adımının ve hatta dış döngünün kontrolünü verir.

Standart bir eğitim döngüsünün üç adımı vardır:

1. Örnek yığınları almak için bir Python oluşturucu veya tf.data.Dataset üzerinde yineleme yapın.
2. Degradeleri toplamak için tf.GradientTape kullanın.
3. Modelin değişkenlerine ağırlık güncellemeleri uygulamak için tf.keras.optimizers birini kullanın.

Unutma:

• Her zaman alt sınıflanmış katmanların ve modellerin call yöntemine bir training argümanı ekleyin.
• Modeli training argümanı doğru ayarlanmış olarak çağırdığınızdan emin olun.
• Kullanıma bağlı olarak, model bir grup veri üzerinde çalıştırılana kadar model değişkenleri mevcut olmayabilir.
• Model için düzenlileştirme kayıpları gibi şeyleri manuel olarak halletmeniz gerekir.

Değişken başlatıcıları çalıştırmaya veya manuel kontrol bağımlılıkları eklemeye gerek yoktur. tf.function , sizin için oluşturma sırasında otomatik kontrol bağımlılıklarını ve değişken başlatma işlemlerini gerçekleştirir.

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
])

optimizer = tf.keras.optimizers.Adam(0.001)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

@tf.function
def train_step(inputs, labels):
  with tf.GradientTape() as tape:
    predictions = model(inputs, training=True)
    regularization_loss=tf.math.add_n(model.losses)
    pred_loss=loss_fn(labels, predictions)
    total_loss=pred_loss + regularization_loss

  gradients = tape.gradient(total_loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))

for epoch in range(NUM_EPOCHS):
  for inputs, labels in train_data:
    train_step(inputs, labels)
  print("Finished epoch", epoch)

tutucu11 l10n-yer

2021-12-08 17:15:16.714849: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Finished epoch 0
2021-12-08 17:15:17.097043: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Finished epoch 1
2021-12-08 17:15:17.502480: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Finished epoch 2
2021-12-08 17:15:17.873701: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Finished epoch 3
Finished epoch 4
2021-12-08 17:15:18.344196: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

Python kontrol akışıyla tf.function özelliğinden yararlanın

tf.function veriye bağlı kontrol akışını tf.cond ve tf.while_loop gibi grafik modu eşdeğerlerine dönüştürmek için bir yol sağlar.

Veriye bağlı kontrol akışının göründüğü yaygın bir yer, sıralı modellerdir. tf.keras.layers.RNN , bir RNN hücresini sararak yinelemeyi statik veya dinamik olarak açmanıza olanak tanır. Örnek olarak, dinamik açmayı aşağıdaki gibi yeniden uygulayabilirsiniz.

class DynamicRNN(tf.keras.Model):

  def __init__(self, rnn_cell):
    super(DynamicRNN, self).__init__(self)
    self.cell = rnn_cell

  @tf.function(input_signature=[tf.TensorSpec(dtype=tf.float32, shape=[None, None, 3])])
  def call(self, input_data):

    # [batch, time, features] -> [time, batch, features]
    input_data = tf.transpose(input_data, [1, 0, 2])
    timesteps =  tf.shape(input_data)[0]
    batch_size = tf.shape(input_data)[1]
    outputs = tf.TensorArray(tf.float32, timesteps)
    state = self.cell.get_initial_state(batch_size = batch_size, dtype=tf.float32)
    for i in tf.range(timesteps):
      output, state = self.cell(input_data[i], state)
      outputs = outputs.write(i, output)
    return tf.transpose(outputs.stack(), [1, 0, 2]), state

lstm_cell = tf.keras.layers.LSTMCell(units = 13)

my_rnn = DynamicRNN(lstm_cell)
outputs, state = my_rnn(tf.random.normal(shape=[10,20,3]))
print(outputs.shape)

-yer tutucu14 l10n-yer

(10, 20, 13)

Daha fazla bilgi için tf.function kılavuzunu okuyun.

Yeni tarz metrikler ve kayıplar

Metrikler ve kayıplar hem hevesle çalışan nesnelerdir hem de tf.function s'de.

Bir kayıp nesnesi çağrılabilir ve argüman olarak ( y_true , y_pred ) bekler:

cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
cce([[1, 0]], [[-1.0,3.0]]).numpy()

tutucu16 l10n-yer

4.01815

Veri toplamak ve görüntülemek için metrikleri kullanın

Verileri toplamak için tf.metrics ve özetleri günlüğe kaydetmek ve bir bağlam yöneticisi kullanarak bir yazara yönlendirmek için tf.summary kullanabilirsiniz. Özetler doğrudan yazara gönderilir, bu da çağrı yerinde step değerini sağlamanız gerektiği anlamına gelir.

summary_writer = tf.summary.create_file_writer('/tmp/summaries')
with summary_writer.as_default():
  tf.summary.scalar('loss', 0.1, step=42)

Verileri özet olarak kaydetmeden önce toplamak için tf.metrics kullanın. Metrikler durum bilgisidir; result yöntemini çağırdığınızda ( Mean.result gibi) değerleri biriktirir ve kümülatif bir sonuç döndürürler. Model.reset_states ile birikmiş değerleri temizleyin.

def train(model, optimizer, dataset, log_freq=10):
  avg_loss = tf.keras.metrics.Mean(name='loss', dtype=tf.float32)
  for images, labels in dataset:
    loss = train_step(model, optimizer, images, labels)
    avg_loss.update_state(loss)
    if tf.equal(optimizer.iterations % log_freq, 0):
      tf.summary.scalar('loss', avg_loss.result(), step=optimizer.iterations)
      avg_loss.reset_states()

def test(model, test_x, test_y, step_num):
  # training=False is only needed if there are layers with different
  # behavior during training versus inference (e.g. Dropout).
  loss = loss_fn(model(test_x, training=False), test_y)
  tf.summary.scalar('loss', loss, step=step_num)

train_summary_writer = tf.summary.create_file_writer('/tmp/summaries/train')
test_summary_writer = tf.summary.create_file_writer('/tmp/summaries/test')

with train_summary_writer.as_default():
  train(model, optimizer, dataset)

with test_summary_writer.as_default():
  test(model, test_x, test_y, optimizer.iterations)

TensorBoard'u özet günlük dizinine işaret ederek oluşturulan özetleri görselleştirin:

tensorboard --logdir /tmp/summaries

TensorBoard'da görselleştirme için özet verileri yazmak için tf.summary API'sini kullanın. Daha fazla bilgi için tf.summary kılavuzunu okuyun.

# Create the metrics
loss_metric = tf.keras.metrics.Mean(name='train_loss')
accuracy_metric = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')

@tf.function
def train_step(inputs, labels):
  with tf.GradientTape() as tape:
    predictions = model(inputs, training=True)
    regularization_loss=tf.math.add_n(model.losses)
    pred_loss=loss_fn(labels, predictions)
    total_loss=pred_loss + regularization_loss

  gradients = tape.gradient(total_loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))
  # Update the metrics
  loss_metric.update_state(total_loss)
  accuracy_metric.update_state(labels, predictions)


for epoch in range(NUM_EPOCHS):
  # Reset the metrics
  loss_metric.reset_states()
  accuracy_metric.reset_states()

  for inputs, labels in train_data:
    train_step(inputs, labels)
  # Get the metric results
  mean_loss=loss_metric.result()
  mean_accuracy = accuracy_metric.result()

  print('Epoch: ', epoch)
  print('  loss:     {:.3f}'.format(mean_loss))
  print('  accuracy: {:.3f}'.format(mean_accuracy))

tutucu21 l10n-yer

2021-12-08 17:15:19.339736: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Epoch:  0
  loss:     0.142
  accuracy: 0.991
2021-12-08 17:15:19.781743: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Epoch:  1
  loss:     0.125
  accuracy: 0.997
2021-12-08 17:15:20.219033: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Epoch:  2
  loss:     0.110
  accuracy: 0.997
2021-12-08 17:15:20.598085: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Epoch:  3
  loss:     0.099
  accuracy: 0.997
Epoch:  4
  loss:     0.085
  accuracy: 1.000
2021-12-08 17:15:20.981787: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

Keras metrik adları

Keras modelleri, metrik adları işleme konusunda tutarlıdır. Metrik listesinde bir dize ilettiğinizde, bu tam dize, metriğin name olarak kullanılır. Bu adlar, model.fit tarafından döndürülen geçmiş nesnesinde ve keras.callbacks iletilen günlüklerde görünür. metrik listesinde ilettiğiniz dizeye ayarlanır.

model.compile(
    optimizer = tf.keras.optimizers.Adam(0.001),
    loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics = ['acc', 'accuracy', tf.keras.metrics.SparseCategoricalAccuracy(name="my_accuracy")])
history = model.fit(train_data)

5/5 [==============================] - 1s 5ms/step - loss: 0.0963 - acc: 0.9969 - accuracy: 0.9969 - my_accuracy: 0.9969
2021-12-08 17:15:21.942940: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

yer tutucu24 l10n-yer

history.history.keys()

dict_keys(['loss', 'acc', 'accuracy', 'my_accuracy'])

hata ayıklama

Şekilleri, veri türlerini ve değerleri incelemek için kodunuzu adım adım çalıştırmak için istekli yürütmeyi kullanın. tf.function , tf.keras vb. gibi belirli API'ler, performans ve taşınabilirlik için Grafik yürütmeyi kullanmak üzere tasarlanmıştır. Hata ayıklama sırasında, bu kod içinde istekli yürütmeyi kullanmak için tf.config.run_functions_eagerly(True) kullanın.

Örneğin:

@tf.function
def f(x):
  if x > 0:
    import pdb
    pdb.set_trace()
    x = x + 1
  return x

tf.config.run_functions_eagerly(True)
f(tf.constant(1))

tutucu27 l10n-yer

>>> f()
-> x = x + 1
(Pdb) l
  6     @tf.function
  7     def f(x):
  8       if x > 0:
  9         import pdb
 10         pdb.set_trace()
 11  ->     x = x + 1
 12       return x
 13
 14     tf.config.run_functions_eagerly(True)
 15     f(tf.constant(1))
[EOF]

Bu aynı zamanda Keras modellerinde ve istekli yürütmeyi destekleyen diğer API'lerde de çalışır:

class CustomModel(tf.keras.models.Model):

  @tf.function
  def call(self, input_data):
    if tf.reduce_mean(input_data) > 0:
      return input_data
    else:
      import pdb
      pdb.set_trace()
      return input_data // 2


tf.config.run_functions_eagerly(True)
model = CustomModel()
model(tf.constant([-2, -4]))

tutucu29 l10n-yer

>>> call()
-> return input_data // 2
(Pdb) l
 10         if tf.reduce_mean(input_data) > 0:
 11           return input_data
 12         else:
 13           import pdb
 14           pdb.set_trace()
 15  ->       return input_data // 2
 16
 17
 18     tf.config.run_functions_eagerly(True)
 19     model = CustomModel()
 20     model(tf.constant([-2, -4]))

Notlar:

• tf.keras.Model metotları fit , evaluate ve predict gibi tf.function ile grafik olarak çalıştırılır.

• tf.keras.Model.compile kullanırken, Model mantığının bir tf.function içine sarılmasını devre dışı bırakmak için run_eagerly = True değerini ayarlayın.

• tf.data.experimental.enable_debug_mode için hata ayıklama modunu etkinleştirmek için tf.data . Daha fazla ayrıntı için API belgelerini okuyun.

Nesnelerinizde tf.Tensors

Bu tensör nesneleri ya bir tf.function içinde ya da istekli bağlamda yaratılabilir ve bu tensörler farklı davranır. Her zaman sadece ara değerler için tf.Tensor s kullanın.

Durumu izlemek için tf.Variable s kullanın, çünkü bunlar her iki bağlamdan da her zaman kullanılabilir. Daha fazla bilgi için tf.Variable kılavuzunu okuyun.

Kaynaklar ve daha fazla okuma

• TF2'nin nasıl kullanılacağı hakkında daha fazla bilgi edinmek için TF2 kılavuzlarını ve eğitimlerini okuyun.

• Daha önce TF1.x kullandıysanız, kodunuzu TF2'ye taşımanız önemle tavsiye edilir. Daha fazla bilgi edinmek için geçiş kılavuzlarını okuyun.