tf.distribute.Strategy ile özel eğitim

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

Bu öğretici, özel eğitim döngüleriyle tf.distribute.Strategy nasıl kullanılacağını gösterir. Moda MNIST veri seti üzerinde basit bir CNN modeli eğiteceğiz. Moda MNIST veri seti, 28 x 28 boyutunda 60000 tren görüntüsü ve 28 x 28 boyutunda 10000 test görüntüsü içerir.

Modelimizi eğitmek için özel eğitim döngüleri kullanıyoruz çünkü bunlar bize eğitim üzerinde esneklik ve daha fazla kontrol sağlıyor. Ayrıca, modelde ve eğitim döngüsünde hata ayıklamak daha kolaydır.

# Import TensorFlow
import tensorflow as tf

# Helper libraries
import numpy as np
import os

print(tf.__version__)
tutucu1 l10n-yer
2.8.0-rc1

Moda MNIST veri setini indirin

fashion_mnist = tf.keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

# Adding a dimension to the array -> new shape == (28, 28, 1)
# We are doing this because the first layer in our model is a convolutional
# layer and it requires a 4D input (batch_size, height, width, channels).
# batch_size dimension will be added later on.
train_images = train_images[..., None]
test_images = test_images[..., None]

# Getting the images in [0, 1] range.
train_images = train_images / np.float32(255)
test_images = test_images / np.float32(255)

Değişkenleri ve grafiği dağıtmak için bir strateji oluşturun

tf.distribute.MirroredStrategy stratejisi nasıl çalışır?

  • Tüm değişkenler ve model grafiği, kopyalarda çoğaltılır.
  • Giriş, kopyalar arasında eşit olarak dağıtılır.
  • Her kopya, aldığı girdi için kaybı ve gradyanları hesaplar.
  • Degradeler, toplanarak tüm kopyalar arasında eşitlenir.
  • Eşitlemeden sonra, her replikadaki değişkenlerin kopyalarına aynı güncelleme yapılır.
# If the list of devices is not specified in the
# `tf.distribute.MirroredStrategy` constructor, it will be auto-detected.
strategy = tf.distribute.MirroredStrategy()

INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)
yer tutucu5 l10n-yer
print ('Number of devices: {}'.format(strategy.num_replicas_in_sync))

Number of devices: 1

Giriş ardışık düzenini ayarla

Grafiği ve değişkenleri platformdan bağımsız SavedModel biçimine aktarın. Modeliniz kaydedildikten sonra dürbünlü veya dürbünsüz olarak yükleyebilirsiniz.

BUFFER_SIZE = len(train_images)

BATCH_SIZE_PER_REPLICA = 64
GLOBAL_BATCH_SIZE = BATCH_SIZE_PER_REPLICA * strategy.num_replicas_in_sync

EPOCHS = 10

Veri kümelerini oluşturun ve bunları dağıtın:

train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_labels)).shuffle(BUFFER_SIZE).batch(GLOBAL_BATCH_SIZE) 
test_dataset = tf.data.Dataset.from_tensor_slices((test_images, test_labels)).batch(GLOBAL_BATCH_SIZE) 

train_dist_dataset = strategy.experimental_distribute_dataset(train_dataset)
test_dist_dataset = strategy.experimental_distribute_dataset(test_dataset)
tutucu9 l10n-yer
2022-01-26 05:45:53.991501: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:776] AUTO sharding policy will apply DATA sharding policy as it failed to apply FILE sharding policy because of the following reason: Found an unshardable source dataset: name: "TensorSliceDataset/_2"
op: "TensorSliceDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_UINT8
    }
  }
}
attr {
  key: "_cardinality"
  value {
    i: 60000
  }
}
attr {
  key: "is_files"
  value {
    b: false
  }
}
attr {
  key: "metadata"
  value {
    s: "\n\024TensorSliceDataset:0"
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 28
        }
        dim {
          size: 28
        }
        dim {
          size: 1
        }
      }
      shape {
      }
    }
  }
}
experimental_type {
  type_id: TFT_PRODUCT
  args {
    type_id: TFT_DATASET
    args {
      type_id: TFT_PRODUCT
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_FLOAT
        }
      }
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_UINT8
        }
      }
    }
  }
  args {
    type_id: TFT_DATASET
    args {
      type_id: TFT_PRODUCT
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_FLOAT
        }
      }
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_UINT8
        }
      }
    }
  }
}

