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

Switch to English

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

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

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

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

Not defterini indir

genel bakış

tf.distribute.Strategy , eğitimi birden çok GPU'ya, birden çok makineye veya TPU'ya dağıtmak 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 şu ana hedefler göz önünde bulundurularak tasarlanmıştır:

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

Eğitimi tf.distribute.Strategy kullanarak tf.distribute.Strategy Model.fit üst düzey bir API ile ve özel eğitim döngüleriyle (ve genel olarak TensorFlow kullanan herhangi bir hesaplama) dağıtabilirsiniz.

TensorFlow 2.x'te programlarınızı hevesle veya tf.function kullanarak bir grafikte çalıştırabilirsiniz. tf.distribute.Strategy , bu iki yürütme modunu da desteklemeyi amaçlar, ancak en iyi şekilde tf.function ile çalışır. İstekli mod yalnızca hata ayıklama amacıyla önerilir ve tf.distribute.TPUStrategy için desteklenmez. Bu kılavuzun odak noktası eğitim olsa da, bu API, farklı platformlarda değerlendirme ve tahmin dağıtmak için de kullanılabilir.

tf.distribute.Strategy çok az değişiklikle kullanabilirsiniz, çünkü TensorFlow'un temel bileşenleri stratejiye duyarlı olacak şekilde değiştirilmiştir. Buna değişkenler, katmanlar, modeller, optimize ediciler, ölçümler, özetler ve kontrol noktaları dahildir.

Bu kılavuzda, çeşitli strateji türleri ve bunları farklı durumlarda nasıl kullanabileceğinizi öğreneceksiniz. Performans sorunlarının nasıl ayıklanacağını öğrenmek için Optimize TensorFlow GPU performans kılavuzuna bakın.

TensorFlow'u kurun

import tensorflow as tf

Strateji türleri

tf.distribute.Strategy , farklı eksenler boyunca bir dizi kullanım durumunu kapsamayı 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şitleme eğitiminde, tüm çalışanlar eşitlemede farklı girdi verisi dilimleri üzerinde eğitim alır ve her adımda gradyanları toplar. Zaman uyumsuz eğitimde, tüm çalışanlar girdi verileri üzerinde bağımsız olarak eğitim alır ve değişkenleri zaman uyumsuz olarak günceller. Tipik olarak senkronizasyon eğitimi, parametre sunucusu mimarisi aracılığıyla tamamen azaltma ve zaman uyumsuz olarak desteklenir.
Donanım platformu: Eğitiminizi bir makinedeki birden çok GPU'ya veya bir ağdaki birden çok makineye (her biri 0 veya daha fazla GPU'ya sahip) veya Cloud TPU'lara ölçeklendirmek isteyebilirsiniz.

Bu kullanım durumlarını desteklemek için TensorFlow'da MirroredStrategy , TPUStrategy , MultiWorkerMirroredStrategy , ParameterServerStrategy , CentralStorageStrategy ve ayrıca mevcut diğer stratejiler bulunur. Sonraki bölüm, TensorFlow'da bunlardan hangilerinin hangi senaryolarda desteklendiğini açıklar. İşte hızlı bir genel bakış:

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

MirroredStrateji

tf.distribute.MirroredStrategy , tek bir makinede birden çok GPU üzerinde senkronize dağıtılmış eğitimi destekler. GPU cihazı başına bir kopya oluşturur. Modeldeki her değişken, tüm kopyalarda yansıtılır. Bu değişkenler birlikte MirroredVariable adlı tek bir kavramsal değişken oluşturur. Bu değişkenler, aynı güncellemeler uygulanarak birbirleriyle senkronize tutulur.

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

MirroredStrategy oluşturmanın en basit yolu:

mirrored_strategy = tf.distribute.MirroredStrategy()

tutucu2 l10n-yer

INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)

Bu, cihazlar arası iletişim olarak TensorFlow ve NCCL tarafından görülebilen tüm GPU'ları 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"])

tutucu4 l10n-yer

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

Cihazlar arası iletişimi geçersiz kılmak istiyorsanız, bunu bir tf.distribute.CrossDeviceOps örneği sağlayarak cross_device_ops bağımsız değişkenini kullanarak yapabilirsiniz. Şu anda, tf.distribute.HierarchicalCopyAllReduce ve tf.distribute.ReductionToOneDevice , varsayılan olan tf.distribute.NcclAllReduce dışında iki seçenektir.

mirrored_strategy = tf.distribute.MirroredStrategy(
    cross_device_ops=tf.distribute.HierarchicalCopyAllReduce())

tutucu6 l10n-yer

INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)

TPUStratejisi

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

