Bu sayfa, Cloud Translation API ile çevrilmiştir.
Switch to English

Keras ile çok çalışanlı eğitim

TensorFlow.org üzerinde görüntüle Google Colab'da yayınla Kaynağı GitHub'da görüntüle Not defterini indir

genel bakış

Bu öğretici, tf.distribute.Strategy API'sini, özellikle tf.distribute.experimental.MultiWorkerMirroredStrategy kullanarak tf.distribute.Strategy modeliyle çok çalışanlı dağıtılmış eğitimi tf.distribute.experimental.MultiWorkerMirroredStrategy . Bu stratejinin yardımıyla, tek işçi üzerinde çalışmak üzere tasarlanmış bir Keras modeli, minimum kod değişikliği ile birden fazla işçi üzerinde sorunsuz bir şekilde çalışabilir.

TensorFlow'da Dağıtılmış Eğitim kılavuzu, tf.distribute.Strategy API'lerini daha iyi anlamak isteyenler için desteklediği dağıtım stratejilerine genel bir bakış için hazırlanmıştır.

Kurmak

İlk olarak, TensorFlow'u ve gerekli ithalatı ayarlayın.

 import os
import tensorflow as tf
import numpy as np
 

Veri seti hazırlanıyor

Şimdi MNIST veri kümesini hazırlayalım. MNIST veri kümesi 60.000 eğitim örneği ve 0x9 arası elle yazılmış rakamların 28x28 piksel tek renkli görüntüler olarak biçimlendirilmiş 10.000 test örneğinden oluşur. Bu örnekte, göstermek için veri kümelerinin eğitim bölümünü ele alacağız.

 def mnist_dataset(batch_size):
  (x_train, y_train), _ = tf.keras.datasets.mnist.load_data()
  # The `x` arrays are in uint8 and have values in the range [0, 255].
  # We need to convert them to float32 with values in the range [0, 1]
  x_train = x_train / np.float32(255)
  y_train = y_train.astype(np.int64)
  train_dataset = tf.data.Dataset.from_tensor_slices(
      (x_train, y_train)).shuffle(60000).repeat().batch(batch_size)
  return train_dataset
 

Keras modelini oluşturun

Burada basit bir tf.keras.Sequential sinir ağları Keras modeli oluşturmak ve derlemek için tf.keras.Sequential API kullanın.

 def build_and_compile_cnn_model():
  model = tf.keras.Sequential([
      tf.keras.Input(shape=(28, 28)),
      tf.keras.layers.Reshape(target_shape=(28, 28, 1)),
      tf.keras.layers.Conv2D(32, 3, activation='relu'),
      tf.keras.layers.Flatten(),
      tf.keras.layers.Dense(128, activation='relu'),
      tf.keras.layers.Dense(10)
  ])
  model.compile(
      loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
      optimizer=tf.keras.optimizers.SGD(learning_rate=0.001),
      metrics=['accuracy'])
  return model
 

Önce az sayıda dönem için modeli eğitmeye çalışalım ve her şeyin doğru çalıştığından emin olmak için sonuçları tek bir işçide gözlemleyelim. Dönem ilerledikçe kayıp düşüşü ve 1.0'a yaklaşan doğruluk görmeyi beklemelisiniz.

 per_worker_batch_size = 64
single_worker_dataset = mnist_dataset(per_worker_batch_size)
single_worker_model = build_and_compile_cnn_model()
single_worker_model.fit(single_worker_dataset, epochs=3, steps_per_epoch=70)
 
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
Epoch 1/3
70/70 [==============================] - 0s 2ms/step - loss: 2.2701 - accuracy: 0.2451
Epoch 2/3
70/70 [==============================] - 0s 2ms/step - loss: 2.1827 - accuracy: 0.4777
Epoch 3/3
70/70 [==============================] - 0s 2ms/step - loss: 2.0865 - accuracy: 0.5955

<tensorflow.python.keras.callbacks.History at 0x7fc59381ac50>

Çok Çalışanlı Yapılandırma

Şimdi çok çalışanlı eğitim dünyasına girelim. TensorFlow'da, TF_CONFIG ortam değişkeni, her biri muhtemelen farklı bir role sahip olan birden fazla makinede eğitim için gereklidir. TF_CONFIG , kümenin bir parçası olan her çalışanda küme yapılandırmasını belirtmek için kullanılan bir JSON dizesidir.

