Halaman ini diterjemahkan oleh Cloud Translation API.
Switch to English

Pelatihan terdistribusi dengan TensorFlow

Lihat di TensorFlow.org Jalankan di Google Colab Lihat sumber di GitHub Unduh buku catatan

Gambaran

tf.distribute.Strategy adalah TensorFlow API untuk mendistribusikan pelatihan ke beberapa GPU, beberapa mesin, atau TPU. Menggunakan API ini, Anda dapat mendistribusikan model yang ada dan kode pelatihan dengan sedikit perubahan kode.

tf.distribute.Strategy telah dirancang dengan tujuan utama berikut ini:

  • Mudah digunakan dan mendukung banyak segmen pengguna, termasuk peneliti, teknisi ML, dll.
  • Berikan performa yang baik di luar kotak.
  • Peralihan yang mudah antar strategi.

tf.distribute.Strategy dapat digunakan dengan API tingkat tinggi seperti Keras , dan juga dapat digunakan untuk mendistribusikan loop pelatihan kustom (dan, secara umum, komputasi apa pun menggunakan TensorFlow).

Di TensorFlow 2.x, Anda dapat menjalankan program dengan penuh semangat, atau dalam grafik menggunakan tf.function . tf.distribute.Strategy bermaksud untuk mendukung kedua mode eksekusi ini, tetapi bekerja paling baik dengan tf.function . Mode Eager hanya direkomendasikan untuk tujuan debugging dan tidak didukung untuk TPUStrategy . Meskipun pelatihan adalah fokus dari panduan ini, API ini juga dapat digunakan untuk mendistribusikan evaluasi dan prediksi pada berbagai platform.

Anda dapat menggunakan tf.distribute.Strategy dengan sedikit perubahan pada kode Anda, karena kami telah mengubah komponen yang mendasari TensorFlow menjadi peka terhadap strategi. Ini termasuk variabel, lapisan, model, pengoptimal, metrik, ringkasan, dan pos pemeriksaan.

Dalam panduan ini, kami menjelaskan berbagai jenis strategi dan bagaimana Anda dapat menggunakannya dalam berbagai situasi. Untuk mempelajari cara men-debug masalah performa, lihat panduan Performa Optimize TensorFlow GPU .

# Import TensorFlow
import tensorflow as tf

Jenis strategi

tf.distribute.Strategy bermaksud untuk mencakup sejumlah kasus penggunaan dengan sumbu yang berbeda. Beberapa dari kombinasi ini saat ini didukung dan yang lainnya akan ditambahkan di masa mendatang. Beberapa sumbu tersebut adalah:

  • Pelatihan sinkron vs asinkron: Ini adalah dua cara umum untuk mendistribusikan pelatihan dengan paralelisme data. Dalam pelatihan sinkronisasi, semua pekerja berlatih pada irisan yang berbeda dari data masukan secara sinkron, dan menggabungkan gradien di setiap langkah. Dalam pelatihan asinkron, semua pekerja melakukan pelatihan mandiri atas data masukan dan memperbarui variabel secara asinkron. Biasanya pelatihan sinkronisasi didukung melalui all-reduce dan async melalui arsitektur server parameter.
  • Platform hardware: Anda mungkin ingin menskalakan pelatihan Anda ke beberapa GPU di satu mesin, atau beberapa mesin dalam jaringan (masing-masing dengan 0 atau lebih GPU), atau di Cloud TPU.

Untuk mendukung kasus penggunaan ini, ada enam strategi yang tersedia. Bagian selanjutnya menjelaskan mana yang didukung di skenario mana di TF. Berikut ini gambaran singkatnya:

API Pelatihan MirroredStrategy Strategi TPUS MultiWorkerMirroredStrategy CentralStorageStrategy ParameterServerStrategy
API Keras Didukung Didukung Dukungan eksperimental Dukungan eksperimental Mendukung pos terencana 2.3
Loop pelatihan kustom Didukung Didukung Dukungan eksperimental Dukungan eksperimental Mendukung pos terencana 2.3
Estimator API Dukungan Terbatas Tidak didukung Dukungan Terbatas Dukungan Terbatas Dukungan Terbatas

MirroredStrategy