Dağıtılmış eğitim mimarisi açısından, TPUStrategy aynı MirroredStrategy ; senkronize dağıtılmış eğitimi uygular. TPU'lar, TPUStrategy kullanılan birden çok TPU çekirdeğinde verimli tümüyle azaltma ve diğer toplu işlemlerin kendi uygulamalarını sağlar.

TPUStrategy şu şekilde başlatacaksı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, TPU'ların bulunmasına yardımcı olur. Colab'da buna herhangi bir argüman belirtmeniz gerekmez.

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

TPU kaynağınızın adını tpu bağımsız değişkeninde belirtmelisiniz.
TPU sistemini programın başlangıcında açıkça başlatmalısınız . Bu, TPU'ların hesaplama için kullanılabilmesi için gereklidir. TPU sisteminin başlatılması, TPU belleğini de siler; bu nedenle, durum kaybını önlemek için önce bu adımı tamamlamak önemlidir.

Çoklu ÇalışanYansıtmalıStrateji

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

MultiWorkerMirroredStrategy oluşturmanın en basit yolu:

strategy = tf.distribute.MultiWorkerMirroredStrategy()

tutucu9 l10n-yer

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

MultiWorkerMirroredStrategy , cihazlar arası iletişim için iki uygulamaya sahiptir. CommunicationImplementation.RING , RPC tabanlıdır ve hem CPU'ları hem de GPU'ları destekler. CommunicationImplementation.NCCL , NCCL'yi kullanır ve GPU'larda son teknoloji performans sağlar, ancak CPU'ları desteklemez. CollectiveCommunication.AUTO , seçimi Tensorflow'a erteler. Bunları aşağıdaki şekilde belirtebilirsiniz:

communication_options = tf.distribute.experimental.CommunicationOptions(
    implementation=tf.distribute.experimental.CommunicationImplementation.NCCL)
strategy = tf.distribute.MultiWorkerMirroredStrategy(
    communication_options=communication_options)

tutucu11 l10n-yer

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

Çoklu GPU eğitimi ile karşılaştırıldığında, çok işçili eğitim almanın temel farklarından biri, çok işçili kurulumdur. 'TF_CONFIG' ortam değişkeni, TensorFlow'da kümenin parçası olan her çalışana küme yapılandırmasını belirtmenin standart yoludur. Bu belgenin TF_CONFIG kurulumu bölümünde daha fazla bilgi edinin.

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

ParametreSunucuStratejisi

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

TensorFlow 2'de parametre sunucusu eğitimi, tf.distribute.experimental.coordinator.ClusterCoordinator sınıfı aracılığıyla merkezi bir koordinatör tabanlı mimari kullanır.

Bu uygulamada, worker ve parameter server görevleri, koordinatörden görevleri dinleyen tf.distribute.Server ları ç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ıyla ilgilenir.

Koordinatör üzerinde çalışan programlamada, bir eğitim adımı tanımlamak için bir ParameterServerStrategy nesnesi kullanacak ve eğitim adımlarını uzak çalışanlara göndermek için bir ClusterCoordinator kullanacaksınız. İşte onları yaratmanın en basit yolu:

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

ParameterServerStrategy hakkında daha fazla bilgi edinmek için Keras Model.fit ile Parameter server eğitimine ve özel eğitim döngüsü eğitimine göz atın .

TensorFlow 1'de, ParameterServerStrategy yalnızca tf.compat.v1.distribute.experimental.ParameterServerStrategy sembolü aracılığıyla bir Tahmin Edici ile kullanılabilir.

MerkeziDepolamaStratejisi

tf.distribute.experimental.CentralStorageStrategy senkron eğitim de 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.

CentralStorageStrategy örneğini şu şekilde oluşturun:

central_storage_strategy = tf.distribute.experimental.CentralStorageStrategy()

tutucu14 l10n-yer

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. Replikalardaki değişkenlerde yapılan güncellemeler, değişkenlere uygulanmadan önce toplanır.

Diğer stratejiler

Yukarıdaki stratejilere ek olarak, tf.distribute API'lerini kullanırken prototip oluşturma ve hata ayıklama için faydalı olabilecek iki strateji daha vardır.

Varsayılan Strateji

Varsayılan Strateji, kapsam dahilinde 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 bir dağıtım sağlamaz. Örneğin, Strategy.run(fn) yalnızca fn çağırı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 tektir ve bunun daha fazla örneği oluşturulamaz. Herhangi bir açık stratejinin kapsamı dışında tf.distribute.get_strategy kullanılarak elde edilebilir (mevcut stratejiyi açık bir stratejinin kapsamı içine almak için kullanılabilen aynı API).