2022-01-26 05:45:54.034762: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:776] AUTO sharding policy will apply DATA sharding policy as it failed to apply FILE sharding policy because of the following reason: Found an unshardable source dataset: name: "TensorSliceDataset/_2"
op: "TensorSliceDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_UINT8
    }
  }
}
attr {
  key: "_cardinality"
  value {
    i: 10000
  }
}
attr {
  key: "is_files"
  value {
    b: false
  }
}
attr {
  key: "metadata"
  value {
    s: "\n\024TensorSliceDataset:3"
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 28
        }
        dim {
          size: 28
        }
        dim {
          size: 1
        }
      }
      shape {
      }
    }
  }
}
experimental_type {
  type_id: TFT_PRODUCT
  args {
    type_id: TFT_DATASET
    args {
      type_id: TFT_PRODUCT
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_FLOAT
        }
      }
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_UINT8
        }
      }
    }
  }
  args {
    type_id: TFT_DATASET
    args {
      type_id: TFT_PRODUCT
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_FLOAT
        }
      }
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_UINT8
        }
      }
    }
  }
}

modeli oluştur

tf.keras.Sequential kullanarak bir model oluşturun. Bunu yapmak için Model Alt Sınıflandırma API'sini de kullanabilirsiniz.

def create_model():
  model = tf.keras.Sequential([
      tf.keras.layers.Conv2D(32, 3, activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Conv2D(64, 3, activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Flatten(),
      tf.keras.layers.Dense(64, activation='relu'),
      tf.keras.layers.Dense(10)
    ])

  return model
tutucu11 l10n-yer
# Create a checkpoint directory to store the checkpoints.
checkpoint_dir = './training_checkpoints'
checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")

Kayıp fonksiyonunu tanımlayın

Normalde, 1 GPU/CPU'lu tek bir makinede kayıp, girdi grubundaki örnek sayısına bölünür.

Peki, bir tf.distribute.Strategy kullanırken kayıp nasıl hesaplanmalıdır?

  • Örnek olarak, 4 GPU'nuz ve 64'lük bir toplu iş boyutunuz olduğunu varsayalım. Bir toplu girdi, çoğaltmalara (4 GPU) dağıtılır ve her çoğaltma, 16 boyutunda bir girdi alır.

  • Her kopyadaki model, ilgili girdisiyle ileriye doğru bir geçiş yapar ve kaybı hesaplar. Şimdi, kaybı ilgili girişindeki örnek sayısına bölmek yerine (BATCH_SIZE_PER_REPLICA = 16), kayıp GLOBAL_BATCH_SIZE'a (64) bölünmelidir.

Bunu neden yap?

  • Bunun yapılması gerekir, çünkü her replikadaki degradeler hesaplandıktan sonra, bunlar toplanarak replikalar arasında eşitlenir.

Bunu TensorFlow'da nasıl yapabilirim?

  • Bu öğreticide olduğu gibi özel bir eğitim döngüsü yazıyorsanız, örnek başına kayıpları toplamalı ve toplamı GLOBAL_BATCH_SIZE'a bölmelisiniz: scale_loss = tf.reduce_sum(loss) * (1. / GLOBAL_BATCH_SIZE) veya tf.nn.compute_average_loss kullanabilirsiniz Örnek başına kaybı, isteğe bağlı örnek ağırlıklarını ve tf.nn.compute_average_loss bağımsız değişken olarak alan ve ölçeklenmiş kaybı döndüren .nn.compute_average_loss.

  • Modelinizde düzenlileştirme kayıpları kullanıyorsanız, kayıp değerini kopya sayısına göre ölçeklendirmeniz gerekir. Bunu tf.nn.scale_regularization_loss işlevini kullanarak yapabilirsiniz.

  • tf.reduce_mean kullanılması önerilmez. Bunu yapmak, kaybı, adım adım değişebilen gerçek kopya başına toplu iş boyutuna böler.

  • Bu küçültme ve ölçekleme, keras model.compile ve model.fit otomatik olarak yapılır.

  • tf.keras.losses sınıfları kullanılıyorsa (aşağıdaki örnekte olduğu gibi), kayıp azaltmanın açıkça NONE veya SUM olarak belirtilmesi gerekir. tf.distribute.Strategy ile kullanıldığında AUTO ve SUM_OVER_BATCH_SIZE izin tf.distribute.Strategy . AUTO izin verilmez, çünkü kullanıcının dağıtılmış durumda doğru olduğundan emin olmak için hangi azaltmayı istediğini açıkça düşünmesi gerekir. SUM_OVER_BATCH_SIZE şu anda yalnızca kopya parti boyutuna göre bölüneceği ve kopya sayısına göre bölmeyi kullanıcıya bırakacağı için izin verilmemektedir, bu da gözden kaçırılması kolay olabilir. Bunun yerine kullanıcıdan indirgemeyi açıkça yapmasını istiyoruz.

  • labels çok boyutluysa, her örnekteki öğe sayısı boyunca per_example_loss ortalamasını alın. Örneğin, predictions şekli (batch_size, H, W, n_classes) ve labels (batch_size, H, W) ise, per_example_loss şekilde güncellemeniz gerekir: per_example_loss /= tf.cast(tf.reduce_prod(tf.shape(labels)[1:]), tf.float32)

with strategy.scope():
  # Set reduction to `none` so we can do the reduction afterwards and divide by
  # global batch size.
  loss_object = tf.keras.losses.SparseCategoricalCrossentropy(
      from_logits=True,
      reduction=tf.keras.losses.Reduction.NONE)
  def compute_loss(labels, predictions):
    per_example_loss = loss_object(labels, predictions)
    return tf.nn.compute_average_loss(per_example_loss, global_batch_size=GLOBAL_BATCH_SIZE)

Kaybı ve doğruluğu izlemek için metrikleri tanımlayın

Bu metrikler, test kaybını, eğitimi ve test doğruluğunu izler. Birikmiş istatistikleri istediğiniz zaman almak için .result() 'u kullanabilirsiniz.

with strategy.scope():
  test_loss = tf.keras.metrics.Mean(name='test_loss')

  train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
      name='train_accuracy')
  test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
      name='test_accuracy')