tf.distribute.MirroredStrategy mendukung pelatihan terdistribusi sinkron pada beberapa GPU di satu mesin. Ini membuat satu replika per perangkat GPU. Setiap variabel dalam model dicerminkan di semua replika. Bersama-sama, variabel-variabel ini membentuk variabel konseptual tunggal yang disebut MirroredVariable . Variabel ini tetap sinkron satu sama lain dengan menerapkan pembaruan yang identik.

Algoritme semua pengurangan yang efisien digunakan untuk mengkomunikasikan pembaruan variabel di seluruh perangkat. Semua-kurangi agregat tensor di semua perangkat dengan menambahkannya, dan membuatnya tersedia di setiap perangkat. Ini adalah algoritma gabungan yang sangat efisien dan dapat mengurangi overhead sinkronisasi secara signifikan. Ada banyak algoritme dan implementasi all-reduce yang tersedia, bergantung pada jenis komunikasi yang tersedia antar perangkat. Secara default, ini menggunakan NVIDIA NCCL sebagai implementasi all-reduce. Anda dapat memilih dari beberapa opsi lain, atau menulis sendiri.

Berikut adalah cara paling sederhana untuk membuat MirroredStrategy :

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

Ini akan membuat instance MirroredStrategy yang akan menggunakan semua GPU yang terlihat oleh TensorFlow, dan menggunakan NCCL sebagai komunikasi lintas perangkat.

Jika Anda hanya ingin menggunakan beberapa GPU di mesin Anda, Anda dapat melakukannya seperti ini:

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

Jika Anda ingin mengganti komunikasi lintas perangkat, Anda dapat melakukannya menggunakan argumen cross_device_ops dengan menyediakan instance tf.distribute.CrossDeviceOps . Saat ini, tf.distribute.HierarchicalCopyAllReduce dan tf.distribute.ReductionToOneDevice adalah dua opsi selain tf.distribute.NcclAllReduce yang merupakan default.

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

Strategi TPUS

tf.distribute.TPUStrategy memungkinkan Anda menjalankan pelatihan TensorFlow di Tensor Processing Units (TPUs). TPU adalah ASIC khusus Google yang dirancang untuk mempercepat beban kerja machine learning secara dramatis. Mereka tersedia di Google Colab, TensorFlow Research Cloud, dan Cloud TPU .

Dalam hal arsitektur pelatihan terdistribusi, TPUStrategy adalah MirroredStrategy sama - ia mengimplementasikan pelatihan terdistribusi secara sinkron. TPU menyediakan implementasi mereka sendiri untuk semua pengurangan yang efisien dan operasi kolektif lainnya di beberapa inti TPU, yang digunakan dalam strategi TPUStrategy .

Berikut adalah bagaimana Anda akan membuat contoh strategi 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 membantu menemukan TPU. Di Colab, Anda tidak perlu menentukan argumen apa pun untuk itu.

Jika Anda ingin menggunakannya untuk Cloud TPU:

  • Anda harus menentukan nama resource TPU Anda dalam argumen tpu .
  • Anda harus menginisialisasi sistem tpu secara eksplisit pada awal program. Ini diperlukan sebelum TPU dapat digunakan untuk komputasi. Menginisialisasi sistem tpu juga menghapus memori TPU, jadi penting untuk menyelesaikan langkah ini terlebih dahulu untuk menghindari kehilangan status.

MultiWorkerMirroredStrategy

tf.distribute.experimental.MultiWorkerMirroredStrategy sangat mirip dengan MirroredStrategy . Ini mengimplementasikan pelatihan terdistribusi sinkron di beberapa pekerja, masing-masing dengan potensi banyak GPU. Mirip dengan MirroredStrategy , ini membuat salinan semua variabel dalam model di setiap perangkat di semua pekerja.

Ini menggunakan CollectiveOps sebagai metode komunikasi multi-pekerja yang semuanya dikurangi yang digunakan untuk menjaga variabel tetap sinkron. Operasi kolektif adalah operasi tunggal dalam grafik TensorFlow yang secara otomatis dapat memilih algoritme pengurangan total dalam waktu proses TensorFlow sesuai dengan hardware, topologi jaringan, dan ukuran tensor.