default_strategy = tf.distribute.get_strategy()

Bu strateji iki ana amaca hizmet eder:

Koşulsuz olarak dağıtıma duyarlı kitaplık kodu yazılmasına izin verir. Örneğin, tf.optimizer s'de tf.distribute.get_strategy kullanabilir ve bu stratejiyi degradeleri azaltmak için kullanabilirsiniz; bu her zaman üzerinde Strategy.reduce API'sini arayabileceğiniz 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

tutucu17 l10n-yer

1.0

Kütüphane koduna benzer şekilde, koşullu mantık gerektirmeden, dağıtım stratejisi ile ve olmadan çalışacak son kullanıcıların programlarını yazmak için kullanılabilir. İşte bunu gösteren örnek bir kod parçacığı:

if tf.config.list_physical_devices('GPU'):
  strategy = tf.distribute.MirroredStrategy()
else:  # Use the Default Strategy
  strategy = tf.distribute.get_strategy()

with strategy.scope():
  # Do something interesting
  print(tf.Variable(1.))

tutucu19 l10n-yer

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

OneDeviceStrateji

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

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

Bu strateji, birkaç yönden Varsayılan Stratejiden farklıdır. Varsayılan Stratejide, TensorFlow'u herhangi bir dağıtım stratejisi olmadan çalıştırmaya kıyasla değişken yerleştirme mantığı değişmeden kalır. Ancak OneDeviceStrategy kullanılırken, kapsamında oluşturulan tüm değişkenler açıkça belirtilen aygıta yerleştirilir. Ayrıca OneDeviceStrategy.run aracılığıyla çağrılan işlevler de belirtilen cihaza yerleştirilecektir.

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

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

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

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

tf.distribute.Strategy , TensorFlow'un Keras API belirtimi uygulaması olan tf.keras ile entegre edilmiştir. tf.keras , modeller oluşturmak ve eğitmek için üst düzey bir API'dir. tf.keras eğitim çerçevesinde yazılmış eğitiminizi Model.fit kullanarak sorunsuz bir şekilde dağıtabilirsiniz.

İşte kodunuzda değiştirmeniz gerekenler:

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

TensorFlow dağıtım stratejileri, her tür Keras modelini destekler— Sıralı , İşlevsel ve alt sınıflı.

İşte bir Dense 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')

tutucu22 l10n-yer

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 kullanır, böylece bunu birden çok GPU'lu bir makinede çalıştırabilirsiniz. strategy.scope() , Keras'a eğitimi dağıtmak için hangi stratejinin kullanılacağını belirtir. Bu kapsamda modeller/iyileştiriciler/metrikler oluşturmak, normal değişkenler yerine dağıtılmış değişkenler oluşturmanıza olanak tanır. Bu ayarlandıktan sonra, modelinizi normalde yaptığınız gibi sığdırabilirsiniz. MirroredStrategy , modelin eğitimini mevcut GPU'larda ç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)

tutucu24 l10n-yer

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',).
2021-10-26 01:27:56.527729: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:695] AUTO sharding policy will apply DATA sharding policy as it failed to apply FILE sharding policy because of the following reason: Found an unshardable source dataset: name: "TensorDataset/_2"
op: "TensorDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_FLOAT
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 1
        }
      }
      shape {
        dim {
          size: 1
        }
      }
    }
  }
}
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.2552
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: 0.9968
2021-10-26 01:27:59.372113: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:695] AUTO sharding policy will apply DATA sharding policy as it failed to apply FILE sharding policy because of the following reason: Found an unshardable source dataset: name: "TensorDataset/_2"
op: "TensorDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_FLOAT
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 1
        }
      }
      shape {
        dim {
          size: 1
        }
      }
    }
  }
}
10/10 [==============================] - 1s 2ms/step - loss: 0.6190
0.6190494298934937

Burada bir tf.data.Dataset , eğitim ve değerlendirme girdisini sağlar. 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)

tutucu26 l10n-yer

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

Her iki durumda da - Dataset veya NumPy ile - verilen girdinin her partisi birden çok kopya arasında eşit olarak bölünür. Örneğin, MirroredStrategy 2 GPU ile kullanıyorsanız, 10 boyutundaki her parti, her adımda 5 giriş örneği alacak şekilde 2 GPU arasında bölünecektir. Her dönem, siz daha fazla GPU ekledikçe daha hızlı çalışacaktır. Tipik olarak, ekstra bilgi işlem gücünden etkin bir şekilde yararlanmak için daha fazla hızlandırıcı ekledikçe toplu iş boyutunuzu artırmak istersiniz. Ayrıca modele bağlı olarak öğrenme hızınızı yeniden ayarlamanız gerekecektir. Kopya sayısını almak için strategy.num_replicas_in_sync kullanabilirsiniz.

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

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