tutucu14 l10n-yer
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).

Eğitim döngüsü

# model, optimizer, and checkpoint must be created under `strategy.scope`.
with strategy.scope():
  model = create_model()

  optimizer = tf.keras.optimizers.Adam()

  checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=model)

def train_step(inputs):
  images, labels = inputs

  with tf.GradientTape() as tape:
    predictions = model(images, training=True)
    loss = compute_loss(labels, predictions)

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

  train_accuracy.update_state(labels, predictions)
  return loss 

def test_step(inputs):
  images, labels = inputs

  predictions = model(images, training=False)
  t_loss = loss_object(labels, predictions)

  test_loss.update_state(t_loss)
  test_accuracy.update_state(labels, predictions)
yer tutucu17 l10n-yer
# `run` replicates the provided computation and runs it
# with the distributed input.
@tf.function
def distributed_train_step(dataset_inputs):
  per_replica_losses = strategy.run(train_step, args=(dataset_inputs,))
  return strategy.reduce(tf.distribute.ReduceOp.SUM, per_replica_losses,
                         axis=None)

@tf.function
def distributed_test_step(dataset_inputs):
  return strategy.run(test_step, args=(dataset_inputs,))

for epoch in range(EPOCHS):
  # TRAIN LOOP
  total_loss = 0.0
  num_batches = 0
  for x in train_dist_dataset:
    total_loss += distributed_train_step(x)
    num_batches += 1
  train_loss = total_loss / num_batches

  # TEST LOOP
  for x in test_dist_dataset:
    distributed_test_step(x)

  if epoch % 2 == 0:
    checkpoint.save(checkpoint_prefix)

  template = ("Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, "
              "Test Accuracy: {}")
  print (template.format(epoch+1, train_loss,
                         train_accuracy.result()*100, test_loss.result(),
                         test_accuracy.result()*100))

  test_loss.reset_states()
  train_accuracy.reset_states()
  test_accuracy.reset_states()

