TensorFlow ile dağıtılmış 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

genel bakış

tf.distribute.Strategy birden GPU'ları, birden fazla makine veya TPU genelinde eğitim dağıtmak için bir TensorFlow API'sıdır. Bu API'yi kullanarak mevcut modellerinizi ve eğitim kodunuzu minimum kod değişikliği ile dağıtabilirsiniz.

tf.distribute.Strategy Akılda bu anahtar hedeflere dizayn edilmiştir:

  • Araştırmacılar, makine öğrenimi mühendisleri vb. dahil olmak üzere birden fazla kullanıcı segmentini kullanmak ve desteklemek kolaydır.
  • Kutunun dışında iyi performans sağlayın.
  • Stratejiler arasında kolay geçiş.

Sen kullanarak eğitim dağıtabilir tf.distribute.Strategy Keras gibi üst düzey bir API ile Model.fit yanı sıra özel eğitim döngüler (genel olarak TensorFlow kullanarak herhangi hesaplama ve).

TensorFlow 2.x, kullanmakta hevesle programlarınızı çalıştırmak ya da bir grafikte olabilir tf.function . tf.distribute.Strategy yürütme hem bu modları destekleyen istiyor ama en iyi şekilde çalışır tf.function . Hevesli modu sadece hata ayıklama amacıyla önerilir ve desteklenmez tf.distribute.TPUStrategy . Bu kılavuzun odak noktası eğitim olsa da, bu API farklı platformlarda değerlendirme ve tahmin dağıtmak için de kullanılabilir.

Sen kullanabilirsiniz tf.distribute.Strategy TensorFlow altında yatan bileşenleri strateji farkında olmaya değiştiği için, kodunuzu çok az değişikliklerle. Buna değişkenler, katmanlar, modeller, optimize ediciler, ölçümler, özetler ve kontrol noktaları dahildir.

Bu kılavuzda, çeşitli strateji türleri ve bunları farklı durumlarda nasıl kullanabileceğinizi öğreneceksiniz. Kontrol, nasıl ayıklama performans sorunları öğrenmek için optimize TensorFlow GPU performansı kılavuzu.

TensorFlow'u kurun

import tensorflow as tf

Strateji türleri

tf.distribute.Strategy farklı eksenler boyunca kullanım durumları bir dizi karşılamaya yöneliktir. Bu kombinasyonlardan bazıları şu anda desteklenmektedir ve diğerleri gelecekte eklenecektir. Bu eksenlerden bazıları şunlardır:

  • Asenkron eğitim vs Eşzamanlı: Bu veriler paralelizm'le eğitim dağıtma iki genel yolu vardır. Eşitleme eğitiminde, tüm çalışanlar eşitlemede farklı girdi verisi dilimleri üzerinde eğitim alır ve her adımda gradyanları toplar. Zaman uyumsuz eğitimde, tüm çalışanlar girdi verileri üzerinde bağımsız olarak eğitim alır ve değişkenleri zaman uyumsuz olarak günceller. Tipik olarak, eşitleme eğitimi, parametre sunucusu mimarisi aracılığıyla tümüyle azalt ve eşzamansız olarak desteklenir.
  • Donanım platformu: Siz veya Bulut TPU üzerinde (0 veya daha fazla GPU'ları her biriyle) bir ağda bir makineye veya birden fazla makine üzerinde birden GPU'ları üzerine eğitim ölçek isteyebilirsiniz.

Bu kullanım şeklini destekler için, TensorFlow vardır MirroredStrategy , TPUStrategy , MultiWorkerMirroredStrategy , ParameterServerStrategy , CentralStorageStrategy yanı sıra mevcut diğer stratejileri. Sonraki bölüm, TensorFlow'da bunlardan hangilerinin hangi senaryolarda desteklendiğini açıklar. İşte hızlı bir genel bakış:

Eğitim API'sı MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy CentralStorageStrategy ParameterServerStrategy
keras Model.fit Desteklenen Desteklenen Desteklenen deneysel destek deneysel destek
Özel eğitim döngüsü Desteklenen Desteklenen Desteklenen deneysel destek deneysel destek
Tahminci API'sı Sınırlı Destek Desteklenmiyor Sınırlı Destek Sınırlı Destek Sınırlı Destek

MirroredStrateji

tf.distribute.MirroredStrategy destekleri Bir makinede birden GPU'ları üzerine eğitim dağıtılan senkron. GPU aygıtı başına bir kopya oluşturur. Modeldeki her değişken, tüm kopyalarda yansıtılır. Birlikte, bu değişkenler olarak adlandırılan tek bir kavramsal değişkeni oluşturmak MirroredVariable . Bu değişkenler, aynı güncellemeler uygulanarak birbirleriyle senkronize tutulur.

Cihazlar arasında değişken güncellemeleri iletmek için verimli all-reduce algoritmaları kullanılır. All-reduce, tensörleri tüm cihazlarda toplayarak toplar ve her cihazda kullanılabilir hale getirir. Çok verimli olan ve senkronizasyon yükünü önemli ölçüde azaltabilen kaynaşmış bir algoritmadır. Cihazlar arasında mevcut olan iletişim türüne bağlı olarak, çok sayıda tamamen azaltılmış algoritma ve uygulama mevcuttur. Varsayılan olarak, NVIDIA Toplu Haberleşme Kütüphanesi (kullanır NCCLS hepsi azaltmak uygulanması gibi). Diğer birkaç seçenek arasından seçim yapabilir veya kendinizinkini yazabilirsiniz.

İşte yaratmanın en basit yoldur MirroredStrategy :

mirrored_strategy = tf.distribute.MirroredStrategy()
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)

