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

TensorFlow.org üzerinde görüntüle

Google Colab'da yayınla

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

Not defterini indir

genel bakış

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

tf.distribute.Strategy şu temel hedefler göz önünde bulundurularak tasarlanmıştır:

• Kullanımı kolay ve araştırmacılar, ML mühendisleri vb.Dahil olmak üzere birden fazla kullanıcı segmentini destekliyor.
• 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 tf.function komutunu kullanarak programlarınızı hevesli bir şekilde veya bir grafikte tf.function . tf.distribute.Strategy , her iki yürütme modunu da desteklemeyi tf.distribute.Strategy , ancak en iyi tf.function ile tf.function . İstekli mod yalnızca hata ayıklama amacıyla önerilir ve TPUStrategy için desteklenmez. Bu kılavuzda çoğu zaman eğitimi tartışmamıza rağmen, bu API aynı zamanda farklı platformlarda değerlendirme ve tahmin dağıtmak için de kullanılabilir.

tf.distribute.Strategy çok az değişiklik yaparak tf.distribute.Strategy kullanabilirsiniz, çünkü TensorFlow'un temel bileşenlerini stratejiye duyarlı hale getirdik. Buna değişkenler, katmanlar, modeller, optimize ediciler, metrikler, özetler ve kontrol noktaları dahildir.

Bu kılavuzda, çeşitli strateji türlerini ve bunları farklı durumlarda nasıl kullanabileceğinizi açıklıyoruz.

 # Import TensorFlow
import tensorflow as tf
 

Strateji türleri

tf.distribute.Strategy , farklı eksenler boyunca bir dizi kullanım durumunu tf.distribute.Strategy amaçlamaktadır. Bu kombinasyonların bazıları şu anda desteklenmektedir ve diğerleri gelecekte eklenecektir. Bu eksenlerden bazıları:

• Senkronize ve asenkronize eğitim: Bunlar, veri paralelliği ile eğitimi dağıtmanın iki yaygın yoludur. Senkronizasyon eğitiminde, tüm çalışanlar senkronizasyonda farklı giriş verileri dilimleri ve her adımda degradeleri toplayarak eğitim alır. Zaman uyumsuz eğitimde, tüm çalışanlar bağımsız olarak girdi verileri üzerinde eğitim alır ve değişkenleri zaman uyumsuz olarak günceller. Eşitleme eğitimi genellikle parametre azaltma mimarisi aracılığıyla all-reduce ve async aracılığıyla desteklenir.
• Donanım platformu: Eğitiminizi bir makinedeki birden fazla GPU'ya veya bir ağdaki (her biri 0 veya daha fazla GPU içeren) veya Cloud TPU'lardaki birden fazla makineye ölçeklendirmek isteyebilirsiniz.

Bu kullanım örneklerini desteklemek için altı strateji vardır. Bir sonraki bölümde, şu anda TF 2.2'deki hangi senaryolarda hangilerinin desteklendiğini açıklayacağız. İşte hızlı bir genel bakış:

MirroredStrategy

tf.distribute.MirroredStrategy bir makinede birden fazla GPU üzerinde senkronize dağıtılmış eğitimi destekler. GPU cihazı başına bir çoğaltma oluşturur. Modeldeki her değişken, tüm kopyalara yansıtılır. Bu değişkenler birlikte MirroredVariable adı verilen tek bir kavramsal değişken oluşturur. Bu değişkenler, özdeş güncellemeler uygulanarak birbirleriyle senkronize tutulur.

Değişken güncelleştirmeleri aygıtlar arasında iletmek için etkin tüm azaltma algoritmaları kullanılır. Tümü azalt, tansörleri tüm aygıtlarda toplayarak toplar ve her aygıtta kullanılabilir hale getirir. Çok verimli ve senkronizasyon yükünü önemli ölçüde azaltabilen kaynaşmış bir algoritmadır. Cihazlar arasındaki iletişim türüne bağlı olarak, pek çok indirgeme algoritması ve uygulaması vardır. Varsayılan olarak, all-reduce uygulaması olarak NVIDIA NCCL kullanır. Sunduğumuz diğer birkaç seçenek arasından seçim yapabilir veya kendiniz yazabilirsiniz.