Epoch 1, Loss: 0.5106383562088013, Accuracy: 81.77999877929688, Test Loss: 0.39399346709251404, Test Accuracy: 85.79000091552734
Epoch 2, Loss: 0.3362727463245392, Accuracy: 87.91333770751953, Test Loss: 0.35871225595474243, Test Accuracy: 86.7699966430664
Epoch 3, Loss: 0.2928692400455475, Accuracy: 89.2683334350586, Test Loss: 0.2999486029148102, Test Accuracy: 89.04000091552734
Epoch 4, Loss: 0.2605818510055542, Accuracy: 90.41999816894531, Test Loss: 0.28474125266075134, Test Accuracy: 89.47000122070312
Epoch 5, Loss: 0.23641237616539001, Accuracy: 91.32166290283203, Test Loss: 0.26421546936035156, Test Accuracy: 90.41000366210938
Epoch 6, Loss: 0.2192477434873581, Accuracy: 91.90499877929688, Test Loss: 0.2650589942932129, Test Accuracy: 90.4800033569336
Epoch 7, Loss: 0.20016911625862122, Accuracy: 92.66999816894531, Test Loss: 0.25025954842567444, Test Accuracy: 90.9000015258789
Epoch 8, Loss: 0.18381091952323914, Accuracy: 93.26499938964844, Test Loss: 0.2585820257663727, Test Accuracy: 90.95999908447266
Epoch 9, Loss: 0.1699329912662506, Accuracy: 93.67500305175781, Test Loss: 0.26234227418899536, Test Accuracy: 91.0199966430664
Epoch 10, Loss: 0.15756534039974213, Accuracy: 94.16333770751953, Test Loss: 0.25516414642333984, Test Accuracy: 90.93000030517578

Yukarıdaki örnekte dikkat edilmesi gerekenler:

En son kontrol noktasını geri yükleyin ve test edin

tf.distribute.Strategy ile kontrol noktası olan bir model, stratejili veya stratejisiz olarak geri yüklenebilir.

eval_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
      name='eval_accuracy')

new_model = create_model()
new_optimizer = tf.keras.optimizers.Adam()

test_dataset = tf.data.Dataset.from_tensor_slices((test_images, test_labels)).batch(GLOBAL_BATCH_SIZE)

@tf.function
def eval_step(images, labels):
  predictions = new_model(images, training=False)
  eval_accuracy(labels, predictions)
yer tutucu21 l10n-yer
checkpoint = tf.train.Checkpoint(optimizer=new_optimizer, model=new_model)
checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))

for images, labels in test_dataset:
  eval_step(images, labels)

print ('Accuracy after restoring the saved model without strategy: {}'.format(
    eval_accuracy.result()*100))

Accuracy after restoring the saved model without strategy: 91.0199966430664

Bir veri kümesi üzerinde yineleme yapmanın alternatif yolları

Yineleyicileri kullanma

Tüm veri kümesi boyunca değil, belirli bir sayıda adım üzerinde yineleme yapmak istiyorsanız, yineleyicide next iter çağrısını ve açık çağrıyı kullanarak bir yineleyici oluşturabilirsiniz. tf.function içinde ve dışında veri kümesi üzerinde yineleme yapmayı seçebilirsiniz. İşte bir yineleyici kullanarak tf.function dışında veri kümesinin yinelemesini gösteren küçük bir pasaj.

for _ in range(EPOCHS):
  total_loss = 0.0
  num_batches = 0
  train_iter = iter(train_dist_dataset)

  for _ in range(10):
    total_loss += distributed_train_step(next(train_iter))
    num_batches += 1
  average_train_loss = total_loss / num_batches

  template = ("Epoch {}, Loss: {}, Accuracy: {}")
  print (template.format(epoch+1, average_train_loss, train_accuracy.result()*100))
  train_accuracy.reset_states()
tutucu24 l10n-yer
Epoch 10, Loss: 0.17486707866191864, Accuracy: 93.4375
Epoch 10, Loss: 0.12386945635080338, Accuracy: 95.3125
Epoch 10, Loss: 0.16411852836608887, Accuracy: 93.90625
Epoch 10, Loss: 0.10728752613067627, Accuracy: 96.40625
Epoch 10, Loss: 0.11865834891796112, Accuracy: 95.625
Epoch 10, Loss: 0.12875251471996307, Accuracy: 95.15625
Epoch 10, Loss: 0.1189488023519516, Accuracy: 95.625
Epoch 10, Loss: 0.1456708014011383, Accuracy: 95.15625
Epoch 10, Loss: 0.12446556240320206, Accuracy: 95.3125
Epoch 10, Loss: 0.1380888819694519, Accuracy: 95.46875

Bir tf.function içinde yineleme

Ayrıca, for x in ... yapısını kullanarak veya yukarıda yaptığımız gibi yineleyiciler oluşturarak bir train_dist_dataset içindeki bütün train_dist_dataset girdisini yineleyebilirsiniz. Aşağıdaki örnek, bir eğitim dönemini bir tf.function içine sarmayı ve işlevin içinde train_dist_dataset üzerinde yinelemeyi gösterir.