Bu yaratacak MirroredStrategy TensorFlow görülebilir tüm GPU'ları kullanır örneği, ve NCCLS-çapraz aygıt iletişim.

Makinenizde yalnızca bazı GPU'ları kullanmak istiyorsanız, bunu şu şekilde yapabilirsiniz:

mirrored_strategy = tf.distribute.MirroredStrategy(devices=["/gpu:0", "/gpu:1"])
WARNING:tensorflow:Some requested devices in `tf.distribute.Strategy` are not visible to TensorFlow: /job:localhost/replica:0/task:0/device:GPU:1,/job:localhost/replica:0/task:0/device:GPU:0
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1')

Çapraz cihaz iletişimi geçersiz kılmak isterseniz, bu yüzden kullanarak yapabilirsiniz cross_device_ops bir örneğini sağlayarak argüman tf.distribute.CrossDeviceOps . Şu anda, tf.distribute.HierarchicalCopyAllReduce ve tf.distribute.ReductionToOneDevice dışındaki iki seçenek vardır tf.distribute.NcclAllReduce varsayılan değerdir.

mirrored_strategy = tf.distribute.MirroredStrategy(
    cross_device_ops=tf.distribute.HierarchicalCopyAllReduce())
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)

TPUStratejisi

tf.distribute.TPUStrategy Eğer üzerinde TensorFlow eğitimi çalıştırmanızı sağlar tensör İşleme Birimi (TPU) . TPU'lar, Google'ın makine öğrenimi iş yüklerini önemli ölçüde hızlandırmak için tasarlanmış özel ASIC'leridir. Onlar mevcuttur tarihinde CoLab , TPU Araştırma Cloud ve Bulut TPU .

Dağıtılan eğitim mimarisi açısından, TPUStrategy aynıdır MirroredStrategy -çok uygular senkron dağıtılan eğitim. TPU kullanılan çoklu TPU çekirdeklerinin, bu gruplardaki tüm azaltmak, verimli ve diğer kolektif operasyonların kendi uygulamasını sağlamak TPUStrategy .

Burada örneğini nasıl olduğunu TPUStrategy :

cluster_resolver = tf.distribute.cluster_resolver.TPUClusterResolver(
    tpu=tpu_address)
tf.config.experimental_connect_to_cluster(cluster_resolver)
tf.tpu.experimental.initialize_tpu_system(cluster_resolver)
tpu_strategy = tf.distribute.TPUStrategy(cluster_resolver)

TPUClusterResolver örneği TPU bulmanıza yardımcı olur. Colab'de buna herhangi bir argüman belirtmeniz gerekmez.

Bunu Cloud TPU'lar için kullanmak istiyorsanız:

  • Sen içinde TPU kaynağın adını belirtmelisiniz tpu argüman.
  • Programın başlangıcında açıkça TPU sistemini başlatmak zorundadır. Bu, TPU'ların hesaplama için kullanılabilmesi için gereklidir. TPU sisteminin başlatılması aynı zamanda TPU belleğini de siler, bu nedenle durum kaybını önlemek için önce bu adımı tamamlamak önemlidir.

Çoklu ÇalışanYansıtmalıStrateji

tf.distribute.MultiWorkerMirroredStrategy çok benzer MirroredStrategy . Her biri potansiyel olarak birden çok GPU'ya sahip birden çok çalışan arasında senkronize dağıtılmış eğitim uygular. Benzer tf.distribute.MirroredStrategy , tüm işçilerin genelinde her cihazda modeldeki tüm değişkenler kopyalarını yaratır.