İşte 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ı ve cihazlar arası iletişim olarak NCCL'yi kullanan bir MirroredStrategy örneği oluşturur.

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',)

TPUStrategy

tf.distribute.TPUStrategy , TensorFlow eğitiminizi Tensor İşleme Üniteleri (TPU'lar) üzerinde çalıştırmanızı sağlar. TPU'lar, makine öğrenimi iş yüklerini önemli ölçüde hızlandırmak için tasarlanmış Google'ın özel ASIC'leri. Google Colab, TensorFlow Research Cloud ve Cloud TPU'da mevcuttur.

Dağıtılmış eğitim mimarisi açısından, TPUStrategy aynı MirroredStrategy - senkronize dağıtılmış eğitim uygular. TPUStrategy , TPUStrategy kullanılan birden fazla TPU çekirdeğinde etkili tüm azaltma ve diğer toplu operasyonları kendi uygulamalarını TPUStrategy .

TPUStrategy nasıl başlatacağınız aşağıda 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, TPUClusterResolver bulunmasına yardımcı olur. Colab'da, herhangi bir argüman belirtmenize gerek yoktur.

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 tpu sistemini açıkça başlatmalısınız . TPU'ların hesaplama için kullanılabilmesi için bu gereklidir. TPU sisteminin başlatılması da TPU belleğini siler, bu nedenle durumun kaybolmasını önlemek için önce bu adımı tamamlamak önemlidir.

MultiWorkerMirroredStrategy

tf.distribute.experimental.MultiWorkerMirroredStrategy MirroredStrategy çok benzer. Her biri potansiyel olarak birden fazla GPU'ya sahip birden fazla işçi arasında senkronize dağıtılmış eğitim uygular. MirroredStrategy benzer şekilde, tüm çalışanlarda her cihazda modeldeki tüm değişkenlerin kopyalarını oluşturur.

Değişkenleri senkronize tutmak için kullanılan çok çalışanlı tüm azaltma iletişim yöntemi olarak CollectiveOps'u kullanır. Kolektif op, TensorFlow grafiğinde, donanım, ağ topolojisi ve tensör boyutlarına göre TensorFlow çalışma zamanında otomatik olarak tümüyle azaltma algoritmasını seçebilen tek bir op'dur.

Ayrıca ek performans optimizasyonları uygular. Örneğin, küçük tansörler üzerindeki birden fazla tüm küçültmeyi daha büyük tansörler üzerindeki daha az tam küçültmeye dönüştüren statik bir optimizasyon içerir. Buna ek olarak, bir eklenti mimarisine sahip olacak şekilde tasarlıyoruz - böylece gelecekte donanımınız için daha iyi ayarlanmış algoritmaları ekleyebileceksiniz. Kolektif operasyonların yayın ve toplanma gibi diğer kolektif operasyonları da uyguladığını unutmayın.

İşte MultiWorkerMirroredStrategy oluşturmanın en basit yolu:

 multiworker_strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()
 

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

MultiWorkerMirroredStrategy şu anda kolektif operasyonların iki farklı uygulaması arasında seçim yapmanıza izin veriyor. CollectiveCommunication.RING , iletişim katmanı olarak gRPC kullanarak halka tabanlı kolektifler uygular. CollectiveCommunication.NCCL , kolektifleri uygulamak için Nvidia'nın NCCL'sini kullanır. CollectiveCommunication.AUTO seçimi çalışma zamanına göre değiştirir. En iyi toplu uygulama seçimi GPU'ların sayısına ve türüne ve kümedeki ağ bağlantısına bağlıdır. Bunları aşağıdaki şekilde belirleyebilirsiniz:

 multiworker_strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy(
    tf.distribute.experimental.CollectiveCommunication.NCCL)
 

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

Çok GPU eğitimine kıyasla çok çalışanlı eğitimin devam etmesini sağlayan önemli farklılıklardan biri de çok çalışanlı kurulumdur. TF_CONFIG ortam değişkeni, TensorFlow öğesinde, kümenin bir parçası olan her çalışan için küme yapılandırmasını belirtmenin standart yoludur. TF_CONFIG kurulumu hakkında daha fazla bilgi edinin.

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 bu GPU'ya yerleştirilir.

CentralStorageStrategy örneğini şu şekilde 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şturur. Çoğaltmalardaki değişkenlerin güncelleştirilmesi, değişkenlere uygulanmadan önce toplanır.

ParameterServerStrategy

tf.distribute.experimental.ParameterServerStrategy , birden çok makinede parametre sunucusu eğitimini destekler. Bu kurulumda, bazı makineler işçi, bazıları ise parametre sunucuları olarak belirlenmiştir. Modelin her değişkeni bir parametre sunucusuna yerleştirilir. Hesaplama, tüm çalışanların tüm GPU'larında çoğaltılır.

Kod açısından, diğer stratejilere benzer:

 ps_strategy = tf.distribute.experimental.ParameterServerStrategy()
 

Çok çalışanlı eğitim için, TF_CONFIG , TF_CONFIG parametre sunucuları ve çalışanlarının yapılandırmasını belirtmesi gerekir; bunlar hakkında TF_CONFIG'den daha fazla bilgi edinebilirsiniz .

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 doğrudan tf.distribute.Strategy ve gerçek bir dağıtım sağlamaz. Örneğin, strategy.run(fn) sadece fn çağırır. Bu strateji kullanılarak yazılan kod, herhangi bir strateji olmadan yazılan kod gibi davranmalıdır. Bunu "hayır-op" stratejisi olarak düşünebilirsiniz.

Varsayılan strateji bir singleton - ve biri daha fazla örnek oluşturamaz. Herhangi bir açık stratejinin kapsamı dışında (geçerli stratejiyi açık bir stratejinin kapsamına almak için kullanılabilen aynı API tf.distribute.get_strategy() dışında tf.distribute.get_strategy() kullanılarak elde edilebilir.

 default_strategy = tf.distribute.get_strategy()
 

Bu strateji iki ana amaca hizmet eder:

• Koşulsuz dağıtım farkındalık kitaplığı kodu yazma sağlar. Örneğin, optimizer'da tf.distribute.get_strategy() ve degradeleri azaltmak için bu stratejiyi kullanabiliriz - her zaman azaltma API'sı olarak adlandı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 olan ve olmayan son kullanıcıların programlarını yazmak için kullanılabilir. Bunu gösteren bir örnek 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.))
 