TF_CONFIG iki bileşeni vardır: cluster ve task . cluster , worker gibi farklı iş türlerinden oluşan bir diksiyon olan eğitim cluster hakkında bilgi sağlar. MultiWorkerMirroredStrategy ile çok çalışanlı eğitimde, normal bir worker yaptıklarının yanı sıra TensorBoard için kontrol noktasını kaydetme ve özet dosyası yazma gibi biraz daha fazla sorumluluk alan bir worker vardır. Böyle işçisi olarak adlandırılır chief işçisi, ve gelenektir worker ile index 0 baş olarak atandı worker (aslında bu nasıl tf.distribute.Strategy uygulanmaktadır). task diğer taraftan cari görevin bilgi sağlar. İlk bileşen cluster tüm çalışanlar için aynıdır ve ikinci bileşen task her çalışanda farklıdır ve o çalışanın type ve index belirtir.

Bu örnekte, görev type "worker" ve görev index 0 ayarladık. Bu, böyle bir ayara sahip olan makinenin, baş işçi olarak atanacak ve diğer işçilerden daha fazla iş yapacak olan ilk işçi olduğu anlamına gelir. Diğer makinelerin de TF_CONFIG ortam değişkeninin ayarlanmış olması gerektiğini ve bu makinelerin rollerinin ne olduğuna bağlı olarak aynı cluster diksiyonuna, ancak farklı görev type veya görev index sahip olması gerektiğini unutmayın.

Örnekleme amacıyla, bu eğitici, bir TF_CONFIG localhost üzerinde 2 işçi ile nasıl TF_CONFIG ayarlayabileceğini gösterir. Uygulamada, kullanıcılar harici IP adreslerinde / bağlantı noktalarında birden çok işçi oluşturacak ve her bir işçi için uygun şekilde TF_CONFIG ayarlayacaktır.

 os.environ['TF_CONFIG'] = json.dumps({
    'cluster': {
        'worker': ["localhost:12345", "localhost:23456"]
    },
    'task': {'type': 'worker', 'index': 0}
})
 

Bu örnekte öğrenme oranı sabit olmasına rağmen, genel olarak öğrenme hızının küresel parti boyutuna göre ayarlanması gerekebileceğini unutmayın.

Doğru stratejiyi seçin

TensorFlow'da, dağıtılmış eğitim, eğitim adımlarının çalışanlar ve kopyalar arasında senkronize edildiği senkronize eğitimden ve eğitim adımlarının tam olarak senkronize edilmediği asenkron eğitimden oluşur.

Eşzamanlı çok çalışanlı eğitim için önerilen strateji olan MultiWorkerMirroredStrategy bu kılavuzda gösterilecektir. Modeli eğitmek için bir tf.distribute.experimental.MultiWorkerMirroredStrategy örneğini kullanın. MultiWorkerMirroredStrategy , tüm çalışanlarda modelin katmanlarındaki tüm değişkenlerin her aygıtta kopyalarını oluşturur. Degradeleri toplamak ve değişkenleri senkronize tutmak için toplu iletişim için bir TensorFlow op olan CollectiveOps kullanır. tf.distribute.Strategy rehberinde bu strateji hakkında daha ayrıntılı bilgi yer almaktadır.

 strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()
 
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
INFO:tensorflow:Using MirroredStrategy with devices ('/device:GPU:0',)
INFO:tensorflow:Single-worker MultiWorkerMirroredStrategy with local_devices = ('/device:GPU:0',), communication = CollectiveCommunication.AUTO

MultiWorkerMirroredStrategy , CollectiveCommunication parametresi aracılığıyla birden fazla uygulama sağlar. RING , çapraz konak iletişim katmanı olarak gRPC kullanarak halka tabanlı kolektifler uygular. NCCL kolektifleri uygulamak için Nvidia'nın NCCL kullanır. AUTO , seçimi çalışma zamanına göre tanımlar. En iyi toplu uygulama seçimi GPU'ların sayısına ve türüne ve kümedeki ağ bağlantısına bağlıdır.

MultiWorkerMirroredStrategy ile modeli eğitin