İşte yaratmanın en basit yoldur MultiWorkerMirroredStrategy :

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

MultiWorkerMirroredStrategy cihazlar arası iletişim için iki uygulamaları vardır. CommunicationImplementation.RING olan RPC tabanlı ve CPU ve GPU'ları destekler. CommunicationImplementation.NCCL NCCLS kullanır ve GPU'larda state-of-art performans sağlar ama işlemcileri desteklemez. CollectiveCommunication.AUTO Tensorflow seçeneği ertelemektedir. Bunları aşağıdaki şekilde belirtebilirsiniz:

communication_options = tf.distribute.experimental.CommunicationOptions(
    implementation=tf.distribute.experimental.CommunicationImplementation.NCCL)
strategy = tf.distribute.MultiWorkerMirroredStrategy(
    communication_options=communication_options)
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
INFO:tensorflow:Single-worker MultiWorkerMirroredStrategy with local_devices = ('/device:GPU:0',), communication = CommunicationImplementation.NCCL

Çoklu GPU eğitimi ile karşılaştırıldığında, çok işçili eğitim almanın temel farklarından biri, çok işçili kurulumdur. 'TF_CONFIG' ortam değişkeni kümesinin parçası olan her işçi için küme yapılandırmasını belirtmek için TensorFlow standart yoludur. Daha fazla bilgi TF_CONFIG bölümünde yukarı ayarı bu belgenin.

Hakkında daha fazla ayrıntı için MultiWorkerMirroredStrategy aşağıdaki öğreticiler göz önünde bulundurun:

ParametreSunucuStratejisi

Parametre sunucusu eğitimi, birden çok makinede model eğitimini büyütmek için yaygın bir veri paralel yöntemidir. Bir parametre sunucusu eğitim kümesi, çalışanlardan ve parametre sunucularından oluşur. Değişkenler parametre sunucularında oluşturulur ve her adımda çalışanlar tarafından okunur ve güncellenir. Check out Parametre sunucu eğitim detayları için öğretici.

TensorFlow 2, parametre sunucu eğitim yoluyla merkezi koordinatörü tabanlı mimarisini kullanan tf.distribute.experimental.coordinator.ClusterCoordinator sınıfına.

Bu uygulamada, worker ve parameter server görevleri çalıştırmak tf.distribute.Server ler koordinatörü gelen görevler için dinlemek. Koordinatör kaynakları oluşturur, eğitim görevlerini gönderir, kontrol noktaları yazar ve görev başarısızlıklarıyla ilgilenir.

Koordinatör üzerinde çalışan programlama, bir kullanacak ParameterServerStrategy bir eğitim aşamasını tanımlamak için nesne ve bir kullanma ClusterCoordinator uzak işçilere gönderme eğitim adımlarına. İşte onları yaratmanın en basit yolu:

strategy = tf.distribute.experimental.ParameterServerStrategy(
    tf.distribute.cluster_resolver.TFConfigClusterResolver(),
    variable_partitioner=variable_partitioner)
coordinator = tf.distribute.experimental.coordinator.ClusterCoordinator(
    strategy)

Hakkında daha fazla bilgi edinmek için ParameterServerStrategy , kontrol Keras Model.fit ve özel bir eğitim döngü ile Parametre sunucu eğitimi öğretici.

TensorFlow 1'de ParameterServerStrategy sadece üzerinden bir Tahmincisi ile kullanılabilir tf.compat.v1.distribute.experimental.ParameterServerStrategy sembolü.

MerkeziDepolamaStratejisi

tf.distribute.experimental.CentralStorageStrategy kuyunun olarak senkron eğitim yapar. Değişkenler yansıtılmaz, bunun yerine CPU'ya yerleştirilir ve işlemler tüm yerel GPU'larda çoğaltılır. Yalnızca bir GPU varsa, tüm değişkenler ve işlemler o GPU'ya yerleştirilecektir.

Bir örneğini oluşturun CentralStorageStrategy tarafından:

central_storage_strategy = tf.distribute.experimental.CentralStorageStrategy()
INFO:tensorflow:ParameterServerStrategy (CentralStorageStrategy if you are using a single machine) with compute_devices = ['/job:localhost/replica:0/task:0/device:GPU:0'], variable_device = '/job:localhost/replica:0/task:0/device:GPU:0'