Ini juga menerapkan pengoptimalan kinerja tambahan. Misalnya, ini mencakup pengoptimalan statis yang mengubah beberapa pengurangan semua pada tensor kecil menjadi pengurangan semua yang lebih sedikit pada tensor yang lebih besar. Selain itu, ia dirancang untuk memiliki arsitektur plugin - sehingga di masa mendatang, Anda akan dapat memasang algoritme yang lebih baik untuk perangkat keras Anda. Perhatikan bahwa operasi kolektif juga menerapkan operasi kolektif lainnya seperti siaran dan kumpul-kumpul.

Berikut adalah cara paling sederhana untuk membuat MultiWorkerMirroredStrategy :

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 saat ini memungkinkan Anda untuk memilih di antara dua implementasi operasi kolektif yang berbeda. CollectiveCommunication.RING mengimplementasikan kolektif berbasis cincin menggunakan gRPC sebagai lapisan komunikasi. CollectiveCommunication.NCCL menggunakan NCCL Nvidia untuk mengimplementasikan kolektif. CollectiveCommunication.AUTO mengalihkan pilihan ke runtime. Pilihan terbaik dari implementasi kolektif bergantung pada jumlah dan jenis GPU, dan interkoneksi jaringan di cluster. Anda dapat menentukannya dengan cara berikut:

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

Salah satu perbedaan utama untuk menjalankan pelatihan multi-pekerja, dibandingkan dengan pelatihan multi-GPU, adalah penyiapan multi-pekerja. TF_CONFIG lingkungan TF_CONFIG adalah cara standar di TensorFlow untuk menentukan konfigurasi cluster untuk setiap pekerja yang merupakan bagian dari cluster. Pelajari lebih lanjut tentang menyiapkan TF_CONFIG .

ParameterServerStrategy

Pelatihan server parameter adalah metode paralel data umum untuk meningkatkan pelatihan model di beberapa mesin. Kluster pelatihan server parameter terdiri dari pekerja dan server parameter. Variabel dibuat di server parameter dan dibaca serta diperbarui oleh pekerja di setiap langkah. Silakan lihat tutorial pelatihan server parameter untuk detailnya.

Pelatihan server parameter TensorFlow 2 menggunakan arsitektur berbasis koordinator pusat melalui kelas tf.distribute.experimental.coordinator.ClusterCoordinator .

Dalam implementasi ini worker dan tugas parameter server menjalankan tf.distribute.Server s yang mendengarkan tugas dari koordinator. Koordinator membuat sumber daya, mengirimkan tugas pelatihan, menulis checkpoint, dan menangani kegagalan tugas.

Dalam pemrograman yang berjalan pada koordinator, Anda akan menggunakan objek ParameterServerStrategy untuk menentukan langkah pelatihan dan menggunakan ClusterCoordinator untuk mengirimkan langkah-langkah pelatihan ke pekerja jarak jauh. Berikut cara termudah untuk membuatnya:

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

Catatan Anda perlu mengkonfigurasi variabel lingkungan TF_CONFIG jika Anda menggunakan TFConfigClusterResolver . Ini mirip dengan TF_CONFIG di MultiWorkerMirroredStrategy tetapi memiliki peringatan tambahan.

Di TF 1, ParameterServerStrategy hanya tersedia dengan estimator melalui simbol tf.compat.v1.distribute.experimental.ParameterServerStrategy .

CentralStorageStrategy

tf.distribute.experimental.CentralStorageStrategy juga melakukan pelatihan sinkron. Variabel tidak dicerminkan, melainkan ditempatkan di CPU dan operasi direplikasi di semua GPU lokal. Jika hanya ada satu GPU, semua variabel dan operasi akan ditempatkan di GPU itu.

Buat instance CentralStorageStrategy dengan:

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'

Ini akan membuat instance CentralStorageStrategy yang akan menggunakan semua GPU dan CPU yang terlihat. Pembaruan pada variabel pada replika akan digabungkan sebelum diterapkan ke variabel.

Strategi lainnya

Selain strategi di atas, ada dua strategi lain yang mungkin berguna untuk tf.distribute prototipe dan debugging saat menggunakan API tf.distribute .

Strategi Default