Şimdi ne destekleniyor?

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

Örnekler ve öğreticiler

Model.fit ile yukarıdaki entegrasyonu uçtan uca gösteren öğreticilerin ve örneklerin bir listesi:

Öğretici : Model.fit ve MirroredStrategy ile eğitim.
Öğretici : Model.fit ve MultiWorkerMirroredStrategy ile eğitim.
Kılavuz : Model.fit ve TPUStrategy kullanımına ilişkin bir örnek içerir.
Öğretici : Model.fit ve ParameterServerStrategy ile parametre sunucusu eğitimi.
Öğretici : Model.fit ve TPUStrategy ile GLUE karşılaştırmasından birçok görev için BERT'ye ince ayar yapın.
Çeşitli stratejiler kullanılarak uygulanan en son model koleksiyonlarını içeren TensorFlow Model Garden deposu .

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

Yukarıda gösterildiği gibi, tf.distribute.Strategy ile Model.fit kullanmak, kodunuzun yalnızca birkaç satırını değiştirmeyi gerektirir. Biraz daha çabayla, özel eğitim döngüleriyle tf.distribute.Strategy de kullanabilirsiniz.

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

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

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

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

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

Ardından, girdi veri kümesini oluşturun ve stratejiye dayalı olarak veri kümesini 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)

tutucu30 l10n-yer

2021-10-26 01:28:01.831942: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:695] AUTO sharding policy will apply DATA sharding policy as it failed to apply FILE sharding policy because of the following reason: Found an unshardable source dataset: name: "TensorDataset/_2"
op: "TensorDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_FLOAT
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 1
        }
      }
      shape {
        dim {
          size: 1
        }
      }
    }
  }
}

Ardından, eğitimin bir adımını tanımlayın. Degradeleri hesaplamak için tf.GradientTape ve modelinizin değişkenlerini güncellemek için bu degradeleri uygulamak için optimize ediciyi kullanın. Bu eğitim adımını dağıtmak için, onu train_step işlevine koyun ve daha önce oluşturduğunuz dist_dataset aldığınız veri kümesi girdileriyle birlikte tf.distribute.Strategy.run iletin:

loss_object = tf.keras.losses.BinaryCrossentropy(
  from_logits=True,
  reduction=tf.keras.losses.Reduction.NONE)

def compute_loss(labels, predictions):
  per_example_loss = loss_object(labels, predictions)
  return tf.nn.compute_average_loss(per_example_loss, global_batch_size=global_batch_size)

def train_step(inputs):
  features, labels = inputs

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

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

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

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

Kaybı hesaplamak için tf.nn.compute_average_loss kullandınız. tf.nn.compute_average_loss örnek başına kaybı toplar ve toplamı global_batch_size ile böler. Bu önemlidir, çünkü daha sonra her yinelemede degradeler hesaplandıktan sonra, bunlar toplanarak kopyalar arasında toplanır.
Ayrıca tf.distribute.Strategy.run tarafından döndürülen sonuçları toplamak için tf.distribute.Strategy.reduce API'sini kullandınız. tf.distribute.Strategy.run , stratejideki her yerel kopyadan sonuçları döndürür ve bu sonucu tüketmenin birden çok yolu vardır. Toplu bir değer elde etmek için bunları reduce . Ayrıca, sonuçta yer alan değerlerin listesini yerel kopya başına bir tane olmak üzere almak için tf.distribute.Strategy.experimental_local_results yapabilirsiniz.
Bir dağıtım stratejisi kapsamında apply_gradients çağırdığınızda, davranışı değiştirilir. Spesifik olarak, eşzamanlı eğitim sırasında her bir paralel örneğe degradeler uygulamadan önce, degradelerin tümünün toplamını gerçekleştirir.

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ırabilirsiniz:

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

tutucu33 l10n-yer

tf.Tensor(0.18686396, shape=(), dtype=float32)
tf.Tensor(0.18628375, shape=(), dtype=float32)
tf.Tensor(0.18570684, shape=(), dtype=float32)
tf.Tensor(0.18513316, shape=(), dtype=float32)
tf.Tensor(0.1845627, shape=(), dtype=float32)
tf.Tensor(0.18399543, shape=(), dtype=float32)
tf.Tensor(0.18343134, shape=(), dtype=float32)
tf.Tensor(0.18287037, shape=(), dtype=float32)
tf.Tensor(0.18231256, shape=(), dtype=float32)
tf.Tensor(0.18175781, shape=(), dtype=float32)
tf.Tensor(0.18120615, shape=(), dtype=float32)
tf.Tensor(0.18065754, shape=(), dtype=float32)
tf.Tensor(0.18011193, shape=(), dtype=float32)
tf.Tensor(0.17956935, shape=(), dtype=float32)
tf.Tensor(0.17902976, shape=(), dtype=float32)
tf.Tensor(0.17849308, shape=(), dtype=float32)
tf.Tensor(0.17795937, shape=(), dtype=float32)
tf.Tensor(0.17742859, shape=(), dtype=float32)
tf.Tensor(0.17690066, shape=(), dtype=float32)
tf.Tensor(0.17637561, shape=(), dtype=float32)