Bu yaratacak CentralStorageStrategy tüm görünür GPU'lar ve CPU kullanacak örneği. Replikalardaki değişkenlere yapılan güncellemeler, değişkenlere uygulanmadan önce toplanır.

Diğer stratejiler

Yukarıdaki stratejilerine ek olarak, prototip ile kullanıldığında ayıklama için yararlı olabilir iki strateji vardır tf.distribute API'leri.

Varsayılan Strateji

Varsayılan Strateji, kapsam dahilinde açık bir dağıtım stratejisi olmadığında mevcut olan bir dağıtım stratejisidir. Bu uygular tf.distribute.Strategy arayüz ama bir geçiş ve hiçbir gerçek dağılımı sağlar. Örneğin, strategy.run(fn) basitçe arayacak fn . Bu strateji kullanılarak yazılan kod, tam olarak herhangi bir strateji olmadan yazılan kod gibi davranmalıdır. Bunu "işlemsiz" bir strateji olarak düşünebilirsiniz.

Varsayılan Strateji bir tektir ve bunun daha fazla örneği oluşturulamaz. Bu kullanılarak elde edilebilir tf.distribute.get_strategy herhangi açık stratejisinin kapsamı dışında (açık stratejisinin kapsamı içindeki geçerli bir strateji almak için kullanılabilecek aynı API).

default_strategy = tf.distribute.get_strategy()

Bu strateji iki ana amaca hizmet eder:

  • Koşulsuz olarak dağıtıma duyarlı kitaplık kodunun yazılmasına izin verir. Örneğin, tf.optimizer kullanabileceğiniz s tf.distribute.get_strategy ve azaltılması için bu stratejiyi kullanmak geçişlerini-her zaman Arayabileceğin hangi bir strateji nesnesi döndürür Strategy.reduce API.
# In optimizer or other library code
# Get currently active strategy
strategy = tf.distribute.get_strategy()
strategy.reduce("SUM", 1., axis=None)  # reduce some values
1.0
  • Kütüphane koduna benzer şekilde, koşullu mantık gerektirmeden, dağıtım stratejisi olan ve olmayan son kullanıcıların programlarını yazmak için kullanılabilir. İşte bunu gösteren örnek bir kod parçacığı:
if tf.config.list_physical_devices('GPU'):
  strategy = tf.distribute.MirroredStrategy()
else:  # Use the Default Strategy
  strategy = tf.distribute.get_strategy()

with strategy.scope():
  # Do something interesting
  print(tf.Variable(1.))
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)
MirroredVariable:{
  0: <tf.Variable 'Variable:0' shape=() dtype=float32, numpy=1.0>
}

OneDeviceStrateji

tf.distribute.OneDeviceStrategy tek belirtilen cihazda tüm değişkenleri ve hesaplama yerleştirmek için bir stratejidir.

strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")

Bu strateji, Varsayılan Stratejiden çeşitli şekillerde farklıdır. Varsayılan Stratejide, TensorFlow'u herhangi bir dağıtım stratejisi olmadan çalıştırmaya kıyasla değişken yerleştirme mantığı değişmeden kalır. Kullanırken Ama OneDeviceStrategy , kapsamı oluşturulan tüm değişkenler açıkça belirtilen cihazda yerleştirilir. Ayrıca, ile adlandırılan bir işlevleri OneDeviceStrategy.run de belirtilen cihazda yerleştirilecektir.

Bu strateji aracılığıyla dağıtılan girdiler, belirtilen cihaza önceden getirilecektir. Varsayılan Strateji'de girdi dağıtımı yoktur.

Varsayılan Stratejiye benzer şekilde, bu strateji, aslında birden çok cihaza/makineye dağıtılan diğer stratejilere geçmeden önce kodunuzu test etmek için de kullanılabilir. Bu ancak örnek için, kullanmanın tam ölçüde biraz daha Standart Stratejisi den dağıtım stratejisi makine kullanacaktır MirroredStrategy veya TPUStrategy . Strateji yokmuş gibi davranan bir kod istiyorsanız, Varsayılan Strateji'yi kullanın.

Şimdiye kadar farklı stratejiler ve bunları nasıl somutlaştırabileceğinizi öğrendiniz. Sonraki birkaç bölüm, bunları eğitiminizi dağıtmak için kullanabileceğiniz farklı yolları gösterir.

Keras Model.fit ile tf.distribute.Strategy kullanın