Strategi default adalah strategi distribusi yang muncul ketika tidak ada strategi distribusi eksplisit dalam cakupannya. Ini mengimplementasikan antarmuka tf.distribute.Strategy tetapi merupakan pass-through dan tidak menyediakan distribusi yang sebenarnya. Misalnya, strategy.run(fn) hanya akan memanggil fn . Kode yang ditulis menggunakan strategi ini harus berperilaku persis seperti kode yang ditulis tanpa strategi apa pun. Anda dapat menganggapnya sebagai strategi "tanpa operasi".

Strategi default adalah tunggal - dan seseorang tidak dapat membuat lebih banyak contoh darinya. Ini dapat diperoleh dengan menggunakan tf.distribute.get_strategy() luar cakupan strategi eksplisit apa pun (API yang sama yang dapat digunakan untuk mendapatkan strategi saat ini di dalam cakupan strategi eksplisit).

default_strategy = tf.distribute.get_strategy()

Strategi ini memiliki dua tujuan utama:

  • Ini memungkinkan penulisan kode pustaka sadar distribusi tanpa syarat. Misalnya, dalam tf.optimizer s dapat menggunakan tf.distribute.get_strategy() dan menggunakan strategi tersebut untuk mengurangi gradien - itu akan selalu mengembalikan objek strategi yang dapat kita panggil API pengurangan.
# 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
  • Mirip dengan kode perpustakaan, kode ini dapat digunakan untuk menulis program pengguna akhir untuk bekerja dengan dan tanpa strategi distribusi, tanpa memerlukan logika kondisional. Cuplikan kode contoh yang menggambarkan ini:
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 adalah strategi untuk menempatkan semua variabel dan komputasi pada satu perangkat yang ditentukan.

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

Strategi ini berbeda dari strategi default dalam beberapa hal. Dalam strategi default, logika penempatan variabel tetap tidak berubah jika dibandingkan dengan menjalankan TensorFlow tanpa strategi distribusi apa pun. Namun saat menggunakan OneDeviceStrategy , semua variabel yang dibuat dalam cakupannya ditempatkan secara eksplisit di perangkat yang ditentukan. Selain itu, setiap fungsi yang dipanggil melalui OneDeviceStrategy.run juga akan ditempatkan di perangkat yang ditentukan.

Input yang didistribusikan melalui strategi ini akan diambil sebelumnya ke perangkat yang ditentukan. Dalam strategi default, tidak ada distribusi input.

Mirip dengan strategi default, strategi ini juga dapat digunakan untuk menguji kode Anda sebelum beralih ke strategi lain yang sebenarnya didistribusikan ke beberapa perangkat / mesin. Ini akan menjalankan mesin strategi distribusi lebih dari sekedar strategi default, tetapi tidak sepenuhnya seperti menggunakan MirroredStrategy atau TPUStrategy dll. Jika Anda menginginkan kode yang berperilaku seolah-olah tidak ada strategi, maka gunakan strategi default.

Sejauh ini Anda telah melihat berbagai strategi yang tersedia dan bagaimana Anda dapat membuat contoh. Beberapa bagian berikutnya menunjukkan berbagai cara yang dapat Anda gunakan untuk mendistribusikan pelatihan Anda.

Menggunakan tf.distribute.Strategy dengan tf.keras.Model.fit

tf.distribute.Strategy diintegrasikan ke dalam tf.keras yang merupakan implementasi TensorFlow dari spesifikasi Keras API . tf.keras adalah API tingkat tinggi untuk membangun dan melatih model. Dengan mengintegrasikan ke dalam backend tf.keras , kami telah tf.keras Anda untuk mendistribusikan pelatihan yang ditulis dalam framework pelatihan Keras menggunakan model.fit .

Inilah yang perlu Anda ubah dalam kode Anda:

  1. Buat instance tf.distribute.Strategy sesuai.
  2. Pindahkan pembuatan model Keras, pengoptimal, dan metrik di dalam strategy.scope .

Kami mendukung semua jenis model Keras - berurutan, fungsional, dan subclass.

Berikut adalah potongan kode untuk melakukan ini untuk model Keras yang sangat sederhana dengan satu lapisan padat:

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

