TensorFlow ile dağıtılmış eğitim

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

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

Kaynağı GitHub'da görüntüleyin

Defteri indirin

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 şekilde 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ında nasıl hata ayıklanacağını öğrenmek için TensorFlow GPU Performansını Optimize Etme kılavuzuna bakın.

# 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ı şunlardır:

• 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 verileri 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 birden çok makineye (her biri 0 veya daha fazla GPU'ya sahip) 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ış:

YansıtılmışStrateji

tf.distribute.MirroredStrategy , 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. Bu, ç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, tamamen 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şlatmalısınız . 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 son teknoloji 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, kümenin parçası olan her çalışan için küme yapılandırmasını belirtmenin TensorFlow'daki 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 başarısızlıkları ile ilgilenir.

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 bir CentralStorageStrategy örneği 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 s tf.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 çalıştırmaya kıyasla değişmeden kalır. Ancak OneDeviceStrategy kullanılırken, 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 aygıta 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 . Hiçbir strateji yokmuş gibi davranan bir kod istiyorsanız, varsayılan stratejiyi kullanın.

Şimdiye kadar, mevcut farklı stratejileri ve bunları nasıl somutlaştırabileceğ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:

1. Uygun tf.distribute.Strategy bir örneğini oluşturun.
2. Keras modelinin, optimizasyonunun 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 örnek, 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 dizileri 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ıyorsanız, 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ı almak 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?

Örnekler ve Öğreticiler

Yukarıda Keras ile uçtan uca yukarıdaki entegrasyonu gösteren öğretici ve örneklerin bir listesi:

1. Öğretici, ile MNIST yetiştirmek MirroredStrategy .
2. Öğretici, MNIST kullanarak yetiştirmek MultiWorkerMirroredStrategy .
3. Kılavuzu kullanarak eğitim MNIST üzerinde TPUStrategy .
4. Öğretici, ile TensorFlow 2'de parametre sunucu eğitimi için ParameterServerStrategy .
5. Ç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 Pekiştirmeli Öğ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 snippet göstereceğiz.

İlk olarak, modeli ve optimize ediciyi stratejinin kapsamı içinde 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 degradeleri 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:

1. tf.nn.compute_average_loss hesaplamak için tf.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 bir eşlemede hesaplandıktan sonra, eşlemelerde toplanarak toplanırlar.
2. tf.distribute.Strategy.reduce tarafından döndürülen sonuçları toplamak için tf.distribute.Strategy.reduce API'sini tf.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çin tf.distribute.Strategy.experimental_local_results da yapabilirsiniz.
3. 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 yinelendiniz. 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 açıkça yineleyiciler 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 bir şekilde 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?

Ö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:

1. Öğretici, MNIST kullanarak yetiştirmek MirroredStrategy .
2. Kılavuzu kullanarak eğitim MNIST üzerinde TPUStrategy .
3. Ç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.