tf.distribute.Strategy entegre edilmiştir tf.keras ait TensorFlow en uygulaması olan Keras API şartname . tf.keras inşa ve tren modellere üst düzey bir API'sıdır. İçine entegre ederek tf.keras arka uç, sizin için 's dikişsiz Keras eğitim çerçevesinde yazılı eğitiminizi dağıtmak için Model.fit kullanarak .

İşte kodunuzda değiştirmeniz gerekenler:

  1. Uygun bir örneğini oluşturun tf.distribute.Strategy .
  2. Keras modeli optimize edici ve iç ölçütlerinin oluşturulması Taşı strategy.scope .

TensorFlow dağıtım stratejileri keras modeller-her türlü destek Sıralı , Fonksiyonel ve sınıflandırma .

İşte bir ile çok basit bir Keras modeli için bunu yapmak için kod snippet'idir Dense katmanın:

mirrored_strategy = tf.distribute.MirroredStrategy()

with mirrored_strategy.scope():
  model = tf.keras.Sequential([tf.keras.layers.Dense(1, input_shape=(1,))])

model.compile(loss='mse', optimizer='sgd')
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU: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',).

Bu örnek kullanır MirroredStrategy Birden GPU'ları olan bir makinede bu çalışabilmesi için,. strategy.scope() eğitim dağıtmak için kullanımı strateji keras gösterir. Bu kapsamda modeller/iyileştiriciler/metrikler oluşturmak, normal değişkenler yerine dağıtılmış değişkenler oluşturmanıza olanak tanır. Bu ayarlandıktan sonra, modelinizi normalde yaptığınız gibi sığdırabilirsiniz. MirroredStrategy , mevcut GPU'larda modelin eğitimi kopyalayan geçişlerini araya ve daha ilgilenir.

dataset = tf.data.Dataset.from_tensors(([1.], [1.])).repeat(100).batch(10)
model.fit(dataset, epochs=2)
model.evaluate(dataset)
2021-09-22 20:33:41.551842: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:695] 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: "TensorDataset/_2"
op: "TensorDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_FLOAT
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 1
        }
      }
      shape {
        dim {
          size: 1
        }
      }
    }
  }
}
Epoch 1/2
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',).
10/10 [==============================] - 3s 2ms/step - loss: 2.4687
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',).
Epoch 2/2
10/10 [==============================] - 0s 2ms/step - loss: 1.0912
2021-09-22 20:33:44.537154: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:695] 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: "TensorDataset/_2"
op: "TensorDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_FLOAT
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 1
        }
      }
      shape {
        dim {
          size: 1
        }
      }
    }
  }
}
10/10 [==============================] - 1s 2ms/step - loss: 0.6776
0.6776412129402161

İşte tf.data.Dataset eğitim ve eval girdi sağlamaktadır. NumPy dizilerini de kullanabilirsiniz:

import numpy as np

inputs, targets = np.ones((100, 1)), np.ones((100, 1))
model.fit(inputs, targets, epochs=2, batch_size=10)
Epoch 1/2
2021-09-22 20:33:45.820303: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:695] AUTO sharding policy will apply DATA sharding policy as it failed to apply FILE sharding policy because of the following reason: Did not find a shardable source, walked to a node which is not a dataset: name: "FlatMapDataset/_9"
op: "FlatMapDataset"
input: "PrefetchDataset/_8"
attr {
  key: "Targuments"
  value {
    list {
    }
  }
}
attr {
  key: "f"
  value {
    func {
      name: "__inference_Dataset_flat_map_slice_batch_indices_997"
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 10
        }
      }
    }
  }
}
attr {
  key: "output_types"
  value {
    list {
      type: DT_INT64
    }
  }
}
. Consider either turning off auto-sharding or switching the auto_shard_policy to DATA to shard this dataset. You can do this by creating a new `tf.data.Options()` object then setting `options.experimental_distribute.auto_shard_policy = AutoShardPolicy.DATA` before applying the options object to the dataset via `dataset.with_options(options)`.
10/10 [==============================] - 1s 2ms/step - loss: 0.4823
Epoch 2/2
10/10 [==============================] - 0s 2ms/step - loss: 0.2132
<keras.callbacks.History at 0x7f12645690d0>

Her iki durumda da-In Dataset veya numpy-her belirli bir girdinin toplu birden kopyaları arasında eşit olarak bölünür. Kullandığınız Örneğin, MirroredStrategy 2 GPU'larda büyüklüğü, 10 her parti her aşamasında her bir alıcı 5 girdi örnekleri ile, 2 grafik işlemcileri arasında bölünmüş alacak. Her dönem, siz daha fazla GPU ekledikçe daha hızlı çalışacaktır. Tipik olarak, ekstra bilgi işlem gücünden etkin bir şekilde yararlanmak için daha fazla hızlandırıcı ekledikçe toplu iş boyutunuzu artırmak istersiniz. Ayrıca modele bağlı olarak öğrenme oranınızı yeniden ayarlamanız gerekecektir. Sen kullanabilirsiniz strategy.num_replicas_in_sync kopyaları sayısını alır.