<tf.Variable 'Variable:0' shape=() dtype=float32, numpy=1.0>

OneDeviceStrategy

tf.distribute.OneDeviceStrategy , tüm değişkenleri ve hesaplamaları belirtilen tek bir aygıta yerleştirme stratejisidir.

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

Bu strateji, çeşitli yollarla varsayılan stratejiden farklıdır. Varsayılan stratejide, değişken yerleşim mantığı herhangi bir dağıtım stratejisi olmadan TensorFlow'u çalıştırmayla karşılaştırıldığında değişmeden kalır. Ancak OneDeviceStrategy kullanırken, kapsamında oluşturulan tüm değişkenler açıkça belirtilen cihaza yerleştirilir. Ayrıca, OneDeviceStrategy.run üzerinden OneDeviceStrategy.run işlevler de belirtilen cihaza yerleştirilecektir.

Bu strateji ile dağıtılan girdi 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ğıtılan diğer stratejilere geçmeden önce kodunuzu test etmek için de kullanılabilir. Bu, dağıtım stratejisi makinelerini varsayılan stratejiden biraz daha fazla kullanır, ancak tam olarak MirroredStrategy veya TPUStrategy vb. Gibi kullanmaz.

Şimdiye kadar mevcut olan farklı stratejiler ve bunları nasıl somutlaştırabileceğiniz hakkında konuştuk. Önümüzdeki birkaç bölümde, eğitiminizi dağıtmak için bunları kullanabileceğiniz farklı yollar hakkında konuşacağız. Bu kılavuzda kısa kod parçacıkları göstereceğiz ve uçtan uca çalıştırabileceğiniz tüm eğiticilere bağlantı vereceğiz.

tf.distribute.Strategy ile tf.keras.Model.fit