Contoh ini menggunakan MirroredStrategy sehingga Anda dapat menjalankannya di mesin dengan banyak GPU. strategy.scope() menunjukkan ke Keras strategi mana yang digunakan untuk mendistribusikan pelatihan. Membuat model / pengoptimal / metrik di dalam cakupan ini memungkinkan kita membuat variabel terdistribusi, bukan variabel reguler. Setelah ini disiapkan, Anda dapat menyesuaikan model Anda seperti biasanya. MirroredStrategy menangani replikasi pelatihan model pada GPU yang tersedia, menggabungkan gradien, dan banyak lagi.

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: 0.2137
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.0945
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.0587

0.0586698018014431

Di sini, sebuahtf.data.Dataset menyediakan input pelatihan dan evaluasi. Anda juga dapat menggunakan array numpy:

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 2ms/step - loss: 0.0418
Epoch 2/2
10/10 [==============================] - 0s 2ms/step - loss: 0.0185

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

Dalam kedua kasus (kumpulan data atau numpy), setiap batch dari input yang diberikan dibagi rata di antara beberapa replika. Misalnya, jika menggunakan MirroredStrategy dengan 2 GPU, setiap batch ukuran 10 akan dibagi di antara 2 GPU, dengan masing-masing menerima 5 contoh masukan di setiap langkah. Setiap epoch akan berlatih lebih cepat saat Anda menambahkan lebih banyak GPU. Biasanya, Anda ingin meningkatkan ukuran tumpukan saat Anda menambahkan lebih banyak akselerator agar dapat menggunakan daya komputasi ekstra secara efektif. Anda juga perlu menyetel ulang kecepatan pembelajaran Anda, bergantung pada modelnya. Anda dapat menggunakan strategy.num_replicas_in_sync untuk mendapatkan jumlah replika.

# 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]

Apa yang didukung sekarang?

API Pelatihan MirroredStrategy Strategi TPUS MultiWorkerMirroredStrategy ParameterServerStrategy CentralStorageStrategy
API Keras Didukung Didukung Dukungan eksperimental Dukungan eksperimental Dukungan eksperimental

Contoh dan Tutorial

Berikut adalah daftar tutorial dan contoh yang menggambarkan integrasi di atas ujung ke ujung dengan Keras:

  1. Tutorial untuk melatih MNIST dengan MirroredStrategy .
  2. Tutorial untuk melatih MNIST menggunakan MultiWorkerMirroredStrategy .
  3. Panduan tentang melatih MNIST menggunakan strategi TPUStrategy .
  4. Tutorial untuk pelatihan server parameter di TensorFlow 2 dengan ParameterServerStrategy .
  5. TensorFlow Model Taman repositori yang berisi koleksi state-of-the-art model diimplementasikan menggunakan berbagai strategi.

Menggunakan tf.distribute.Strategy dengan loop pelatihan kustom

Seperti yang Anda lihat, menggunakan tf.distribute.Strategy dengan model.fit Keras model.fit hanya perlu mengubah beberapa baris kode Anda. Dengan sedikit usaha, Anda juga dapat menggunakan tf.distribute.Strategy dengan loop pelatihan kustom.

Jika Anda membutuhkan lebih banyak fleksibilitas dan kontrol atas loop pelatihan Anda daripada yang dimungkinkan dengan Estimator atau Keras, Anda dapat menulis loop pelatihan kustom. Misalnya, saat menggunakan GAN, Anda mungkin ingin mengambil langkah generator atau diskriminator yang berbeda setiap putaran. Demikian pula, kerangka kerja tingkat tinggi tidak terlalu cocok untuk pelatihan Pembelajaran Penguatan.

Kelas tf.distribute.Strategy menyediakan sekumpulan metode inti untuk mendukung loop pelatihan kustom. Penggunaan ini mungkin memerlukan restrukturisasi kecil pada kode pada awalnya, tetapi setelah selesai, Anda harus dapat beralih antara GPU, TPU, dan beberapa mesin hanya dengan mengubah instance strategi.

Di sini kami akan menunjukkan cuplikan singkat yang menggambarkan kasus penggunaan ini untuk contoh pelatihan sederhana menggunakan model Keras yang sama seperti sebelumnya.

Pertama, buat model dan pengoptimal di dalam lingkup strategi. Ini memastikan bahwa variabel apa pun yang dibuat dengan model dan pengoptimal adalah variabel cermin.

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

Selanjutnya, buat dataset input dan panggil tf.distribute.Strategy.experimental_distribute_dataset untuk mendistribusikan dataset berdasarkan strategi.