tf.distribute.Strategy API'sini tf.distribute.Strategy entegre tf.keras , eğitimi çok çalışana dağıtmak için yapacağınız tek değişiklik, model oluşturma ve model.compile() çağrısını strategy.scope() içine model.compile() . Dağıtım stratejisinin kapsamı, değişkenlerin nasıl ve nerede oluşturulduğunu belirler ve MultiWorkerMirroredStrategy durumunda, oluşturulan değişkenler MirroredVariable s'dir ve her bir işçiye çoğaltılır.

 num_workers = 4

# Here the batch size scales up by number of workers since 
# `tf.data.Dataset.batch` expects the global batch size. Previously we used 64, 
# and now this becomes 128.
global_batch_size = per_worker_batch_size * num_workers
multi_worker_dataset = mnist_dataset(global_batch_size)

with strategy.scope():
  # Model building/compiling need to be within `strategy.scope()`.
  multi_worker_model = build_and_compile_cnn_model()

# Keras' `model.fit()` trains the model with specified number of epochs and
# number of steps per epoch. Note that the numbers here are for demonstration
# purposes only and may not sufficiently produce a model with good quality.
multi_worker_model.fit(multi_worker_dataset, epochs=3, steps_per_epoch=70)
 
Epoch 1/3
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/data/ops/multi_device_iterator_ops.py:601: get_next_as_optional (from tensorflow.python.data.ops.iterator_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.data.Iterator.get_next_as_optional()` instead.
70/70 [==============================] - 0s 3ms/step - loss: 2.2682 - accuracy: 0.2265
Epoch 2/3
70/70 [==============================] - 0s 3ms/step - loss: 2.1714 - accuracy: 0.4954
Epoch 3/3
70/70 [==============================] - 0s 3ms/step - loss: 2.0638 - accuracy: 0.6232

<tensorflow.python.keras.callbacks.History at 0x7fc5f4f062e8>

Veri kümesi parçalama ve toplu iş boyutu

MultiWorkerMirroredStrategy ile çok çalışanlı eğitimde, yakınsama ve performansı sağlamak için veri kümesini parçalamak gerekir. Ancak, yukarıdaki kod snippet'inde veri kümelerinin, model.fit() gerek kalmadan doğrudan model.fit() e model.fit() ; Bunun nedeni, tf.distribute.Strategy API'sinin veri kümesinin parçalanmasını otomatik olarak halletmesidir. Veri kümesini eğri parçalara neden olabilecek dosya düzeyinde kırpar. Yalnızca tek bir dosyanın olduğu uç durumlarda, yalnızca ilk parça (yani işçi) eğitim veya değerlendirme verilerini alacak ve sonuç olarak tüm çalışanlar hata alacaktır.

Eğitiminiz için manuel parçalamayı tercih ederseniz, otomatik parçalama tf.data.experimental.DistributeOptions api aracılığıyla tf.data.experimental.DistributeOptions . somut olarak,

 options = tf.data.Options()
options.experimental_distribute.auto_shard_policy = tf.data.experimental.AutoShardPolicy.OFF
dataset_no_auto_shard = multi_worker_dataset.with_options(options)
 

Dikkat edilmesi gereken başka bir şey, datasets toplu boyutudur. Kodda kullandığımız, yukarıda pasajı global_batch_size = per_worker_batch_size * num_workers , olan num_workers küresel parti boyutu (geçirilen parametredir çalışan seri boyutuna başına etkin, bunun nedeni, tek işçi için olduğu durumda kadar büyük kez tf.data.Dataset.batch() ), çalışan sayısına bölünür ve bu değişiklikle, çalışan başına toplu iş boyutunu daha önce olduğu gibi tf.data.Dataset.batch() .

Değerlendirme

validation_data model.fit , her çağ için eğitim ve değerlendirme arasında geçiş yapılır. validation_data alan değerlendirme aynı çalışanlar arasında dağıtılır ve değerlendirme sonuçları toplanır ve tüm çalışanlar için kullanılabilir. Eğitime benzer şekilde, doğrulama veri kümesi otomatik olarak dosya düzeyinde kırılır. Doğrulama veri kümesinde genel bir toplu iş boyutu ayarlamanız ve validation_steps ayarlamanız gerekir. Değerlendirme için tekrarlanan bir veri kümesi de önerilir.

Alternatif olarak, kontrol noktalarını periyodik olarak okuyan ve değerlendirmeyi çalıştıran başka bir görev de oluşturabilirsiniz. Tahmincisi bunu yapar. Ancak bu değerlendirme yapmak için önerilen bir yol değildir ve bu nedenle detayları atlanmıştır.

tahmin

Şu anda model.predict ile MultiWorkerMirroredStrategy.

Verim

Artık MultiWorkerMirroredStrategy ile birden fazla MultiWorkerMirroredStrategy çalışacak şekilde ayarlanmış bir MultiWorkerMirroredStrategy . MultiWorkerMirroredStrategy ile çok çalışanlı eğitimin performansını değiştirmek için aşağıdaki teknikleri deneyebilirsiniz.

  • MultiWorkerMirroredStrategy çoklu toplu iletişim uygulamaları sağlar . RING , çapraz konak iletişim katmanı olarak gRPC kullanarak halka tabanlı kolektifler uygular. NCCL kolektifleri uygulamak için Nvidia'nın NCCL kullanır. AUTO , seçimi çalışma zamanına göre tanımlar. En iyi toplu uygulama seçimi GPU'ların sayısına ve türüne ve kümedeki ağ bağlantısına bağlıdır. Otomatik seçimi geçersiz kılmak için MultiWorkerMirroredStrategy communication parametresine geçerli bir değer belirtin, örn. communication=tf.distribute.experimental.CollectiveCommunication.NCCL .
  • Değişkenleri mümkünse tf.float . Resmi ResNet modeli bunun nasıl yapılabileceğine dair bir örnek içermektedir.

Arıza toleransı

Eşzamanlı eğitimde, işçilerden biri başarısız olursa ve hiçbir arıza kurtarma mekanizması yoksa küme başarısız olur. tf.distribute.Strategy ile kullanmak, işçilerin öldüğü veya dengesiz olduğu durumlarda hata toleransı avantajıyla birlikte gelir. Bunu, tercih edilen dağıtılmış dosya sistemindeki eğitim durumunu koruyarak yaparız, böylece daha önce başarısız olan veya önlenen örneğin yeniden başlatılması üzerine eğitim durumu kurtarılır.

Tüm çalışanlar eğitim çağları ve adımları açısından senkronize tutulduğundan, diğer çalışanların başarısız veya ön ödemeli işçinin devam etmesi için yeniden başlamasını beklemesi gerekecektir.

ModelCheckpoint geri arama

ModelCheckpoint geri ModelCheckpoint artık hata toleransı işlevi BackupAndRestore , lütfen bunun yerine BackupAndRestore geri BackupAndRestore kullanın.

ModelCheckpoint geri ModelCheckpoint yine de kontrol noktalarını kaydetmek için kullanılabilir. Ancak bununla birlikte, eğitim kesilirse veya başarıyla tamamlanırsa, kontrol noktasından eğitime devam etmek için kullanıcı modeli manuel olarak yüklemekle sorumludur. İsteğe bağlı olarak kullanıcı, ModelCheckpoint geri ModelCheckpoint dışındaki model / ağırlıkları kaydetmeyi ve geri yüklemeyi seçebilir.

Model tasarrufu ve yükleme

Modelinizi model.save veya tf.saved_model.save kullanarak kaydetmek için, kaydetme hedefinin her çalışan için farklı olması gerekir. Şef olmayan çalışanlarda, modeli geçici bir dizine kaydetmeniz ve şefin sağlanan model dizinine kaydetmeniz gerekir. Aynı konuma yazmaya çalışan birden çok çalışanın neden olduğu hataları önlemek için, çalışandaki geçici dizinlerin benzersiz olması gerekir. Tüm dizinlere kaydedilen modele özdeştir ve tipik olarak sadece şef tarafından kaydedilen modele geri yükleme veya sunum için referans verilmelidir. Eğitiminiz tamamlandıktan sonra çalışanlar tarafından oluşturulan geçici dizinleri silen bazı temizleme mantığınız olmasını öneririz.

Şef ve işçilerden aynı anda tasarruf etmenizin nedeni, kontrol noktası sırasında hem şefin hem de çalışanların allreduce iletişim protokolüne katılmasını gerektiren değişkenleri toplayabilmenizdir. Öte yandan, şefin ve çalışanların aynı model dizinine kaydetmelerine izin vermek, çekişme nedeniyle hatalara neden olacaktır.

MultiWorkerMirroredStrategy ile program her çalışanda çalıştırılır ve mevcut çalışanın baş olup olmadığını bilmek için task_type ve task_id özniteliklerine sahip küme çözümleyici nesneden task_id . task_type size geçerli işin ne olduğunu söyler (örneğin 'işçi') ve task_id size işçinin tanımlayıcısını söyler. 0 kimliğine sahip işçi baş işçi olarak atanır.

Aşağıdaki kod snippet'inde write_filepath , çalışan kimliğine bağlı olarak yazmak için dosya yolunu sağlar. Şef (0 kimliğine sahip işçi) durumunda, orijinal dosya yoluna yazar; diğerleri için yazmak için geçici bir dizin oluşturur (dizin yolunda id ile):

 model_path = '/tmp/keras-model'

def _is_chief(task_type, task_id):
  # If `task_type` is None, this may be operating as single worker, which works 
  # effectively as chief.
  return task_type is None or task_type == 'chief' or (
            task_type == 'worker' and task_id == 0)

def _get_temp_dir(dirpath, task_id):
  base_dirpath = 'workertemp_' + str(task_id)
  temp_dir = os.path.join(dirpath, base_dirpath)
  tf.io.gfile.makedirs(temp_dir)
  return temp_dir

def write_filepath(filepath, task_type, task_id):
  dirpath = os.path.dirname(filepath)
  base = os.path.basename(filepath)
  if not _is_chief(task_type, task_id):
    dirpath = _get_temp_dir(dirpath, task_id)
  return os.path.join(dirpath, base)

task_type, task_id = (strategy.cluster_resolver.task_type,
                      strategy.cluster_resolver.task_id)
write_model_path = write_filepath(model_path, task_type, task_id)
 

Bununla artık kaydetmeye hazırsınız:

 multi_worker_model.save(write_model_path)
 
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: /tmp/keras-model/assets

Yukarıda açıkladığımız gibi, daha sonra model sadece kaydedilen yol şefinden yüklenmelidir, bu yüzden şef olmayan işçilerin kurtardığı geçici olanları kaldıralım:

 if not _is_chief(task_type, task_id):
  tf.io.gfile.rmtree(os.path.dirname(write_model_path))
 

Şimdi, yükleme zamanı geldiğinde, uygun tf.keras.models.load_model API'sini tf.keras.models.load_model ve daha fazla çalışmaya devam edelim. Burada, eğitimi yüklemek ve devam ettirmek için sadece tek bir çalışan kullandığımızı varsayıyoruz, bu durumda başka bir strategy.scope() içinde tf.keras.models.load_model .

 loaded_model = tf.keras.models.load_model(model_path)

# Now that we have the model restored, and can continue with the training.
loaded_model.fit(single_worker_dataset, epochs=2, steps_per_epoch=20)
 
Epoch 1/2
20/20 [==============================] - 0s 2ms/step - loss: 1.9825 - accuracy: 0.1102
Epoch 2/2
20/20 [==============================] - 0s 2ms/step - loss: 1.9367 - accuracy: 0.1117

<tensorflow.python.keras.callbacks.History at 0x7fc5f4b0d8d0>

Denetim noktası kaydetme ve geri yükleme

Öte yandan, kontrol noktası, modelin ağırlıklarını kaydetmenize ve tüm modeli kaydetmek zorunda kalmadan geri yüklemenize olanak tanır. Burada, yalnızca en son kontrol noktasının korunması için bir tf.train.CheckpointManager tarafından yönetilen modeli izleyen bir tf.train.Checkpoint oluşturacaksınız.

 checkpoint_dir = '/tmp/ckpt'

checkpoint = tf.train.Checkpoint(model=multi_worker_model)
write_checkpoint_dir = write_filepath(checkpoint_dir, task_type, task_id)
checkpoint_manager = tf.train.CheckpointManager(
  checkpoint, directory=write_checkpoint_dir, max_to_keep=1)
 

CheckpointManager kurulduktan sonra artık kaydetmeye ve baş işçilerin kaydetmediği kontrol noktalarını kaldırmaya hazırsınız.

 checkpoint_manager.save()
if not _is_chief(task_type, task_id):
  tf.io.gfile.rmtree(write_checkpoint_dir)
 

Şimdi, geri yüklemeniz gerektiğinde, uygun tf.train.latest_checkpoint işlevini kullanarak kaydedilen en son kontrol noktasını bulabilirsiniz. Kontrol noktasını geri yükledikten sonra eğitime devam edebilirsiniz.

 latest_checkpoint = tf.train.latest_checkpoint(checkpoint_dir)
checkpoint.restore(latest_checkpoint)
multi_worker_model.fit(multi_worker_dataset, epochs=2, steps_per_epoch=20)
 
Epoch 1/2
20/20 [==============================] - 0s 3ms/step - loss: 1.9841 - accuracy: 0.6561
Epoch 2/2
20/20 [==============================] - 0s 3ms/step - loss: 1.9445 - accuracy: 0.6805

<tensorflow.python.keras.callbacks.History at 0x7fc5f49d9d30>

BackupAndRestore geri arama

BackupAndRestore geri arama altında geçici bir denetim noktası dosyası model ve cari dönem numarasını yedekleyerek, hata toleransı işlevsellik sağlar backup_dir için argüman BackupAndRestore . Bu, her çağın sonunda yapılır.

İşler yarıda kesilip yeniden başlatıldığında, geri arama son kontrol noktasını geri yükler ve eğitim yarıda kesilen dönemin başından itibaren devam eder. Kesintiden önce bitmemiş dönemde yapılmış olan herhangi bir kısmi eğitim atılacaktır, böylece nihai model durumunu etkilemez.

Kullanmak için, bir örneğini temin tf.keras.callbacks.experimental.BackupAndRestore de tf.keras.Model.fit() çağrısı.

MultiWorkerMirroredStrategy ile, bir çalışan kesintiye uğrarsa, kesilen çalışan yeniden başlatılana kadar tüm küme duraklar. Diğer çalışanlar da yeniden başlatılacak ve kesintiye uğrayan işçi kümeye yeniden katılacak. Daha sonra, her çalışan önceden kaydedilmiş olan denetim noktası dosyasını okur ve eski durumunu alır, böylece kümenin eşitlenmesini sağlar. Sonra eğitim devam ediyor.

BackupAndRestore geri arama, mevcut kontrol noktalarını en son BackupAndRestore birlikte izleyen kontrol noktası adı verilen bir dosya oluşturan eğitim durumunu kaydetmek ve geri yüklemek için CheckpointManager kullanır. Bu nedenle, isim çakışmasını önlemek için backup_dir diğer kontrol noktalarını saklamak için tekrar kullanılmamalıdır.

Şu anda, BackupAndRestore geri arama stratejisi olmayan tek işçiyi, MirroredStrategy'yi ve MultiWorkerMirroredStrategy ile çok işçiyi desteklemektedir. Aşağıda hem çok çalışanlı eğitim hem de tek çalışanlı eğitim için iki örnek bulunmaktadır.

 # Multi-worker training with MultiWorkerMirroredStrategy.

callbacks = [tf.keras.callbacks.experimental.BackupAndRestore(backup_dir='/tmp/backup')]
with strategy.scope():
  multi_worker_model = build_and_compile_cnn_model()
multi_worker_model.fit(multi_worker_dataset,
                       epochs=3,
                       steps_per_epoch=70,
                       callbacks=callbacks)
 
Epoch 1/3
70/70 [==============================] - 0s 3ms/step - loss: 2.2837 - accuracy: 0.1836
Epoch 2/3
70/70 [==============================] - 0s 3ms/step - loss: 2.2131 - accuracy: 0.4091
Epoch 3/3
70/70 [==============================] - 0s 3ms/step - loss: 2.1310 - accuracy: 0.5485

<tensorflow.python.keras.callbacks.History at 0x7fc5f49a3080>

backup_dir belirttiğiniz backup_dir dizinini BackupAndRestore , geçici olarak oluşturulan bazı denetim noktası dosyalarını görebilirsiniz. Bu dosyalar daha önce kaybolan örnekleri kurtarmak için gereklidir ve eğitiminizden başarıyla çıktıktan sonra tf.keras.Model.fit() sonunda kütüphane tarafından kaldırılır.

Ayrıca bakınız

  1. TensorFlow kılavuzundaki Dağıtılmış Eğitim , mevcut dağıtım stratejilerine genel bir bakış sağlar.
  2. Birçoğu birden fazla dağıtım stratejisi yürütmek üzere yapılandırılabilen resmi modeller .
  3. Kılavuzdaki Performans bölümü , TensorFlow modellerinizin performansını optimize etmek için kullanabileceğiniz diğer stratejiler ve araçlar hakkında bilgi sağlar.