tf.distribute.Strategy , tf.keras Keras API spesifikasyonunu uygulaması olan tf.keras entegre ettik. tf.keras , modeller oluşturmak ve eğitmek için üst düzey bir API'dir. tf.keras arka tf.keras entegre olarak, tf.keras kullanarak model.fit eğitim çerçevesinde yazılmış eğitiminizi dağıtmanızı kesintisiz hale model.fit .

Kodunuzda değiştirmeniz gerekenler:

1. Uygun tf.distribute.Strategy örneğini oluşturun.
2. Keras modelinin, optimize edicinin ve metriklerin oluşturulmasını strategy.scope içine taşıyın.

Her türlü Keras modelini destekliyoruz - sıralı, fonksiyonel ve alt sınıf.

Yoğun bir katmana sahip çok basit bir Keras modeli için bunu yapmak için bir kod snippet'i:

 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',)

Bu örnekte MirroredStrategy kullandık, böylece bunu birden fazla GPU'lu bir makinede çalıştırabiliriz. strategy.scope() , Keras'a eğitimi dağıtmak için hangi stratejiyi kullanacağını belirtir. Bu kapsamda modeller / optimize ediciler / metrikler oluşturmak, normal değişkenler yerine dağıtılmış değişkenler oluşturmamıza olanak tanır. Bu ayarlandıktan sonra, modelinizi normalde yaptığınız gibi sığdırabilirsiniz. MirroredStrategy , modelin mevcut GPU'lar, toplu degradeler ve daha fazlası hakkındaki eğitimini tekrarlamaya özen gösterir.

 dataset = tf.data.Dataset.from_tensors(([1.], [1.])).repeat(100).batch(10)
model.fit(dataset, epochs=2)
model.evaluate(dataset)
 