# Compute a global batch size using a number of replicas.
BATCH_SIZE_PER_REPLICA = 5
global_batch_size = (BATCH_SIZE_PER_REPLICA *
                     mirrored_strategy.num_replicas_in_sync)
dataset = tf.data.Dataset.from_tensors(([1.], [1.])).repeat(100)
dataset = dataset.batch(global_batch_size)

LEARNING_RATES_BY_BATCH_SIZE = {5: 0.1, 10: 0.15}
learning_rate = LEARNING_RATES_BY_BATCH_SIZE[global_batch_size]

Şimdi ne destekleniyor?

Eğitim API'sı MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy ParameterServerStrategy CentralStorageStrategy
keras Model.fit Desteklenen Desteklenen Desteklenen deneysel destek deneysel destek

Örnekler ve öğreticiler

İşte yukarıdaki entegrasyon uçtan uca Keras ile tasvir Eğitimler ve örnekler listesidir Model.fit :

  1. Öğretici : Antrenmanlar Model.fit ve MirroredStrategy .
  2. Öğretici : Antrenmanlar Model.fit ve MultiWorkerMirroredStrategy .
  3. Kılavuz : kullanarak bir örnek içerir Model.fit ve TPUStrategy .
  4. Öğretici, : ile Parametre sunucu eğitim Model.fit ve ParameterServerStrategy .
  5. Öğretici, : ile YAPIŞTIRICI kriter birçok görevler için ince ayarlamalar Bert Model.fit ve TPUStrategy .
  6. TensorFlow Modeli Bahçe depoya çeşitli stratejiler kullanılarak uygulanan state-of-the-art model koleksiyonları içeren.

Özel eğitim döngüleriyle tf.distribute.Strategy kullanın

Kullanılarak yukarıda gösterildiği gibi tf.distribute.Strategy Keras ile Model.fit Kodunuzdaki yalnızca birkaç hatları değişen gerektirir. Biraz daha çaba ile, aynı zamanda kullanabilirsiniz tf.distribute.Strategy özel eğitim döngüler ile .

Antrenman döngüleriniz üzerinde Estimator veya Keras ile mümkün olandan daha fazla esnekliğe ve kontrole ihtiyacınız varsa, özel eğitim döngüleri yazabilirsiniz. Örneğin, bir GAN kullanırken, her turda farklı sayıda üretici veya ayrımcı adım atmak isteyebilirsiniz. Benzer şekilde, yüksek seviyeli çerçeveler, Pekiştirmeli Öğrenme eğitimi için çok uygun değildir.

tf.distribute.Strategy sınıfları destek özel bir eğitim döngüler için çeşitli yöntemler bir çekirdek dizi sağlar. Bunları kullanmak, başlangıçta kodun küçük bir yeniden yapılandırılmasını gerektirebilir, ancak bu yapıldıktan sonra, yalnızca strateji örneğini değiştirerek GPU'lar, TPU'lar ve birden çok makine arasında geçiş yapabilmeniz gerekir.

Aşağıda, daha önce olduğu gibi aynı Keras modelini kullanan basit bir eğitim örneği için bu kullanım durumunu gösteren kısa bir pasaj bulunmaktadır.

İlk olarak, strateji kapsamında modeli ve optimize ediciyi oluşturun. Bu, model ve optimize edici ile oluşturulan tüm değişkenlerin yansıtılmış değişkenler olmasını sağlar.

with mirrored_strategy.scope():
  model = tf.keras.Sequential([tf.keras.layers.Dense(1, input_shape=(1,))])
  optimizer = tf.keras.optimizers.SGD()

Daha sonra, giriş veri kümesi oluşturmak ve çağrı tf.distribute.Strategy.experimental_distribute_dataset stratejisine dayalı veri kümesi dağıtmak.

dataset = tf.data.Dataset.from_tensors(([1.], [1.])).repeat(100).batch(
    global_batch_size)
dist_dataset = mirrored_strategy.experimental_distribute_dataset(dataset)
2021-09-22 20:33:47.092428: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:695] 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: "TensorDataset/_2"
op: "TensorDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_FLOAT
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 1
        }
      }
      shape {
        dim {
          size: 1
        }
      }
    }
  }
}