@tf.function
def distributed_train_epoch(dataset):
  total_loss = 0.0
  num_batches = 0
  for x in dataset:
    per_replica_losses = strategy.run(train_step, args=(x,))
    total_loss += strategy.reduce(
      tf.distribute.ReduceOp.SUM, per_replica_losses, axis=None)
    num_batches += 1
  return total_loss / tf.cast(num_batches, dtype=tf.float32)

for epoch in range(EPOCHS):
  train_loss = distributed_train_epoch(train_dist_dataset)

  template = ("Epoch {}, Loss: {}, Accuracy: {}")
  print (template.format(epoch+1, train_loss, train_accuracy.result()*100))

  train_accuracy.reset_states()
tutucu26 l10n-yer
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/data/ops/dataset_ops.py:449: UserWarning: To make it possible to preserve tf.data options across serialization boundaries, their implementation has moved to be part of the TensorFlow graph. As a consequence, the options value is in general no longer known at graph construction time. Invoking this method in graph mode retains the legacy behavior of the original implementation, but note that the returned value might not reflect the actual value of the options.
  warnings.warn("To make it possible to preserve tf.data options across "
Epoch 1, Loss: 0.14398494362831116, Accuracy: 94.63999938964844
Epoch 2, Loss: 0.13246288895606995, Accuracy: 94.97333526611328
Epoch 3, Loss: 0.11922841519117355, Accuracy: 95.63833618164062
Epoch 4, Loss: 0.11084160208702087, Accuracy: 95.99333190917969
Epoch 5, Loss: 0.10420522093772888, Accuracy: 96.0816650390625
Epoch 6, Loss: 0.09215126931667328, Accuracy: 96.63500213623047
Epoch 7, Loss: 0.0878651961684227, Accuracy: 96.67666625976562
Epoch 8, Loss: 0.07854588329792023, Accuracy: 97.09333038330078
Epoch 9, Loss: 0.07217177003622055, Accuracy: 97.34833526611328
Epoch 10, Loss: 0.06753655523061752, Accuracy: 97.48999786376953

Replikalar arasında eğitim kaybını izleme

Gerçekleştirilen kayıp ölçeklendirme hesaplaması nedeniyle, farklı kopyalarda eğitim kaybını izlemek için tf.metrics.Mean kullanılmasını önermiyoruz .

Örneğin, aşağıdaki özelliklere sahip bir eğitim işi yürütürseniz:

  • iki kopya
  • Her kopyada iki numune işlenir
  • Ortaya çıkan kayıp değerleri: [2, 3] ve [4, 5] her replikada
  • Genel parti boyutu = 4

Kayıp ölçekleme ile, kayıp değerlerini toplayarak ve ardından genel parti boyutuna bölerek her bir replikadaki kaybın örnek başına değerini hesaplarsınız. Bu durumda: (2 + 3) / 4 = 1.25 ve (4 + 5) / 4 = 2.25 .

İki replikadaki kaybı izlemek için tf.metrics.Mean kullanırsanız, sonuç farklıdır. Bu örnekte, total 3,50 ve 2 count elde edersiniz, bu da metrikte result() çağrıldığında total / count = 1,75 ile sonuçlanır. tf.keras.Metrics ile hesaplanan kayıp, eşitlemedeki kopya sayısına eşit olan ek bir faktörle ölçeklenir.

Kılavuz ve örnekler

Özel eğitim döngüleriyle dağıtım stratejisini kullanmaya ilişkin bazı örnekler:

  1. Dağıtılmış eğitim kılavuzu
  2. MirroredStrategy kullanan DenseNet örneği.
  3. MirroredStrategy ve TPUStrategy kullanılarak eğitilmiş BERT örneği. Bu örnek, dağıtılmış eğitim vb. sırasında bir kontrol noktasından nasıl yükleneceğini ve periyodik kontrol noktalarının nasıl oluşturulacağını anlamak için özellikle yararlıdır.
  4. keras_use_ctl bayrağı kullanılarak etkinleştirilebilen MirroredStrategy kullanılarak eğitilmiş NCF örneği.
  5. MirroredStrategy kullanılarak eğitilmiş NMT örneği.

Dağıtım stratejisi kılavuzunda listelenen daha fazla örnek.

Sonraki adımlar

  • Modellerinizde yeni tf.distribute.Strategy API'sini deneyin.
  • TensorFlow modellerinizin performansını optimize etmek için kullanabileceğiniz diğer stratejiler ve araçlar hakkında daha fazla bilgi edinmek için kılavuzdaki Performans bölümünü ziyaret edin.