Epoch 1/2
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/data/ops/multi_device_iterator_ops.py:601: get_next_as_optional (from tensorflow.python.data.ops.iterator_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.data.Iterator.get_next_as_optional()` instead.
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 [==============================] - 0s 2ms/step - loss: 1.0035
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 1ms/step - loss: 0.4436
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 [==============================] - 0s 1ms/step - loss: 0.2755

0.27546340227127075

Burada eğitim ve değerlendirme girdisini sağlamak için bir tf.data.Dataset kullandık. Ayrıca, sayısal diziler 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 [==============================] - 0s 1ms/step - loss: 0.1961
Epoch 2/2
10/10 [==============================] - 0s 1ms/step - loss: 0.0867

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

Her iki durumda da (veri kümesi veya numpy), verilen girdinin her bir 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 parti 2 GPU arasında bölünecek ve her adımda 5 giriş örneği alacaktır. Daha fazla GPU ekledikçe her dönem daha hızlı antrenman yapar. Genellikle, daha fazla hızlandırıcı ekledikçe, ekstra bilgi işlem gücünü etkili bir şekilde kullanmak için toplu iş boyutunuzu artırmak istersiniz. Modele bağlı olarak öğrenme hızı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 neler destekleniyor?

Örnekler ve Eğiticiler

Keras ile uçtan uca yukarıdaki entegrasyonu gösteren öğreticilerin ve örneklerin 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. TensorFlow Modeli Çeşitli stratejiler kullanılarak uygulanan son model modellerin koleksiyonlarını içeren Garden deposu .

Özel eğitim döngülerinde tf.distribute.Strategy kullanma

Gördüğünüz gibi, tf.distribute.Strategy ile model.fit kullanmak, tf.distribute.Strategy yalnızca birkaç satırını değiştirmeyi gerektirir. Biraz daha fazla çaba ile, tf.distribute.Strategy özel eğitim döngülerinde de kullanabilirsiniz.

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

Özel eğitim döngülerini desteklemek için, tf.distribute.Strategy sınıfları aracılığıyla temel bir yöntem kümesi tf.distribute.Strategy . Bunları kullanmak, başlangıçta kodun küçük bir şekilde yeniden yapılandırılmasını gerektirebilir, ancak bir kez yapıldığında, sadece 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ında yaratırız. Bu, model ve iyileştirici ile oluşturulan 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()
 

Ardından, giriş veri kümesini oluştururuz ve veri kümesini stratejiye göre dağıtmak için tf.distribute.Strategy.experimental_distribute_dataset .

 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ımlarız. tf.GradientTape hesaplamak için tf.GradientTape ve modelimizin değişkenlerini güncellemek amacıyla bu degradeleri uygulamak için kullanacağız. Bu eğitim adımı dağıtmak için, bir fonksiyon koymak train_step ve geçmek tf.distrbute.Strategy.run biz aldığım o 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:

1. tf.nn.compute_average_loss hesaplamak için tf.nn.compute_average_loss kullandık. tf.nn.compute_average_loss örnek başına kayıpları toplar ve toplamı global_batch_size ile böler. Bu önemlidir, çünkü daha sonra her bir kopyada degradeler hesaplandıktan sonra, kopyalar toplanarak çoğaltılır.
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 çoğaltmanın sonuçlarını döndürür ve bu sonucu kullanmanın birden çok yolu vardır. Birleştirilmiş bir değer elde etmek için bunları reduce . Ayrıca, tf.distribute.Strategy.experimental_local_results bulunan değerlerin listesini her yerel çoğaltma için bir tane almak için tf.distribute.Strategy.experimental_local_results yapabilirsiniz.
3. apply_gradients bir dağıtım stratejisi kapsamında çağrıldığında davranışı değiştirilir. Özellikle, eşzamanlı eğitim sırasında her bir paralel örneğe degradeler uygulamadan önce, degradelerin toplam kopyalarının bir toplamını gerçekleştirir.

Son olarak, eğitim adımını tanımladıktan sonra dist_dataset üzerinde yineleme yapabilir ve eğitimi bir döngüde çalıştırabiliriz:

 for dist_inputs in dist_dataset:
  print(distributed_train_step(dist_inputs))
 

tf.Tensor(0.4155251, shape=(), dtype=float32)
tf.Tensor(0.41321823, shape=(), dtype=float32)
tf.Tensor(0.4109319, shape=(), dtype=float32)
tf.Tensor(0.40866604, shape=(), dtype=float32)
tf.Tensor(0.40642032, shape=(), dtype=float32)
tf.Tensor(0.40419456, shape=(), dtype=float32)
tf.Tensor(0.4019885, shape=(), dtype=float32)
tf.Tensor(0.399802, shape=(), dtype=float32)
tf.Tensor(0.39763477, shape=(), dtype=float32)
tf.Tensor(0.3954866, shape=(), dtype=float32)
tf.Tensor(0.39335734, shape=(), dtype=float32)
tf.Tensor(0.3912467, shape=(), dtype=float32)
tf.Tensor(0.38915452, shape=(), dtype=float32)
tf.Tensor(0.38708064, shape=(), dtype=float32)
tf.Tensor(0.38502476, shape=(), dtype=float32)
tf.Tensor(0.38298675, shape=(), dtype=float32)
tf.Tensor(0.38096642, shape=(), dtype=float32)
tf.Tensor(0.3789635, shape=(), dtype=float32)
tf.Tensor(0.3769779, shape=(), dtype=float32)
tf.Tensor(0.37500936, shape=(), dtype=float32)

Yukarıdaki örnekte, eğitiminize girdi sağlamak için dist_dataset üzerinden dist_dataset . Ayrıca, tf.distribute.Strategy.make_experimental_numpy_dataset girişleri 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'yı kullanabilirsiniz.

Verilerinizi yinelemenin başka bir yolu, yinelemeleri açıkça kullanmaktır. Tüm veri kümesini yinelemenin aksine, belirli sayıda adım için çalıştırmak istediğinizde bunu yapmak isteyebilirsiniz. Yukarıdaki yineleme, ilk olarak bir yineleyici oluşturmak ve daha sonra giriş verilerini almak için açıkça bir next çağırmak için değiştirilecektir.

 iterator = iter(dist_dataset)
for _ in range(10):
  print(distributed_train_step(next(iterator)))
 

tf.Tensor(0.37305772, shape=(), dtype=float32)
tf.Tensor(0.3711228, shape=(), dtype=float32)
tf.Tensor(0.3692044, shape=(), dtype=float32)
tf.Tensor(0.36730233, shape=(), dtype=float32)
tf.Tensor(0.3654165, shape=(), dtype=float32)
tf.Tensor(0.36354658, shape=(), dtype=float32)
tf.Tensor(0.36169255, shape=(), dtype=float32)
tf.Tensor(0.3598542, shape=(), dtype=float32)
tf.Tensor(0.35803124, shape=(), dtype=float32)
tf.Tensor(0.3562236, 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. Bu API'ları geliştirme sürecindeyiz. Bu kullanım durumu kodunuzu uyarlamak için daha fazla çalışma gerektirdiğinden, gelecekte ayrı bir ayrıntılı kılavuz yayınlayacağız.

Şimdi neler destekleniyor?

Örnekler ve Eğiticiler

Özel eğitim döngülerinde dağıtım stratejisini kullanmak için bazı örnekler:

1. Öğretici, MNIST kullanarak yetiştirmek MirroredStrategy .
2. Kılavuzu kullanarak eğitim MNIST üzerinde TPUStrategy .
3. TensorFlow Modeli Çeşitli stratejiler kullanılarak uygulanan en son model modellerin koleksiyonlarını içeren Garden deposu .

Tahmincisi ile tf.distribute.Strategy kullanma (Sınırlı destek)

tf.estimator async parametre sunucusu yaklaşımını başlangıçta destekleyen dağıtılmış bir eğitim TensorFlow API'sıdır. tf.distribute.Strategy , tf.Estimator entegre ettik. Eğitiminiz için Tahmin Edici'yi kullanıyorsanız, kodunuzda çok az değişiklik yaparak dağıtılmış eğitime kolayca geçebilirsiniz. Bununla, Tahmincisi kullanıcılar artık birden fazla GPU ve birden fazla çalışan üzerinde eşzamanlı dağıtılmış eğitim yapabilir ve TPU kullanabilirler. Tahmin edicideki bu destek sınırlıdır. Daha fazla ayrıntı için aşağıdaki Şimdi desteklenenler bölümüne bakın.

Tahmincisi ile tf.distribute.Strategy kullanımı tf.distribute.Strategy durumundan biraz farklıdır. strategy.scope kullanmak yerine, şimdi strateji nesnesini Tahmincisi için RunConfig .

İşte bunu önceden yapılmış bir Tahmincisi LinearRegressor ve MirroredStrategy ile gösteren bir kod snippet'i:

 mirrored_strategy = tf.distribute.MirroredStrategy()
config = tf.estimator.RunConfig(
    train_distribute=mirrored_strategy, eval_distribute=mirrored_strategy)
regressor = tf.estimator.LinearRegressor(
    feature_columns=[tf.feature_column.numeric_column('feats')],
    optimizer='SGD',
    config=config)
 

INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)
INFO:tensorflow:Initializing RunConfig with distribution strategies.
INFO:tensorflow:Not using Distribute Coordinator.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmp2ack9oru
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp2ack9oru', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': <tensorflow.python.distribute.mirrored_strategy.MirroredStrategy object at 0x7fa124522b38>, '_device_fn': None, '_protocol': None, '_eval_distribute': <tensorflow.python.distribute.mirrored_strategy.MirroredStrategy object at 0x7fa124522b38>, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1, '_distribute_coordinator_mode': None}

Burada önceden hazırlanmış bir Tahmincisi kullanıyoruz, ancak aynı kod özel bir Tahmincisi ile de çalışıyor. train_distribute eğitimin nasıl dağıtılacağını belirler ve eval_distribute değerlendirmenin nasıl dağıtılacağını belirler. Bu, hem eğitim hem de değerlendirme için aynı stratejiyi kullandığımız Keras'tan başka bir fark.

Şimdi bu Tahmincisi bir giriş fonksiyonu ile eğitebilir ve değerlendirebiliriz:

 def input_fn():
  dataset = tf.data.Dataset.from_tensors(({"feats":[1.]}, [1.]))
  return dataset.repeat(1000).batch(10)
regressor.train(input_fn=input_fn, steps=10)
regressor.evaluate(input_fn=input_fn, steps=10)
 

INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_estimator/python/estimator/canned/linear.py:1481: Layer.add_variable (from tensorflow.python.keras.engine.base_layer_v1) is deprecated and will be removed in a future version.
Instructions for updating:
Please use `layer.add_weight` method instead.
INFO:tensorflow:Done calling model_fn.
WARNING:tensorflow:AutoGraph could not transform <function _combine_distributed_scaffold.<locals>.<lambda> at 0x7fa12452cb70> and will run it as-is.
Cause: could not parse the source code:

      lambda scaffold: scaffold.ready_op, args=(grouped_scaffold,))

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
WARNING: AutoGraph could not transform <function _combine_distributed_scaffold.<locals>.<lambda> at 0x7fa12452cb70> and will run it as-is.
Cause: could not parse the source code:

      lambda scaffold: scaffold.ready_op, args=(grouped_scaffold,))

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
INFO:tensorflow:Create CheckpointSaverHook.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_estimator/python/estimator/util.py:96: DistributedIteratorV1.initialize (from tensorflow.python.distribute.input_lib) is deprecated and will be removed in a future version.
Instructions for updating:
Use the iterator's `initializer` property instead.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp2ack9oru/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 1.0, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 10...
INFO:tensorflow:Saving checkpoints for 10 into /tmp/tmp2ack9oru/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 10...
INFO:tensorflow:Loss for final step: 2.877698e-13.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
WARNING:tensorflow:AutoGraph could not transform <function _combine_distributed_scaffold.<locals>.<lambda> at 0x7fa1e9768d08> and will run it as-is.
Cause: could not parse the source code:

      lambda scaffold: scaffold.ready_op, args=(grouped_scaffold,))

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
WARNING: AutoGraph could not transform <function _combine_distributed_scaffold.<locals>.<lambda> at 0x7fa1e9768d08> and will run it as-is.
Cause: could not parse the source code:

      lambda scaffold: scaffold.ready_op, args=(grouped_scaffold,))

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
INFO:tensorflow:Starting evaluation at 2020-08-04T20:28:12Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmp2ack9oru/model.ckpt-10
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/10]
INFO:tensorflow:Evaluation [2/10]
INFO:tensorflow:Evaluation [3/10]
INFO:tensorflow:Evaluation [4/10]
INFO:tensorflow:Evaluation [5/10]
INFO:tensorflow:Evaluation [6/10]
INFO:tensorflow:Evaluation [7/10]
INFO:tensorflow:Evaluation [8/10]
INFO:tensorflow:Evaluation [9/10]
INFO:tensorflow:Evaluation [10/10]
INFO:tensorflow:Inference Time : 0.20350s
INFO:tensorflow:Finished evaluation at 2020-08-04-20:28:12
INFO:tensorflow:Saving dict for global step 10: average_loss = 1.4210855e-14, global_step = 10, label/mean = 1.0, loss = 1.4210855e-14, prediction/mean = 0.99999994
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 10: /tmp/tmp2ack9oru/model.ckpt-10

{'average_loss': 1.4210855e-14,
 'label/mean': 1.0,
 'loss': 1.4210855e-14,
 'prediction/mean': 0.99999994,
 'global_step': 10}

Burada Tahmincisi ile Keras arasında vurgulanması gereken bir diğer fark girdi işleme. Keras'ta, veri kümesinin her grubunun otomatik olarak çoklu kopyalara bölündüğünden bahsettik. Bununla birlikte, Tahmincide, toplu işin otomatik olarak bölünmesini veya verileri farklı çalışanlar arasında otomatik olarak parçalamıyoruz. Verilerinizin çalışanlar ve cihazlar arasında nasıl dağıtılmasını istediğiniz üzerinde tam kontrole sahipsiniz ve verilerinizin nasıl dağıtılacağını belirlemek için bir input_fn sağlamanız gerekir.

input_fn değeriniz çalışan başına bir kez çağrılır, böylece çalışan başına bir veri kümesi verilir. Daha sonra bu veri kümesinden bir toplu iş, o işçideki bir çoğaltmaya beslenir, böylece 1 işçideki N kopyaları için N toplu iş tüketilir. Başka bir deyişle, input_fn tarafından döndürülen veri kümesi input_fn boyutunda gruplar PER_REPLICA_BATCH_SIZE . Ve bir adımın global toplu iş boyutu PER_REPLICA_BATCH_SIZE * strategy.num_replicas_in_sync olarak elde edilebilir.

Çok çalışanlı eğitim yaparken, verilerinizi çalışanlar arasında bölmelisiniz veya her birinde rastgele bir tohumla karıştırmalısınız. Bunun nasıl yapılacağına dair bir örneği Tahmincisi ile Çok Çalışanlı Eğitim'de görebilirsiniz .

Benzer şekilde, çok çalışanlı ve parametre sunucusu stratejilerini de kullanabilirsiniz. Kod aynı kalır, ancak tf.estimator.train_and_evaluate kullanmanız ve TF_CONFIG çalışan her ikili için TF_CONFIG ortam değişkenlerini ayarlamanız TF_CONFIG .

Şimdi neler destekleniyor?

TPUStrategy hariç tüm stratejileri kullanarak Tahmincisi ile eğitim için sınırlı destek vardır. Temel eğitim ve değerlendirme çalışmalıdır, ancak iskele gibi bazı gelişmiş özellikler henüz çalışmaz. Bu entegrasyonda bir takım hatalar da olabilir. Şu anda, bu desteği aktif olarak geliştirmeyi planlamıyoruz ve bunun yerine Keras ve özel eğitim döngüsü desteğine odaklanıyoruz. Mümkünse, bunun yerine bu API'larla tf.distribute kullanmayı tercih etmelisiniz.

Örnekler ve Eğiticiler

Tahmincisi ile çeşitli stratejilerin uçtan uca kullanımını gösteren bazı örnekler:

1. Tahmincisi ile Çoklu işçi Eğitimi kullanarak birden işçilerle MNIST yetiştirmek MultiWorkerMirroredStrategy .
2. Kubernetes şablonlarını kullanarak tensorflow / ekosistemde çok çalışanlı eğitim için uçtan uca örnek . Bu örnek bir Keras modeliyle başlar ve tf.keras.estimator.model_to_estimator API'sını kullanarak bir Tahmincisi'ne dönüştürür.
3. MirroredStrategy veya MultiWorkerMirroredStrategy kullanılarak eğitilebilen resmi ResNet50 modeli.

Diğer başlıklar

Bu bölümde, çoklu kullanım durumlarıyla ilgili bazı konuları ele alacağız.

TF_CONFIG ortam değişkenini ayarlama

Çok çalışanlı eğitim için, daha önce de belirtildiği gibi, TF_CONFIG çalışan her bir ikili dosya için TF_CONFIG ortam değişkenini ayarlamanız gerekir. TF_CONFIG ortam değişkeni, hangi görevlerin küme oluşturduğunu, adreslerini ve her görevin kümedeki rolünü belirten bir JSON dizesidir. Eğitim görevleriniz için TF_CONFIG ayarlayan TF_CONFIG / ekosistem deposunda bir Kubernetes şablonu sunuyoruz .

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 diksiyon olan eğitim kümesi hakkında bilgi sağlar. Çok çalışanlı eğitimde, genellikle TensorBoard için kontrol noktasını kaydetme ve özet dosyası yazma gibi normal bir işçinin yaptıklarına ek olarak biraz daha fazla sorumluluk alan bir çalışan vardır. Böyle bir işçi 'baş' işçi olarak adlandırılır ve endeks 0'a sahip işçinin baş işçi olarak atanması gelenekseldir (aslında tf.distribute.Strategy'nin uygulanması bu şekildedir). Öte yandan görev, geçerli görevin bilgilerini 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 örneği:

 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 , küme içinde ana bilgisayarları ve bağlantı noktaları ile birlikte üç işçi ve iki ps görevi olduğunu belirtir. "Görev" bölümü, kümedeki (1) (ikinci işçi) geçerli görevin rolünü belirtir. Bir kümedeki 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. GitHub sorunlarını kullanarak denemenizi ve vermenizi ve geri bildirimlerinizi bekliyoruz.