Ardından, eğitimin bir adımını tanımlayın. Kullanım tf.GradientTape hesaplama gradyanlar ve optimizer için modelin değişkenleri güncellemek için bu degradeler uygulamak için. Bu eğitim adımı dağıtmak için, bir fonksiyon içine koyun train_step ve iletecek tf.distrbute.Strategy.run Eğer aldığım veri kümesi girişleri ile birlikte dist_dataset önce oluşturulan:

loss_object = tf.keras.losses.BinaryCrossentropy(
  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)

def train_step(inputs):
  features, labels = inputs

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

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

@tf.function
def distributed_train_step(dist_inputs):
  per_replica_losses = mirrored_strategy.run(train_step, args=(dist_inputs,))
  return mirrored_strategy.reduce(tf.distribute.ReduceOp.SUM, per_replica_losses,
                         axis=None)

Yukarıdaki kodda dikkat edilmesi gereken birkaç şey daha:

  1. Kullanılan tf.nn.compute_average_loss kaybını hesaplamak için. tf.nn.compute_average_loss Örnekl'deki kaybı toplar ve global_batch_size ile toplamı böler. Gradyanları her çoğaltma hesaplanır daha sonra sonra, bunları toplayarak kopyaları arasında derlendiği için bu önemlidir.
  2. Ayrıca kullanılan tf.distribute.Strategy.reduce tarafından döndürülen sonuçları toplamak için API tf.distribute.Strategy.run . tf.distribute.Strategy.run stratejisinde her yerel kopyadan sonuçları döndürür ve bu sonucu tüketmek birden çok yolu vardır. Sen edebilirsiniz reduce bir toplu değerini almak için onları. Ayrıca yapabilirsiniz tf.distribute.Strategy.experimental_local_results değerleri sonucu, yerel çoğaltma başına birinin içerdiği listesini almak için.
  3. Aradığınızda apply_gradients bir dağıtım stratejisi kapsamında, onun davranışı değiştirilir. Spesifik olarak, eşzamanlı eğitim sırasında her bir paralel örneğe degradeler uygulamadan önce, degradelerin tümünün toplamını gerçekleştirir.

Eğer eğitim adımını tanımladıktan sonra Son olarak, adımlayabilirsiniz dist_dataset ve bir döngü içinde eğitim çalıştırın:

for dist_inputs in dist_dataset:
  print(distributed_train_step(dist_inputs))
tf.Tensor(0.29786447, shape=(), dtype=float32)
tf.Tensor(0.29653987, shape=(), dtype=float32)
tf.Tensor(0.29522538, shape=(), dtype=float32)
tf.Tensor(0.29392087, shape=(), dtype=float32)
tf.Tensor(0.29262626, shape=(), dtype=float32)
tf.Tensor(0.29134142, shape=(), dtype=float32)
tf.Tensor(0.29006627, shape=(), dtype=float32)
tf.Tensor(0.28880078, shape=(), dtype=float32)
tf.Tensor(0.2875447, shape=(), dtype=float32)
tf.Tensor(0.28629807, shape=(), dtype=float32)
tf.Tensor(0.28506076, shape=(), dtype=float32)
tf.Tensor(0.2838327, shape=(), dtype=float32)
tf.Tensor(0.28261372, shape=(), dtype=float32)
tf.Tensor(0.28140378, shape=(), dtype=float32)
tf.Tensor(0.28020284, shape=(), dtype=float32)
tf.Tensor(0.27901068, shape=(), dtype=float32)
tf.Tensor(0.27782732, shape=(), dtype=float32)
tf.Tensor(0.27665266, shape=(), dtype=float32)
tf.Tensor(0.2754866, shape=(), dtype=float32)
tf.Tensor(0.274329, shape=(), dtype=float32)

Yukarıdaki örnekte, iterated dist_dataset eğitiminizin girdi sağlamak için. Ayrıca sağlanmaktadır tf.distribute.Strategy.make_experimental_numpy_dataset NumPy girişlerini desteklemek için. Sen aramadan önce bir veri kümesi oluşturmak için bu API kullanabilirsiniz tf.distribute.Strategy.experimental_distribute_dataset .

Verilerinizi yinelemenin başka bir yolu da yineleyicileri açıkça kullanmaktır. Bunu, tüm veri kümesini yinelemek yerine belirli sayıda adım için çalıştırmak istediğinizde yapmak isteyebilirsiniz. Yineleme yukarıda şimdi ilk bir yineleyici oluşturmak için değiştirilebilir ve daha sonra açıkça çağırır next giriş verilerini almak için onun.