dataset = tf.data.Dataset.from_tensors(([1.], [1.])).repeat(100).batch(
    global_batch_size)
dist_dataset = mirrored_strategy.experimental_distribute_dataset(dataset)

Kemudian, tentukan satu langkah pelatihan. Gunakantf.GradientTape untuk menghitung gradien dan pengoptimal untuk menerapkan gradien tersebut guna memperbarui variabel model kita. Untuk mendistribusikan langkah pelatihan ini, masukkan ke dalam function train_step dan teruskan ke tf.distrbute.Strategy.run bersama dengan input tf.distrbute.Strategy.run data yang Anda dapatkan dari dist_dataset dibuat sebelumnya:

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)

Beberapa hal lain yang perlu diperhatikan pada kode di atas:

  1. Ini menggunakan tf.nn.compute_average_loss untuk menghitung kerugian. tf.nn.compute_average_loss menjumlahkan kerugian per contoh dan membagi jumlahnya dengan ukuran_batch_lobal. Ini penting karena nanti setelah gradien dihitung pada setiap replika, gradien akan digabungkan di seluruh replika dengan menjumlahkannya .
  2. Ini menggunakan API tf.distribute.Strategy.reduce untuk menggabungkan hasil yang dikembalikan oleh tf.distribute.Strategy.run . tf.distribute.Strategy.run mengembalikan hasil dari setiap replika lokal dalam strategi, dan ada beberapa cara untuk menggunakan hasil ini. Anda dapat reduce untuk mendapatkan nilai gabungan. Anda juga dapat melakukan tf.distribute.Strategy.experimental_local_results untuk mendapatkan daftar nilai yang terdapat dalam hasil, satu per replika lokal.
  3. Ketika apply_gradients dipanggil dalam lingkup strategi distribusi, perilakunya diubah. Secara khusus, sebelum menerapkan gradien pada setiap instance paralel selama pelatihan sinkron, ia melakukan jumlah-di-semua-replika gradien.

Terakhir, setelah Anda menentukan langkah pelatihan, kita dapat mengulang dist_dataset dan menjalankan pelatihan dalam satu putaran:

for dist_inputs in dist_dataset:
  print(distributed_train_step(dist_inputs))
tf.Tensor(0.18279998, shape=(), dtype=float32)
tf.Tensor(0.18224256, shape=(), dtype=float32)
tf.Tensor(0.18168819, shape=(), dtype=float32)
tf.Tensor(0.1811369, shape=(), dtype=float32)
tf.Tensor(0.18058868, shape=(), dtype=float32)
tf.Tensor(0.18004347, shape=(), dtype=float32)
tf.Tensor(0.17950125, shape=(), dtype=float32)
tf.Tensor(0.178962, shape=(), dtype=float32)
tf.Tensor(0.17842571, shape=(), dtype=float32)
tf.Tensor(0.17789237, shape=(), dtype=float32)
tf.Tensor(0.17736195, shape=(), dtype=float32)
tf.Tensor(0.17683437, shape=(), dtype=float32)
tf.Tensor(0.17630969, shape=(), dtype=float32)
tf.Tensor(0.17578785, shape=(), dtype=float32)
tf.Tensor(0.17526883, shape=(), dtype=float32)
tf.Tensor(0.17475258, shape=(), dtype=float32)
tf.Tensor(0.17423911, shape=(), dtype=float32)
tf.Tensor(0.17372845, shape=(), dtype=float32)
tf.Tensor(0.17322046, shape=(), dtype=float32)
tf.Tensor(0.1727152, shape=(), dtype=float32)

Dalam contoh di atas, Anda melakukan iterasi pada dist_dataset untuk memberikan masukan ke pelatihan Anda. Kami juga menyediakan tf.distribute.Strategy.make_experimental_numpy_dataset untuk mendukung masukan numpy. Anda dapat menggunakan API ini untuk membuat kumpulan data sebelum memanggil tf.distribute.Strategy.experimental_distribute_dataset .

Cara lain untuk melakukan iterasi terhadap data Anda adalah dengan menggunakan iterator secara eksplisit. Anda mungkin ingin melakukan ini saat Anda ingin menjalankan sejumlah langkah tertentu, bukan mengulang seluruh kumpulan data. Iterasi di atas sekarang akan dimodifikasi untuk membuat iterator terlebih dahulu dan kemudian secara eksplisit memanggilnya next untuk mendapatkan data masukan.

