![]() | ![]() | ![]() | ![]() |
Genel Bakış
tf.distribute.Strategy
, eğitimi birden çok GPU, birden çok makine veya TPU'ya tf.distribute.Strategy
için bir TensorFlow API'sidir. Bu API'yi kullanarak, mevcut modellerinizi ve eğitim kodunuzu minimum kod değişikliği ile dağıtabilirsiniz.
tf.distribute.Strategy
, aşağıdaki temel hedefler göz önünde bulundurularak tasarlanmıştır:
- Araştırmacılar, makine öğrenimi mühendisleri vb. Dahil olmak üzere birden çok kullanıcı segmentini kullanmak ve desteklemek kolaydır.
- Kutudan çıkar çıkmaz iyi performans sağlayın.
- Stratejiler arasında kolay geçiş.
tf.distribute.Strategy
gibi üst düzey bir API ile birlikte kullanılabilir keras (genel olarak, TensorFlow kullanarak herhangi bir hesaplama ve benzeri), ve aynı zamanda özel bir eğitim döngüler dağıtmak için kullanılabilir.
TensorFlow 2.x'te, programlarınızı hevesle veya tf.function
kullanarak bir grafikte tf.function
. tf.distribute.Strategy
bu iki yürütme modunu da desteklemeyi amaçlamaktadır, ancak en iyi tf.function
ile tf.function
. İstekli mod yalnızca hata ayıklama amacıyla önerilir ve TPUStrategy
için desteklenmez. Eğitim bu kılavuzun odak noktası olsa da, bu API aynı zamanda değerlendirme ve tahmini farklı platformlarda dağıtmak için de kullanılabilir.
tf.distribute.Strategy
çok az değişiklikle kullanabilirsiniz, çünkü TensorFlow'un temel bileşenlerini stratejiden haberdar olmak için değiştirdik. Buna değişkenler, katmanlar, modeller, optimize ediciler, ölçümler, özetler ve kontrol noktaları dahildir.
Bu kılavuzda, çeşitli strateji türlerini ve bunları farklı durumlarda nasıl kullanabileceğinizi açıklıyoruz. Performans sorunlarının nasıl giderileceğini öğrenmek için, bkz. TensorFlow GPU Performansını Optimize Etme kılavuzu.
# Import TensorFlow
import tensorflow as tf
Strateji türleri
tf.distribute.Strategy
, farklı eksenler boyunca bir dizi kullanım tf.distribute.Strategy
amaçlamaktadır. Bu kombinasyonlardan bazıları şu anda desteklenmektedir ve diğerleri gelecekte eklenecektir. Bu eksenlerden bazıları:
- Eşzamanlı ve eşzamansız eğitim: Bunlar, eğitimi veri paralelliği ile dağıtmanın iki yaygın yoludur. Eşzamanlı eğitimde, tüm çalışanlar eşzamanlı olarak farklı girdi verisi dilimlerinde eğitim alır ve her adımda gradyanları bir araya getirir. Eşzamansız eğitimde, tüm çalışanlar girdi verileri üzerinde bağımsız olarak eğitim alır ve değişkenleri eşzamansız olarak günceller. Tipik olarak senkronizasyon eğitimi, parametre sunucusu mimarisi aracılığıyla tümü azaltma ve zaman uyumsuzluğu aracılığıyla desteklenir.
- Donanım platformu: Eğitiminizi bir makinede birden çok GPU'ya veya bir ağdaki (her biri 0 veya daha fazla GPU'ya sahip) birden çok makineye ya da Cloud TPU'lara ölçeklendirmek isteyebilirsiniz.
Bu kullanım durumlarını desteklemek için, altı strateji mevcuttur. Sonraki bölüm bunlardan hangilerinin TF'de hangi senaryolarda desteklendiğini açıklamaktadır. İşte hızlı bir genel bakış:
Eğitim API'si | YansıtılmışStrateji | TPUStrateji | MultiWorkerMirroredStrateji | CentralStorageStrategy | ParameterServerStrategy |
---|---|---|---|---|---|
Keras API | Destekleniyor | Destekleniyor | Destekleniyor | Deneysel destek | Desteklenen planlı gönderi 2.4 |
Özel eğitim döngüsü | Destekleniyor | Destekleniyor | Destekleniyor | Deneysel destek | Deneysel destek |
Tahminci API | Sınırlı Destek | Desteklenmiyor | Sınırlı Destek | Sınırlı Destek | Sınırlı Destek |
YansıtılmışStrateji
tf.distribute.MirroredStrategy
, tek bir makinede birden çok GPU üzerinde eşzamanlı dağıtılmış eğitimi destekler. GPU cihazı başına bir kopya oluşturur. Modeldeki her değişken, tüm eşlemelerde yansıtılır. Birlikte, bu değişkenler MirroredVariable
adlı tek bir kavramsal değişken oluşturur. Bu değişkenler, aynı güncellemeler uygulanarak birbirleriyle senkronize tutulur.
Değişken güncellemeleri cihazlar arasında iletmek için verimli tam azaltma algoritmaları kullanılır. Tümü azalt, tüm cihazlarda tensörleri toplayarak toplar ve her cihazda kullanılabilir hale getirir. Çok verimli olan ve senkronizasyon ek yükünü önemli ölçüde azaltabilen birleşik bir algoritmadır. Cihazlar arasında mevcut iletişim türüne bağlı olarak, çok sayıda tümüyle azaltılmış algoritma ve uygulama mevcuttur. Varsayılan olarak, tam azaltma uygulaması olarak NVIDIA NCCL'yi kullanır. Diğer birkaç seçenekten birini seçebilir veya kendi yazınızı yazabilirsiniz.
MirroredStrategy
oluşturmanın en basit yolu:
mirrored_strategy = tf.distribute.MirroredStrategy()
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)
Bu, TensorFlow tarafından görülebilen tüm GPU'ları kullanacak ve cihazlar arası iletişim olarak NCCL'yi kullanacak bir MirroredStrategy
örneği oluşturacaktır.
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:0,/job:localhost/replica:0/task:0/device:GPU:1 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',)
TPUStrateji
tf.distribute.TPUStrategy
, TensorFlow eğitiminizi Tensor Processing Units (TPU'lar) üzerinde çalıştırmanıza olanak tanır. TPU'lar, makine öğrenimi iş yüklerini önemli ölçüde hızlandırmak için tasarlanmış Google'ın özel ASIC'leridir. Google Colab, TensorFlow Research Cloud ve Cloud TPU'da mevcuttur.
Dağıtılmış eğitim mimarisi açısından, TPUStrategy
aynı MirroredStrategy
- eşzamanlı dağıtılmış eğitimi uygular. TPUStrategy
, TPUStrategy
kullanılan birden çok TPU çekirdeği üzerinde kendi verimli, tümü azaltma ve diğer toplu işlem uygulamalarını sağlar.
TPUStrategy
şu şekilde başlatırsınız:
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, TPUClusterResolver
bulunmasına yardımcı olur. Colab'da herhangi bir argüman belirtmenize gerek yoktur.
Bunu Cloud TPU'lar için kullanmak istiyorsanız:
- TPU kaynağınızın adını
tpu
bağımsız değişkeninde belirtmelisiniz. - Programın başlangıcında tpu sistemini açıkça başlatmanız gerekir. TPU'ların hesaplama için kullanılabilmesi için bu gereklidir. TPU sistemini başlatmak aynı zamanda TPU belleğini de siler, bu nedenle durum kaybını önlemek için önce bu adımı tamamlamak önemlidir.
MultiWorkerMirroredStrateji
tf.distribute.MultiWorkerMirroredStrategy
, MirroredStrategy
çok benzer. Her biri potansiyel olarak birden çok GPU'ya sahip birden çok çalışan arasında eşzamanlı dağıtılmış eğitim uygular. tf.distribute.MirroredStrategy
benzer şekilde, tüm çalışanlar genelinde her cihazda modeldeki tüm değişkenlerin kopyalarını oluşturur.
MultiWorkerMirroredStrategy
oluşturmanın en basit yolu:
strategy = tf.distribute.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 = CommunicationImplementation.AUTO
MultiWorkerMirroredStrategy
, cihazlar arası iletişim için iki uygulamaya sahiptir. CommunicationImplementation.RING
, RPC tabanlıdır ve hem CPU hem de GPU'yu destekler. CommunicationImplementation.NCCL
, Nvidia'nın NCCL'sini kullanır ve GPU'da en gelişmiş performansı sağlar, ancak CPU'yu desteklemez. CollectiveCommunication.AUTO
, Tensorflow seçimini erteliyor. Bunları şu ş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:Using MirroredStrategy with devices ('/device:GPU:0',) 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, çoklu çalışan eğitimine devam etmenin en önemli farklarından biri, çok çalışanlı kurulumdur. TF_CONFIG
ortam değişkeni, TensorFlow'da kümenin parçası olan her bir çalışana küme yapılandırmasını belirtmenin standart yoludur. TF_CONFIG kurulumu hakkında daha fazla bilgi edinin.
ParameterServerStrategy
Parametre sunucusu eğitimi, birden çok makinede model eğitimini büyütmek için yaygın bir veri paralel yöntemdir. Bir parametre sunucusu eğitim kümesi, işçilerden 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. Ayrıntılar için lütfen parametre sunucusu eğitim öğreticisine bakın.
TensorFlow 2 parametre sunucusu eğitimi, tf.distribute.experimental.coordinator.ClusterCoordinator
sınıfı aracılığıyla merkezi koordinatör tabanlı bir mimari kullanır.
Bu uygulamada, worker
ve parameter server
görevleri, koordinatörden gelen görevleri dinleyen tf.distribute.Server
ı çalıştırır. Koordinatör kaynaklar oluşturur, eğitim görevlerini gönderir, kontrol noktaları yazar ve görev hatalarını ele alır.
Koordinatör üzerinde çalışan programlamada, bir eğitim adımını tanımlamak için bir ParameterServerStrategy
nesnesi ve uzaktaki çalışanlara eğitim adımlarını göndermek için bir ClusterCoordinator
kullanacaksınız. İşte onları oluşturmanı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)
TFConfigClusterResolver kullanıyorsanız, TFConfigClusterResolver
ortam değişkenini yapılandırmanız gerekeceğini TFConfigClusterResolver
. Bu benzer TF_CONFIG içinde MultiWorkerMirroredStrategy
ancak ek uyarısı var.
TF 1'de, ParameterServerStrategy
yalnızca tf.compat.v1.distribute.experimental.ParameterServerStrategy
sembolü aracılığıyla tahmin tf.compat.v1.distribute.experimental.ParameterServerStrategy
kullanılabilir.
CentralStorageStrategy
tf.distribute.experimental.CentralStorageStrategy
de eşzamanlı 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.
Şu şekilde CentralStorageStrategy
bir örneğini oluşturun:
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, tüm görünür GPU'ları ve CPU'yu kullanacak bir CentralStorageStrategy
örneği oluşturacaktır. Eşlemelerde değişkenlere yönelik güncelleme, değişkenlere uygulanmadan önce toplanacaktır.
Diğer stratejiler
Yukarıdaki stratejilere ek olarak, tf.distribute
API'lerini kullanırken prototip oluşturma ve hata ayıklama için yararlı olabilecek iki strateji daha vardır.
Varsayılan Strateji
Varsayılan strateji, kapsamda açık bir dağıtım stratejisi olmadığında mevcut olan bir dağıtım stratejisidir. tf.distribute.Strategy
arabirimini uygular, ancak bir geçiştir ve gerçek dağıtım sağlamaz. Örneğin, strategy.run(fn)
basitçe fn
çağıracaktır. 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 tekildir ve bunun daha fazla örneği oluşturulamaz. Herhangi bir açık stratejinin kapsamı dışında tf.distribute.get_strategy()
kullanılarak elde edilebilir tf.distribute.get_strategy()
geçerli stratejiyi açık bir stratejinin kapsamına almak için kullanılabilen aynı API).
default_strategy = tf.distribute.get_strategy()
Bu strateji iki ana amaca hizmet eder:
- Dağıtıma duyarlı kütüphane kodunun koşulsuz olarak yazılmasına izin verir. Örneğin,
tf.optimizer
stf.distribute.get_strategy()
kullanabilir ve bu stratejiyi degradeleri azaltmak için kullanabilir - her zaman üzerinde azaltma API'sini çağırabileceğimiz bir strateji nesnesi döndürür.
# 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 ile ve olmadan çalışmak üzere son kullanıcıların programlarını yazmak için kullanılabilir. Bunu gösteren örnek bir kod pasajı:
if tf.config.list_physical_devices('GPU'):
strategy = tf.distribute.MirroredStrategy()
else: # use 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> }
OneDeviceStrategy
tf.distribute.OneDeviceStrategy
, tüm değişkenleri ve hesaplamayı belirtilen tek bir cihaza yerleştirmek için bir stratejidir.
strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")
Bu strateji, birkaç yönden varsayılan stratejiden farklıdır. Varsayılan stratejide, değişken yerleştirme mantığı, herhangi bir dağıtım stratejisi olmadan TensorFlow'u çalıştırmaya kıyasla değişmeden kalır. Ancak OneDeviceStrategy
kullanılırken, kendi kapsamında oluşturulan tüm değişkenler açıkça belirtilen cihaza yerleştirilir. Ayrıca, OneDeviceStrategy.run
aracılığıyla OneDeviceStrategy.run
tüm işlevler de belirtilen cihaza yerleştirilecektir.
Bu strateji aracılığıyla dağıtılan giriş, belirtilen cihaza önceden getirilecektir. Varsayılan stratejide girdi dağıtımı yoktur.
Varsayılan stratejiye benzer şekilde, bu strateji, aslında birden fazla cihaza / makineye dağıtan diğer stratejilere geçmeden önce kodunuzu test etmek için de kullanılabilir. Bu, dağıtım stratejisi mekanizmasını varsayılan stratejiden biraz daha fazla uygulayacaktır, ancak tam anlamıyla MirroredStrategy
veya TPUStrategy
vb. TPUStrategy
. TPUStrategy
gibi davranan bir kod istiyorsanız, varsayılan stratejiyi kullanın.
Şimdiye kadar mevcut farklı stratejileri ve bunları nasıl başlatabileceğinizi gördünüz. Sonraki birkaç bölüm, eğitiminizi dağıtmak için bunları kullanmanın farklı yollarını gösterir.
tf.distribute.Strategy
ile tf.keras.Model.fit
tf.distribute.Strategy
, tf.keras
Keras API spesifikasyonu uygulaması olan tf.keras'a entegre edilmiştir. tf.keras
, modelleri oluşturmak ve eğitmek için kullanılan üst düzey bir API'dir. tf.keras
arka tf.keras
entegre ederek, tf.keras
eğitim çerçevesinde yazılan eğitiminizi model.fit
kullanarak model.fit
.
Kodunuzda değiştirmeniz gerekenler:
- Uygun
tf.distribute.Strategy
bir örneğini oluşturun. - Keras modeli, optimizer ve metriklerin oluşturulmasını
strategy.scope
içine taşıyın.
Sıralı, işlevsel ve alt sınıflı her tür Keras modelini destekliyoruz.
İşte tek yoğun katmana sahip çok basit bir Keras modeli için bunu yapmak için bir kod parçası:
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 örnekte MirroredStrategy
böylece bunu birden çok GPU'ya sahip bir makinede çalıştırabilirsiniz. strategy.scope()
, Keras'a eğitimi dağıtmak için hangi stratejinin kullanılacağını belirtir. Bu kapsamda modeller / optimize ediciler / metrikler oluşturmak, normal değişkenler yerine dağıtılmış değişkenler oluşturmamızı sağlar. Bu bir kez kurulduktan sonra modelinize normalde yaptığınız gibi takabilirsiniz. MirroredStrategy
, modelin mevcut GPU'lar üzerindeki eğitimini çoğaltma, gradyanları toplama ve daha fazlasıyla ilgilenir.
dataset = tf.data.Dataset.from_tensors(([1.], [1.])).repeat(100).batch(10)
model.fit(dataset, epochs=2)
model.evaluate(dataset)
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.3180 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.0246 10/10 [==============================] - 1s 2ms/step - loss: 0.5432 0.5432368516921997
Burada birtf.data.Dataset
eğitim ve değerlendirme girdisi sağlar. Ayrıca 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 10/10 [==============================] - 1s 2ms/step - loss: 0.3866 Epoch 2/2 10/10 [==============================] - 0s 2ms/step - loss: 0.1709 <tensorflow.python.keras.callbacks.History at 0x7f36bfa9fc18>
Her iki durumda da (veri kümesi veya numpy), verilen girdinin her grubu, birden çok kopya arasında eşit olarak bölünür. Örneğin, 2 GPU ile MirroredStrategy
kullanılıyorsa, 10 büyüklüğündeki her grup, her adımda 5 giriş örneği alacak şekilde 2 GPU arasında bölünecektir. Siz daha fazla GPU ekledikçe her dönem daha hızlı eğitilir. Ekstra bilgi işlem gücünden verimli bir şekilde yararlanmak için genellikle 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. Çoğaltma sayısını elde etmek için strategy.num_replicas_in_sync
kullanabilirsiniz.
# Compute global batch size using 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'si | YansıtılmışStrateji | TPUStrateji | MultiWorkerMirroredStrateji | ParameterServerStrategy | CentralStorageStrategy |
---|---|---|---|---|---|
Keras API'leri | Destekleniyor | Destekleniyor | Deneysel destek | Deneysel destek | Deneysel destek |
Örnekler ve Öğreticiler
Yukarıda Keras ile uçtan uca yukarıdaki entegrasyonu gösteren öğreticiler ve örnekler listesi:
- Öğretici, ile MNIST yetiştirmek
MirroredStrategy
. - Öğretici, MNIST kullanarak yetiştirmek
MultiWorkerMirroredStrategy
. - Kılavuzu kullanarak eğitim MNIST üzerinde
TPUStrategy
. - Öğretici, ile TensorFlow 2'de parametre sunucu eğitimi için
ParameterServerStrategy
. - Çeşitli stratejiler kullanılarak uygulanan son teknoloji model koleksiyonlarını içeren TensorFlow Model Garden deposu .
tf.distribute.Strategy
özel eğitim döngüleri ile kullanma
Gördüğünüz gibi, kullanarak tf.distribute.Strategy
Keras ile model.fit
Kodunuzdaki yalnızca birkaç hatları değişen gerektirir. Biraz daha çaba sarf tf.distribute.Strategy
özel eğitim döngüleri ile de kullanabilirsiniz.
Eğitim 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 oluşturucu veya ayırıcı adım atmak isteyebilirsiniz. Benzer şekilde, yüksek seviyeli çerçeveler Takviye Öğrenme eğitimi için çok uygun değildir.
tf.distribute.Strategy
sınıfları, özel eğitim döngülerini desteklemek için bir temel yöntem kümesi sağlar. Bunları kullanmak, başlangıçta kodun küçük çapta 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.
Burada, 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 göstereceğiz.
İlk olarak, modeli ve optimize ediciyi stratejinin kapsamında oluşturun. Bu, model ve optimize edici ile oluşturulan tüm değişkenlerin aynalanmış 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()
Ardından, girdi veri kümesini oluşturun ve veri kümesini stratejiye göre dağıtmak için tf.distribute.Strategy.experimental_distribute_dataset
çağırın.
dataset = tf.data.Dataset.from_tensors(([1.], [1.])).repeat(100).batch(
global_batch_size)
dist_dataset = mirrored_strategy.experimental_distribute_dataset(dataset)
Ardından, eğitimin bir adımını tanımlayın.tf.GradientTape
hesaplamak içintf.GradientTape
ve modelimizin değişkenlerini güncellemek için bu gradyanları uygulamak için optimize edici kullanın. 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ç nokta daha:
-
tf.nn.compute_average_loss
hesaplamak içintf.nn.compute_average_loss
kullandı.tf.nn.compute_average_loss
, örnek başına kaybı toplar ve toplamı global_batch_size'ye böler. Bu önemlidir, çünkü daha sonra degradeler her eşlemede hesaplandıktan sonra, eşlemelerde toplanarak toplanırlar. -
tf.distribute.Strategy.reduce
tarafından döndürülen sonuçları toplamak içintf.distribute.Strategy.reduce
API'sinitf.distribute.Strategy.run
.tf.distribute.Strategy.run
, stratejideki her yerel eşlemenin sonuçlarını döndürür ve bu sonucu kullanmanın birden çok yolu vardır. Toplu bir değer elde etmek için bunlarıreduce
. Sonuçta yer alan değerlerin listesini yerel eşleme başına bir tane almak içintf.distribute.Strategy.experimental_local_results
da yapabilirsiniz. -
apply_gradients
bir dağıtım stratejisi kapsamında çağrıldığında, davranışı değiştirilir. Spesifik olarak, eşzamanlı eğitim sırasında her paralel örneğe degradeler uygulamadan önce, degradelerin tüm kopyalarının bir toplamını gerçekleştirir.
Son olarak, eğitim adımını tanımladıktan sonra, dist_dataset
üzerinde dist_dataset
ve eğitimi bir döngü içinde çalıştırabiliriz:
for dist_inputs in dist_dataset:
print(distributed_train_step(dist_inputs))
tf.Tensor(0.7167484, shape=(), dtype=float32) tf.Tensor(0.71152556, shape=(), dtype=float32) tf.Tensor(0.70635474, shape=(), dtype=float32) tf.Tensor(0.7012355, shape=(), dtype=float32) tf.Tensor(0.6961673, shape=(), dtype=float32) tf.Tensor(0.6911497, shape=(), dtype=float32) tf.Tensor(0.6861821, shape=(), dtype=float32) tf.Tensor(0.6812641, shape=(), dtype=float32) tf.Tensor(0.6763952, shape=(), dtype=float32) tf.Tensor(0.6715747, shape=(), dtype=float32) tf.Tensor(0.66680235, shape=(), dtype=float32) tf.Tensor(0.6620776, shape=(), dtype=float32) tf.Tensor(0.6573999, shape=(), dtype=float32) tf.Tensor(0.65276873, shape=(), dtype=float32) tf.Tensor(0.6481838, shape=(), dtype=float32) tf.Tensor(0.6436445, shape=(), dtype=float32) tf.Tensor(0.6391503, shape=(), dtype=float32) tf.Tensor(0.63470083, shape=(), dtype=float32) tf.Tensor(0.6302957, shape=(), dtype=float32) tf.Tensor(0.6259341, shape=(), dtype=float32)
Yukarıdaki örnekte, eğitiminize girdi sağlamak için dist_dataset
üzerinde yineleme dist_dataset
. Ayrıca, numpy girişlerini desteklemek için tf.distribute.Strategy.make_experimental_numpy_dataset
de sağlıyoruz. tf.distribute.Strategy.experimental_distribute_dataset
çağırmadan önce bir veri kümesi oluşturmak için bu API'yi kullanabilirsiniz.
Verileriniz üzerinde yineleme yapmanın başka bir yolu da yineleyicileri açıkça kullanmaktır. Tüm veri kümesini yinelemek yerine belirli sayıda adım için çalıştırmak istediğinizde bunu yapmak isteyebilirsiniz. Yukarıdaki yineleme, şimdi ilk önce bir yineleyici oluşturmak ve ardından giriş verilerini almak için açıkça bir next
çağrı yapmak için değiştirilecektir.
iterator = iter(dist_dataset)
for _ in range(10):
print(distributed_train_step(next(iterator)))
tf.Tensor(0.62161595, shape=(), dtype=float32) tf.Tensor(0.6173406, shape=(), dtype=float32) tf.Tensor(0.6131077, shape=(), dtype=float32) tf.Tensor(0.60891676, shape=(), dtype=float32) tf.Tensor(0.60476726, shape=(), dtype=float32) tf.Tensor(0.60065883, shape=(), dtype=float32) tf.Tensor(0.59659094, shape=(), dtype=float32) tf.Tensor(0.5925633, shape=(), dtype=float32) tf.Tensor(0.5885753, shape=(), dtype=float32) tf.Tensor(0.5846267, shape=(), dtype=float32)
Bu, özel eğitim döngülerini dağıtmak için tf.distribute.Strategy
API'sini kullanmanın en basit durumunu kapsar.
Şimdi ne destekleniyor?
Eğitim API'si | YansıtılmışStrateji | TPUStrateji | MultiWorkerMirroredStrateji | ParameterServerStrategy | CentralStorageStrategy |
---|---|---|---|---|---|
Özel Eğitim Döngüsü | Destekleniyor | Destekleniyor | Deneysel destek | Deneysel destek | Deneysel destek |
Örnekler ve Öğreticiler
Aşağıda, özel eğitim döngüleri ile dağıtım stratejisinin kullanımına ilişkin bazı örnekler verilmiştir:
- Öğretici, MNIST kullanarak yetiştirmek
MirroredStrategy
. - Kılavuzu kullanarak eğitim MNIST üzerinde
TPUStrategy
. - Çeşitli stratejiler kullanılarak uygulanan son teknoloji model koleksiyonlarını içeren TensorFlow Model Garden deposu .
Diğer başlıklar
Bu bölüm, çoklu kullanım durumlarıyla ilgili bazı konuları kapsar.
TF_CONFIG ortam değişkenini ayarlama
Çok çalışanı olan eğitim için, daha önce belirtildiği gibi, TF_CONFIG
çalışan her ikili program için TF_CONFIG
ortam değişkenini ayarlamanız gerekir. TF_CONFIG
ortam değişkeni, hangi görevlerin bir kümeyi oluşturduğunu, adreslerini ve kümedeki her görevin rolünü belirten bir JSON dizesidir. Tensorflow / ekosistem TF_CONFIG
, eğitim görevleriniz için TF_CONFIG
ayarlayan bir Kubernetes şablonu sağlar.
TF_CONFIG'in iki bileşeni vardır: küme ve görev. küme, işçi gibi farklı iş türlerinden oluşan bir dikt olan eğitim kümesi hakkında bilgi sağlar. Çok işçi eğitiminde, normal bir işçinin yaptıklarına ek olarak, kontrol noktasını kaydetmek ve TensorBoard için özet dosyası yazmak gibi biraz daha fazla sorumluluk alan genellikle bir işçi vardır. Bu tür işçi 'baş' işçi olarak adlandırılır ve endeksi 0 olan işçinin baş işçi olarak atanması gelenekseldir (aslında tf.distribute.Strategy böyle uygulanır). görev ise mevcut görevle ilgili bilgi sağlar. İlk bileşen kümesi tüm çalışanlar için aynıdır ve ikinci bileşen görevi her çalışanda farklıdır ve o çalışanın türünü ve dizinini belirtir.
TF_CONFIG
bir örnek:
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
, ana bilgisayarları ve bağlantı noktaları ile birlikte kümede üç çalışan ve iki ps görevi olduğunu belirtir. "Görev" bölümü, kümedeki mevcut görevin rolünün, işçi 1'in (ikinci çalışan) olduğunu belirtir. Bir kümede geçerli roller "şef", "işçi", "ps" ve "değerlendirici" dir. tf.distribute.experimental.ParameterServerStrategy
kullanılması dışında "ps" işi tf.distribute.experimental.ParameterServerStrategy
.
Sıradaki ne?
tf.distribute.Strategy
aktif olarak geliştirilme aşamasındadır. Deneyin ve GitHub sorunlarını kullanarak geri bildiriminizi sağlayın.