iterator = iter(dist_dataset)
for _ in range(10):
  print(distributed_train_step(next(iterator)))
tf.Tensor(0.2731799, shape=(), dtype=float32)
tf.Tensor(0.27203918, shape=(), dtype=float32)
tf.Tensor(0.27090666, shape=(), dtype=float32)
tf.Tensor(0.26978233, shape=(), dtype=float32)
tf.Tensor(0.26866615, shape=(), dtype=float32)
tf.Tensor(0.26755798, shape=(), dtype=float32)
tf.Tensor(0.2664578, shape=(), dtype=float32)
tf.Tensor(0.26536545, shape=(), dtype=float32)
tf.Tensor(0.2642809, shape=(), dtype=float32)
tf.Tensor(0.26320407, shape=(), dtype=float32)

Bu kapaklar kullanmanın en basit durumda tf.distribute.Strategy özel eğitim döngüler dağıtmak için API.

Şimdi ne destekleniyor?

Eğitim API'sı MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy ParameterServerStrategy CentralStorageStrategy
Özel eğitim döngüsü Desteklenen Desteklenen Desteklenen deneysel destek deneysel destek

Örnekler ve öğreticiler

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

  1. Öğretici : Bir özel eğitim döngü ile Eğitim MirroredStrategy .
  2. Öğretici : Bir özel eğitim döngü ile Eğitim MultiWorkerMirroredStrategy .
  3. Kılavuz : ile özel bir eğitim halkası örneği içerir TPUStrategy .
  4. Öğretici : Bir özel eğitim döngü ile Parametre sunucu eğitim ParameterServerStrategy .
  5. TensorFlow Modeli Bahçe depoya çeşitli stratejiler kullanılarak uygulanan state-of-the-art model koleksiyonları içeren.

Diğer başlıklar

Bu bölüm, çoklu kullanım durumları ile ilgili bazı konuları kapsar.

TF_CONFIG ortam değişkenini ayarlama

Daha önce de belirtildiği gibi çok-işçi eğitimi için, kurmak gerekir 'TF_CONFIG' Kümenizdeki her ikili çalışma için ortam değişkeni. 'TF_CONFIG' ortam değişkeni belirtir hangi görevleri bir küme, onların adreslerini ve kümedeki her görevin rol teşkil JSON dizedir. tensorflow/ecosystem Repo kurar bir Kubernetes şablonu sağlar 'TF_CONFIG' antrenman görevler için.

İki bileşeni vardır 'TF_CONFIG' küme ve bir görev.

  • Bir küme, işçiler gibi farklı iş türlerinden oluşan bir dikte olan eğitim kümesi hakkında bilgi sağlar. Çok çalışanlı eğitimde, normal bir çalışanın yaptığına ek olarak, genellikle kontrol noktasını kaydetme ve TensorBoard için özet dosyası yazma gibi biraz daha fazla sorumluluk alan bir çalışan vardır. Böyle işçi "baş" işçi olarak anılacaktır ve indeksi 0 ile işçi baş işçisi olarak tayin edildiğini gelenektir edilir (aslında bu nasıl tf.distribute.Strategy uygulanmaktadır).
  • Öte yandan bir görev, mevcut görevin bilgisini sağlar. İlk bileşen kümesi tüm çalışanlar için aynıdır ve ikinci bileşen görevi her çalışan için farklıdır ve o çalışanın türünü ve dizinini belirtir.

Bir örneği 'TF_CONFIG' geçerli:

os.environ["TF_CONFIG"] = json.dumps({
    "cluster": {
        "worker": ["host1:port", "host2:port", "host3:port"],
        "ps": ["host4:port", "host5:port"]
    },
   "task": {"type": "worker", "index": 1}
})

Bu 'TF_CONFIG' belirtir üç işçi ve iki olduğunu "ps" in görevleri "cluster" onların ana ve liman ile birlikte. "task" bölümü içinde geçerli görev rolünü belirtir "cluster" -worker 1 (ikinci işçi). Bir kümedeki Geçerli rollerdir "chief" , "worker" , "ps" ve "evaluator" . Hiçbir olmalıdır "ps" kullanımı dışında iş tf.distribute.experimental.ParameterServerStrategy .

Sıradaki ne?

tf.distribute.Strategy geliştirme aşamasındadır aktif olduğunu. Deneyin ve kullanarak geribildirim sağlamak GitHub sorunları .