iterator = iter(dist_dataset)
for _ in range(10):
  print(distributed_train_step(next(iterator)))
tf.Tensor(0.17221266, shape=(), dtype=float32)
tf.Tensor(0.17171277, shape=(), dtype=float32)
tf.Tensor(0.17121558, shape=(), dtype=float32)
tf.Tensor(0.17072096, shape=(), dtype=float32)
tf.Tensor(0.17022902, shape=(), dtype=float32)
tf.Tensor(0.16973962, shape=(), dtype=float32)
tf.Tensor(0.16925281, shape=(), dtype=float32)
tf.Tensor(0.1687686, shape=(), dtype=float32)
tf.Tensor(0.1682869, shape=(), dtype=float32)
tf.Tensor(0.16780771, shape=(), dtype=float32)

Ini mencakup kasus paling sederhana dalam menggunakan tf.distribute.Strategy API untuk mendistribusikan loop pelatihan kustom.

Apa yang didukung sekarang?

API Pelatihan MirroredStrategy Strategi TPUS MultiWorkerMirroredStrategy ParameterServerStrategy CentralStorageStrategy
Loop Pelatihan Kustom Didukung Didukung Dukungan eksperimental Dukungan eksperimental Dukungan eksperimental

Contoh dan Tutorial

Berikut beberapa contoh penggunaan strategi distribusi dengan loop pelatihan kustom:

  1. Tutorial untuk melatih MNIST menggunakan MirroredStrategy .
  2. Panduan tentang melatih MNIST menggunakan strategi TPUStrategy .
  3. TensorFlow Model Taman repositori yang berisi koleksi state-of-the-art model diimplementasikan menggunakan berbagai strategi.

Topik lainnya

Bagian ini membahas beberapa topik yang relevan dengan beberapa kasus penggunaan.

Menyiapkan variabel lingkungan TF_CONFIG

Untuk pelatihan multi-pekerja, seperti yang disebutkan sebelumnya, Anda perlu menyetel variabel lingkungan TF_CONFIG untuk setiap biner yang berjalan di kluster Anda. TF_CONFIG lingkungan TF_CONFIG adalah string JSON yang menentukan tugas apa yang membentuk cluster, alamatnya, dan peran masing-masing tugas dalam cluster. Tensorflow / ekosistem repo menyediakan template Kubernetes yang menetapkan TF_CONFIG untuk tugas pelatihan Anda.

Ada dua komponen TF_CONFIG: cluster dan tugas. cluster menyediakan informasi tentang cluster pelatihan, yang merupakan dict yang terdiri dari berbagai jenis pekerjaan seperti pekerja. Dalam pelatihan multi-pekerja, biasanya ada satu pekerja yang mengambil sedikit lebih banyak tanggung jawab seperti menyimpan pos pemeriksaan dan menulis file ringkasan untuk TensorBoard selain yang dilakukan pekerja biasa. Pekerja seperti itu disebut sebagai pekerja 'kepala', dan merupakan kebiasaan bahwa pekerja dengan indeks 0 ditunjuk sebagai pekerja kepala (sebenarnya ini adalah bagaimana tf.distribute.Strategy diimplementasikan). tugas di sisi lain memberikan informasi tentang tugas saat ini. Kluster komponen pertama sama untuk semua pekerja, dan tugas komponen kedua berbeda pada setiap pekerja dan menentukan jenis dan indeks pekerja itu.

Salah satu contoh TF_CONFIG adalah:

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

TF_CONFIG ini menetapkan bahwa ada tiga pekerja dan dua tugas ps di cluster bersama dengan host dan portnya. Bagian "tugas" menentukan bahwa peran tugas saat ini di cluster, pekerja 1 (pekerja kedua). Peran yang valid dalam cluster adalah "chief", "worker", "ps" dan "evaluator". Seharusnya tidak ada tugas "ps" kecuali saat menggunakan tf.distribute.experimental.ParameterServerStrategy .

Apa berikutnya?

tf.distribute.Strategy secara aktif sedang dikembangkan. Cobalah dan berikan masukan Anda menggunakan masalah GitHub .