Yukarıdaki örnekte, eğitiminize girdi sağlamak için dist_dataset üzerinde yinelediniz. NumPy girişlerini desteklemek için size ayrıca tf.distribute.Strategy.make_experimental_numpy_dataset sağlanır. tf.distribute.Strategy.experimental_distribute_dataset çağırmadan önce bir veri kümesi oluşturmak için bu API'yi kullanabilirsiniz.

Verilerinizi yinelemenin başka bir yolu da yineleyicileri açıkça kullanmaktır. Bunu, tüm veri kümesini yinelemek yerine belirli sayıda adım için çalıştırmak istediğinizde yapmak isteyebilirsiniz. Yukarıdaki yineleme şimdi önce bir yineleyici oluşturacak ve ardından giriş verilerini almak için açıkça next çağrıyı yapacak şekilde değiştirilecektir.

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

tutucu35 l10n-yer

tf.Tensor(0.17585339, shape=(), dtype=float32)
tf.Tensor(0.17533402, shape=(), dtype=float32)
tf.Tensor(0.17481743, shape=(), dtype=float32)
tf.Tensor(0.17430364, shape=(), dtype=float32)
tf.Tensor(0.17379259, shape=(), dtype=float32)
tf.Tensor(0.17328428, shape=(), dtype=float32)
tf.Tensor(0.17277871, shape=(), dtype=float32)
tf.Tensor(0.17227581, shape=(), dtype=float32)
tf.Tensor(0.17177561, shape=(), dtype=float32)
tf.Tensor(0.17127804, shape=(), dtype=float32)

Bu, özel eğitim döngülerini dağıtmak için tf.distribute.Strategy API kullanmanın en basit durumunu kapsar.

Şimdi ne destekleniyor?

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

Örnekler ve öğreticiler

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

Öğretici : Özel bir eğitim döngüsü ve MirroredStrategy ile eğitim.
Öğretici : Özel bir eğitim döngüsü ve MultiWorkerMirroredStrategy ile eğitim.
Kılavuz : TPUStrategy ile özel bir eğitim döngüsü örneği içerir.
Öğretici : Özel bir eğitim döngüsü ve ParameterServerStrategy ile parametre sunucusu eğitimi.
Çeşitli stratejiler kullanılarak uygulanan en son model koleksiyonlarını içeren TensorFlow Model Garden deposu .

Diğer başlıklar

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

TF_CONFIG ortam değişkenini ayarlama

Çok çalışanlı eğitim için, daha önce belirtildiği gibi, kümenizde ç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üme oluşturduğunu, adreslerini ve kümedeki her bir görevin rolünü belirten bir JSON dizesidir. tensorflow/ecosystem deposu, eğitim görevleriniz için 'TF_CONFIG' ayarlayan bir Kubernetes şablonu sağlar.

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

Bir küme, işçiler gibi farklı iş türlerinden oluşan bir dikte olan eğitim kümesi hakkında bilgi sağlar. Çok çalışanlı eğitimde, normal bir çalışanın yaptığına ek olarak, genellikle kontrol noktasını kaydetme ve TensorBoard için özet dosyası yazma gibi biraz daha fazla sorumluluk alan bir çalışan vardır. Bu tür işçiye "baş" işçi denir ve 0 indeksli işçinin baş işçi olarak atanması adettendir (aslında tf.distribute.Strategy bu şekilde uygulanır).
Öte yandan bir görev, geçerli görev hakkında 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ışan için farklıdır ve o çalışanın türünü ve dizinini belirtir.

'TF_CONFIG' için 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ıyla birlikte "cluster" üç işçi ve iki "ps" görevi olduğunu belirtir. "task" bölümü, geçerli görevin "cluster" —işçi 1 (ikinci işçi) rolünü belirtir. Bir kümedeki geçerli roller "chief" , "worker" , "ps" ve "evaluator" . tf.distribute.experimental.ParameterServerStrategy kullanılması dışında "ps" işi olmamalıdır.

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.