Trang này được dịch bởi Cloud Translation API.
Switch to English

Đào tạo phân tán với TensorFlow

Xem trên TensorFlow.org Chạy trong Google Colab Xem nguồn trên GitHub Tải vở

Tổng quat

tf.distribute.Strategy là API TensorFlow để phân phối đào tạo trên nhiều GPU, nhiều máy hoặc TPU. Sử dụng API này, bạn có thể phân phối các mô hình và mã đào tạo hiện tại của mình với các thay đổi mã tối thiểu.

tf.distribute.Strategy đã được thiết kế với những mục tiêu chính này:

  • Dễ sử dụng và hỗ trợ nhiều phân khúc người dùng, bao gồm các nhà nghiên cứu, kỹ sư ML, v.v.
  • Cung cấp hiệu suất tốt ra khỏi hộp.
  • Dễ dàng chuyển đổi giữa các chiến lược.

tf.distribute.Strategy có thể được sử dụng với API cấp cao như Keras và cũng có thể được sử dụng để phân phối các vòng lặp đào tạo tùy chỉnh (và nói chung, bất kỳ tính toán nào khi sử dụng TensorFlow).

Trong TensorFlow 2.x, bạn có thể thực hiện các chương trình của mình một cách háo hức hoặc trong một biểu đồ bằng cách sử dụng tf.function . tf.distribute.Strategy dự định hỗ trợ cả hai chế độ thực thi này, nhưng hoạt động tốt nhất với tf.function . Chế độ háo hức chỉ được khuyến nghị cho mục đích gỡ lỗi và không được hỗ trợ cho TPUStrategy . Mặc dù chúng tôi thảo luận về đào tạo hầu hết thời gian trong hướng dẫn này, API này cũng có thể được sử dụng để phân phối đánh giá và dự đoán trên các nền tảng khác nhau.

Bạn có thể sử dụng tf.distribute.Strategy với rất ít thay đổi cho mã của bạn, bởi vì chúng tôi đã thay đổi các thành phần cơ bản của TensorFlow để trở thành nhận thức chiến lược. Điều này bao gồm các biến, lớp, mô hình, tối ưu hóa, số liệu, tóm tắt và điểm kiểm tra.

Trong hướng dẫn này, chúng tôi giải thích các loại chiến lược khác nhau và cách bạn có thể sử dụng chúng trong các tình huống khác nhau.

 # Import TensorFlow
import tensorflow as tf
 

Các loại chiến lược

tf.distribute.Strategy dự định sẽ bao gồm một số trường hợp sử dụng dọc theo các trục khác nhau. Một số kết hợp này hiện đang được hỗ trợ và những kết hợp khác sẽ được thêm vào trong tương lai. Một số trục này là:

  • Đào tạo đồng bộ và không đồng bộ: Đây là hai cách phổ biến để phân phối đào tạo với dữ liệu song song. Trong đào tạo đồng bộ, tất cả các công nhân đào tạo trên các lát dữ liệu đầu vào khác nhau đồng bộ hóa và tổng hợp độ dốc ở mỗi bước. Trong đào tạo không đồng bộ, tất cả các công nhân được đào tạo độc lập về dữ liệu đầu vào và cập nhật các biến không đồng bộ. Thông thường đào tạo đồng bộ hóa được hỗ trợ thông qua all-less và async thông qua kiến ​​trúc máy chủ tham số.
  • Nền tảng phần cứng: Bạn có thể muốn mở rộng quy mô đào tạo của mình lên nhiều GPU trên một máy hoặc nhiều máy trong một mạng (với 0 hoặc nhiều GPU mỗi loại) hoặc trên Cloud TPU.

Để hỗ trợ các trường hợp sử dụng này, có sáu chiến lược có sẵn. Trong phần tiếp theo, chúng tôi giải thích những yếu tố nào trong số này được hỗ trợ trong trường hợp nào trong TF 2.2 tại thời điểm này. Dưới đây là tổng quan nhanh:

API đào tạo Nhân đôi chiến lược Chiến lược MultiWorkerMirroredStrargety CentralStorageStrargety ParameterServerStrargety
API máy ảnh Được hỗ trợ Được hỗ trợ Hỗ trợ thí nghiệm Hỗ trợ thí nghiệm Hỗ trợ bài kế hoạch 2.3
Vòng lặp đào tạo tùy chỉnh Được hỗ trợ Được hỗ trợ Hỗ trợ thí nghiệm Hỗ trợ thí nghiệm Hỗ trợ bài kế hoạch 2.3
API ước tính Hỗ trợ hạn chế Không được hỗ trợ Hỗ trợ hạn chế Hỗ trợ hạn chế Hỗ trợ hạn chế

Nhân đôi chiến lược

tf.distribute.MirroredStrategy hỗ trợ đào tạo phân tán đồng bộ trên nhiều GPU trên một máy. Nó tạo ra một bản sao trên mỗi thiết bị GPU. Mỗi biến trong mô hình được nhân đôi trên tất cả các bản sao. Cùng với nhau, các biến này tạo thành một biến khái niệm duy nhất được gọi là MirroredVariable . Các biến này được giữ đồng bộ với nhau bằng cách áp dụng các cập nhật giống hệt nhau.

Các thuật toán giảm tất cả hiệu quả được sử dụng để giao tiếp các bản cập nhật biến trên các thiết bị. Tất cả các bộ giảm tổng hợp trên tất cả các thiết bị bằng cách thêm chúng và làm cho chúng có sẵn trên mỗi thiết bị. Đó là một thuật toán hợp nhất rất hiệu quả và có thể giảm đáng kể chi phí đồng bộ hóa. Có nhiều thuật toán và triển khai tất cả có sẵn, tùy thuộc vào loại giao tiếp có sẵn giữa các thiết bị. Theo mặc định, nó sử dụng NVIDIA NCCL làm triển khai giảm tất cả. Bạn có thể chọn từ một vài tùy chọn khác mà chúng tôi cung cấp hoặc viết riêng của bạn.

Đây là cách đơn giản nhất để tạo MirroredStrategy :

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

Điều này sẽ tạo ra một cá thể MirroredStrategy sẽ sử dụng tất cả các GPU có thể nhìn thấy đối với TensorFlow và sử dụng NCCL làm giao tiếp chéo thiết bị.

Nếu bạn chỉ muốn sử dụng một số GPU trên máy của mình, bạn có thể làm như vậy:

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

Nếu bạn muốn ghi đè lên giao tiếp thiết bị chéo, bạn có thể làm như vậy bằng cách sử dụng đối số cross_device_ops bằng cách cung cấp một phiên bản của tf.distribute.CrossDeviceOps . Hiện tại, tf.distribute.HierarchicalCopyAllReducetf.distribute.ReductionToOneDevice là hai tùy chọn khác ngoài tf.distribute.NcclAllReduce là mặc định.

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

Chiến lược

tf.distribute.TPUStrategy cho phép bạn chạy chương trình đào tạo TensorFlow của mình trên Đơn vị xử lý kéo căng (TPU). TPU là ASIC chuyên dụng của Google được thiết kế để tăng tốc đáng kể khối lượng công việc học máy. Chúng có sẵn trên Google Colab, Cloud Research CloudCloud TPU .

Về mặt kiến ​​trúc đào tạo phân tán, TPUStrategy giống với MirroredStrategy - nó thực hiện đào tạo phân tán đồng bộ. TPU cung cấp việc thực hiện riêng của họ về giảm thiểu hiệu quả và các hoạt động tập thể khác trên nhiều lõi TPU, được sử dụng trong TPUStrategy .

Đây là cách bạn sẽ khởi tạo 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)
 

Ví dụ TPUClusterResolver giúp định vị các TPU. Trong Colab, bạn không cần chỉ định bất kỳ đối số nào cho nó.

Nếu bạn muốn sử dụng điều này cho Cloud TPU:

  • Bạn phải chỉ định tên tài nguyên TPU của mình trong đối số tpu .
  • Bạn phải khởi tạo hệ thống tpu một cách rõ ràng khi bắt đầu chương trình. Điều này là cần thiết trước khi TPU có thể được sử dụng để tính toán. Khởi tạo hệ thống tpu cũng xóa sạch bộ nhớ TPU, vì vậy điều quan trọng là phải hoàn thành bước này trước tiên để tránh mất trạng thái.

MultiWorkerMirroredStrargety

tf.distribute.experimental.MultiWorkerMirroredStrategy rất giống với MirroredStrategy . Nó triển khai đào tạo phân tán đồng bộ trên nhiều công nhân, mỗi công nhân có nhiều GPU. Tương tự như MirroredStrategy , nó tạo ra các bản sao của tất cả các biến trong mô hình trên mỗi thiết bị trên tất cả các công nhân.

Nó sử dụng CollectiveOps làm phương thức giao tiếp đa nhân công được sử dụng để giữ các biến đồng bộ. Một op tập thể là một op duy nhất trong biểu đồ TensorFlow có thể tự động chọn thuật toán giảm tất cả trong thời gian chạy TensorFlow theo phần cứng, cấu trúc liên kết mạng và kích thước tenor.

Nó cũng thực hiện tối ưu hóa hiệu suất bổ sung. Ví dụ, nó bao gồm một tối ưu hóa tĩnh giúp chuyển đổi nhiều mức giảm tất cả trên các thang đo nhỏ thành ít hơn tất cả các mức giảm trên các thang đo lớn hơn. Ngoài ra, chúng tôi đang thiết kế nó để có kiến ​​trúc plugin - để trong tương lai, bạn sẽ có thể bổ sung các thuật toán được điều chỉnh tốt hơn cho phần cứng của bạn. Lưu ý rằng các ops tập thể cũng thực hiện các hoạt động tập thể khác như phát sóng và thu thập tất cả.

Đây là cách đơn giản nhất để tạo 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 hiện cho phép bạn lựa chọn giữa hai triển khai ops tập thể khác nhau. CollectiveCommunication.RING Truyền thông.RING thực hiện các tập thể dựa trên vòng sử dụng gRPC làm lớp giao tiếp. CollectiveCommunication.NCCL Truyền thông.NCCL sử dụng NCCL của Nvidia để triển khai tập thể. CollectiveCommunication.AUTO thông.AUTO trì hoãn sự lựa chọn cho thời gian chạy. Sự lựa chọn tốt nhất để thực hiện tập thể phụ thuộc vào số lượng và loại GPU và kết nối mạng trong cụm. Bạn có thể chỉ định chúng theo cách sau:

 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

Một trong những khác biệt chính để đào tạo nhiều nhân viên, so với đào tạo đa GPU, là thiết lập nhiều công nhân. TF_CONFIG môi trường TF_CONFIG là cách tiêu chuẩn trong TensorFlow để chỉ định cấu hình cụm cho mỗi công nhân là một phần của cụm. Tìm hiểu thêm về cách thiết lập TF_CONFIG .

CentralStorageStrargety

tf.distribute.experimental.CentralStorageStrategy cũng đào tạo đồng bộ. Các biến không được nhân đôi, thay vào đó chúng được đặt trên CPU và các hoạt động được sao chép trên tất cả các GPU cục bộ. Nếu chỉ có một GPU, tất cả các biến và hoạt động sẽ được đặt trên GPU đó.

Tạo một thể hiện của CentralStorageStrategy bằng cách:

 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'

Điều này sẽ tạo ra một cá thể CentralStorageStrategy sẽ sử dụng tất cả các GPU và CPU có thể nhìn thấy. Cập nhật các biến trên bản sao sẽ được tổng hợp trước khi áp dụng cho các biến.

ParameterServerStrargety

tf.distribute.experimental.ParameterServerStrategy hỗ trợ đào tạo máy chủ tham số trên nhiều máy. Trong thiết lập này, một số máy được chỉ định là công nhân và một số là máy chủ tham số. Mỗi biến của mô hình được đặt trên một máy chủ tham số. Tính toán được nhân rộng trên tất cả các GPU của tất cả các công nhân.

Về mặt mã, nó trông tương tự như các chiến lược khác:

 ps_strategy = tf.distribute.experimental.ParameterServerStrategy()
 

Để đào tạo nhiều nhân viên, TF_CONFIG cần chỉ định cấu hình của các máy chủ tham số và công nhân trong cụm của bạn, bạn có thể đọc thêm về TF_CONFIG bên dưới .

Các chiến lược khác

Ngoài các chiến lược trên, có hai chiến lược khác có thể hữu ích cho việc tạo mẫu và gỡ lỗi khi sử dụng API tf.distribute .

Chiến lược mặc định

Chiến lược mặc định là một chiến lược phân phối có mặt khi không có chiến lược phân phối rõ ràng trong phạm vi. Nó thực hiện giao diện tf.distribute.Strategy nhưng là một giao thức và không cung cấp phân phối thực tế. Chẳng hạn, strategy.run(fn) sẽ gọi fn . Mã được viết bằng chiến lược này sẽ hoạt động chính xác như mã được viết mà không có chiến lược nào. Bạn có thể nghĩ về nó như một chiến lược "không-op".

Chiến lược mặc định là một singleton - và người ta không thể tạo thêm phiên bản của nó. Có thể lấy được bằng cách sử dụng tf.distribute.get_strategy() bên ngoài bất kỳ phạm vi chiến lược rõ ràng nào (cùng API có thể được sử dụng để đưa chiến lược hiện tại vào trong phạm vi chiến lược rõ ràng).

 default_strategy = tf.distribute.get_strategy()
 

Chiến lược này phục vụ hai mục đích chính:

  • Nó cho phép viết mã thư viện nhận biết phân phối vô điều kiện. Ví dụ: trong trình tối ưu hóa, chúng ta có thể thực hiện tf.distribute.get_strategy() và sử dụng chiến lược đó để giảm độ dốc - nó sẽ luôn trả về một đối tượng chiến lược mà chúng ta có thể gọi API giảm.
 # 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
  • Tương tự như mã thư viện, nó có thể được sử dụng để viết các chương trình của người dùng cuối để làm việc với và không có chiến lược phân phối, mà không yêu cầu logic có điều kiện. Một đoạn mã mẫu minh họa điều này:
 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>

OneDeviceStrargety

tf.distribute.OneDeviceStrategy là một chiến lược để đặt tất cả các biến và tính toán trên một thiết bị được chỉ định.

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

Chiến lược này khác với chiến lược mặc định theo một số cách. Trong chiến lược mặc định, logic vị trí biến không thay đổi khi so sánh với việc chạy TensorFlow mà không có bất kỳ chiến lược phân phối nào. Nhưng khi sử dụng OneDeviceStrategy , tất cả các biến được tạo trong phạm vi của nó được đặt rõ ràng trên thiết bị được chỉ định. Hơn nữa, bất kỳ chức năng nào được gọi thông qua OneDeviceStrategy.run cũng sẽ được đặt trên thiết bị được chỉ định.

Đầu vào được phân phối thông qua chiến lược này sẽ được tìm nạp trước đến thiết bị được chỉ định. Trong chiến lược mặc định, không có phân phối đầu vào.

Tương tự như chiến lược mặc định, chiến lược này cũng có thể được sử dụng để kiểm tra mã của bạn trước khi chuyển sang các chiến lược khác thực sự phân phối cho nhiều thiết bị / máy. Điều này sẽ thực hiện bộ máy chiến lược phân phối nhiều hơn chiến lược mặc định, nhưng không đến mức đầy đủ như sử dụng MirroredStrategy hoặc TPUStrategy v.v. Nếu bạn muốn mã hoạt động như thể không có chiến lược, thì hãy sử dụng chiến lược mặc định.

Cho đến nay chúng ta đã nói về các chiến lược khác nhau có sẵn là gì và làm thế nào bạn có thể khởi tạo chúng. Trong một vài phần tiếp theo, chúng tôi sẽ nói về những cách khác nhau mà bạn có thể sử dụng chúng để phân phối đào tạo của mình. Chúng tôi sẽ hiển thị các đoạn mã ngắn trong hướng dẫn này và liên kết với các hướng dẫn đầy đủ mà bạn có thể chạy từ đầu đến cuối.

Sử dụng tf.distribute.Strategy với tf.keras.Model.fit

Chúng tôi đã tích hợp tf.distribute.Strategy vào tf.keras , đây là triển khai của đặc tả API của Keras . tf.keras là một API cấp cao để xây dựng và huấn luyện các mô hình. Bằng cách tích hợp vào tf.keras phụ trợ tf.keras , chúng tôi đã giúp bạn phân phối chương trình đào tạo của mình được viết trong khung đào tạo model.fit bằng model.fit .

Đây là những gì bạn cần thay đổi trong mã của bạn:

  1. Tạo một thể hiện của tf.distribute.Strategy thích hợp.
  2. Di chuyển việc tạo ra các mô hình Keras, ưu và số liệu bên trong strategy.scope .

Chúng tôi hỗ trợ tất cả các loại mô hình Keras - tuần tự, chức năng và phân lớp.

Đây là một đoạn mã để làm điều này cho một mô hình Keras rất đơn giản với một lớp dày đặc:

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

Trong ví dụ này, chúng tôi đã sử dụng MirroredStrategy để chúng tôi có thể chạy nó trên một máy có nhiều GPU. Strateg.scope strategy.scope() chỉ ra cho Keras nên sử dụng chiến lược nào để phân phối đào tạo. Tạo mô hình / tối ưu hóa / số liệu trong phạm vi này cho phép chúng tôi tạo các biến phân tán thay vì các biến thông thường. Khi điều này được thiết lập, bạn có thể phù hợp với mô hình của bạn như bình thường. MirroredStrategy đảm nhiệm việc sao chép đào tạo của mô hình về các GPU có sẵn, tổng hợp độ dốc và hơn thế nữa.

 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

Ở đây chúng tôi đã sử dụng một tf.data.Dataset để cung cấp đầu vào đào tạo và eval. Bạn cũng có thể sử dụng mảng 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 1ms/step - loss: 0.1961
Epoch 2/2
10/10 [==============================] - 0s 1ms/step - loss: 0.0867

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

Trong cả hai trường hợp (tập dữ liệu hoặc numpy), mỗi lô đầu vào đã cho được chia đều cho nhiều bản sao. Chẳng hạn, nếu sử dụng MirroredStrategy với 2 GPU, mỗi lô kích thước 10 sẽ được chia cho 2 GPU, với mỗi lần nhận 5 ví dụ đầu vào trong mỗi bước. Mỗi epoch sau đó sẽ đào tạo nhanh hơn khi bạn thêm nhiều GPU. Thông thường, bạn sẽ muốn tăng kích thước lô của mình khi bạn thêm nhiều máy gia tốc để sử dụng hiệu quả sức mạnh tính toán thêm. Bạn cũng sẽ cần điều chỉnh lại tỷ lệ học tập của mình, tùy thuộc vào mô hình. Bạn có thể sử dụng strategy.num_replicas_in_sync để lấy số lượng bản sao.

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

Những gì được hỗ trợ bây giờ?

API đào tạo Nhân đôi chiến lược Chiến lược MultiWorkerMirroredStrargety CentralStorageStrargety ParameterServerStrargety
API máy ảnh Được hỗ trợ Được hỗ trợ Hỗ trợ thí nghiệm Hỗ trợ thí nghiệm Hỗ trợ kế hoạch bài 2.3

Ví dụ và hướng dẫn

Dưới đây là danh sách các hướng dẫn và ví dụ minh họa kết thúc tích hợp ở trên để kết thúc với Keras:

  1. Hướng dẫn đào tạo MNIST với MirroredStrategy .
  2. Hướng dẫn đào tạo MNIST bằng MultiWorkerMirroredStrategy .
  3. Hướng dẫn đào tạo MNIST bằng cách sử dụng TPUStrategy .
  4. Kho lưu trữ Vườn Mô hình TensorFlow chứa các bộ sưu tập các mô hình hiện đại được triển khai bằng nhiều chiến lược khác nhau.

Sử dụng tf.distribute.Strategy với các vòng lặp đào tạo tùy chỉnh

Như bạn đã thấy, sử dụng tf.distribute.Strategy với Keras model.fit yêu cầu chỉ thay đổi một vài dòng mã của bạn. Với một chút nỗ lực hơn, bạn cũng có thể sử dụng tf.distribute.Strategy với các vòng lặp đào tạo tùy chỉnh.

Nếu bạn cần linh hoạt hơn và kiểm soát các vòng lặp đào tạo của mình nhiều hơn có thể với Công cụ ước tính hoặc Máy ảnh, bạn có thể viết các vòng lặp đào tạo tùy chỉnh. Chẳng hạn, khi sử dụng GAN, bạn có thể muốn thực hiện một số bước khác nhau của trình tạo hoặc phân biệt đối xử mỗi vòng. Tương tự, các khung trình độ cao không phù hợp lắm cho đào tạo Học tập Củng cố.

Để hỗ trợ các vòng lặp đào tạo tùy chỉnh, chúng tôi cung cấp một tập hợp các phương thức cốt lõi thông qua các lớp tf.distribute.Strategy . Việc sử dụng chúng có thể yêu cầu tái cấu trúc mã ban đầu, nhưng sau khi hoàn thành, bạn sẽ có thể chuyển đổi giữa GPU, TPU và nhiều máy chỉ bằng cách thay đổi thể hiện chiến lược.

Ở đây chúng tôi sẽ hiển thị một đoạn ngắn minh họa trường hợp sử dụng này cho một ví dụ đào tạo đơn giản sử dụng mô hình Keras giống như trước đây.

Đầu tiên, chúng tôi tạo mô hình và trình tối ưu hóa trong phạm vi của chiến lược. Điều này đảm bảo rằng bất kỳ biến nào được tạo bằng mô hình và trình tối ưu hóa đều là các biến được nhân đôi.

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

Tiếp theo, chúng tôi tạo tập dữ liệu đầu vào và gọi tf.distribute.Strategy.experimental_distribute_dataset để phân phối tập dữ liệu dựa trên chiến lược.

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

Sau đó, chúng tôi xác định một bước của đào tạo. Chúng tôi sẽ sử dụng tf.GradientTape để tính toán độ dốc và trình tối ưu hóa để áp dụng các độ dốc đó để cập nhật các biến mô hình của chúng tôi. Để phân phối bước đào tạo này, chúng tôi đưa vào một hàm train_step và chuyển nó đến tf.distrbute.Strategy.run cùng với các dữ liệu đầu vào mà chúng tôi nhận được từ dist_dataset được tạo trước đó:

 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)
 

Một vài điều khác cần lưu ý trong đoạn mã trên:

  1. Chúng tôi đã sử dụng tf.nn.compute_average_loss để tính toán tổn thất. tf.nn.compute_average_loss tổng tổn thất cho mỗi ví dụ và chia tổng cho global_batch_size. Điều này rất quan trọng vì sau này sau khi độ dốc được tính toán trên mỗi bản sao, chúng được tổng hợp trên các bản sao bằng cách tính tổng chúng.
  2. Chúng tôi đã sử dụng API tf.distribute.Strategy.reduce để tổng hợp các kết quả được trả về bởi tf.distribute.Strategy.run . tf.distribute.Strategy.run trả về kết quả từ mỗi bản sao cục bộ trong chiến lược và có nhiều cách để sử dụng kết quả này. Bạn có thể reduce chúng để có được một giá trị tổng hợp. Bạn cũng có thể thực hiện tf.distribute.Strategy.experimental_local_results để lấy danh sách các giá trị có trong kết quả, mỗi giá trị trên một bản sao cục bộ.
  3. Khi apply_gradients được gọi trong phạm vi chiến lược phân phối, hành vi của nó được sửa đổi. Cụ thể, trước khi áp dụng độ dốc trên mỗi trường hợp song song trong quá trình đào tạo đồng bộ, nó thực hiện tổng cộng trên tất cả các bản sao của độ dốc.

Cuối cùng, khi chúng ta đã xác định bước đào tạo, chúng ta có thể lặp lại qua dist_dataset và chạy đào tạo theo vòng lặp:

 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)

Trong ví dụ trên, chúng tôi đã lặp lại trên dist_dataset để cung cấp đầu vào cho khóa đào tạo của bạn. Chúng tôi cũng cung cấp tf.distribute.Strategy.make_experimental_numpy_dataset để hỗ trợ các đầu vào numpy. Bạn có thể sử dụng API này để tạo bộ dữ liệu trước khi gọi tf.distribute.Strategy.experimental_distribute_dataset .

Một cách khác để lặp lại dữ liệu của bạn là sử dụng rõ ràng các trình lặp. Bạn có thể muốn làm điều này khi bạn muốn chạy trong một số bước nhất định trái ngược với việc lặp lại trên toàn bộ tập dữ liệu. Lặp lại ở trên bây giờ sẽ được sửa đổi để đầu tiên tạo ra một trình vòng lặp và sau đó gọi một cách rõ ràng next trên nó để có được dữ liệu đầu vào.

 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)

Điều này bao gồm trường hợp đơn giản nhất là sử dụng API tf.distribute.Strategy để phân phối các vòng lặp đào tạo tùy chỉnh. Chúng tôi đang trong quá trình cải thiện các API này. Vì trường hợp sử dụng này đòi hỏi nhiều công việc hơn để điều chỉnh mã của bạn, chúng tôi sẽ xuất bản một hướng dẫn chi tiết riêng trong tương lai.

Những gì được hỗ trợ bây giờ?

API đào tạo Nhân đôi chiến lược Chiến lược MultiWorkerMirroredStrargety CentralStorageStrargety ParameterServerStrargety
Vòng lặp đào tạo tùy chỉnh Được hỗ trợ Được hỗ trợ Hỗ trợ thí nghiệm Hỗ trợ thí nghiệm Hỗ trợ kế hoạch bài 2.3

Ví dụ và hướng dẫn

Dưới đây là một số ví dụ để sử dụng chiến lược phân phối với các vòng huấn luyện tùy chỉnh:

  1. Hướng dẫn đào tạo MNIST bằng MirroredStrategy .
  2. Hướng dẫn đào tạo MNIST bằng cách sử dụng TPUStrategy .
  3. Kho lưu trữ Vườn Mô hình TensorFlow chứa các bộ sưu tập các mô hình hiện đại được triển khai bằng nhiều chiến lược khác nhau.

Sử dụng tf.distribute.Strategy with Ước tính (Hỗ trợ có giới hạn)

tf.estimator là một API TensorFlow đào tạo phân tán, ban đầu hỗ trợ cách tiếp cận máy chủ tham số async. Giống như với Keras, chúng tôi đã tích hợp tf.distribute.Strategy vào tf.Estimator . Nếu bạn đang sử dụng Công cụ ước tính cho đào tạo của mình, bạn có thể dễ dàng thay đổi sang đào tạo phân tán với rất ít thay đổi cho mã của mình. Với điều này, người dùng Ước tính giờ đây có thể thực hiện đào tạo phân tán đồng bộ trên nhiều GPU và nhiều công nhân, cũng như sử dụng TPU. Hỗ trợ này trong Công cụ ước tính, tuy nhiên, bị hạn chế. Xem phần được hỗ trợ ngay bây giờ bên dưới để biết thêm chi tiết.

Việc sử dụng tf.distribute.Strategy with Ước tính hơi khác so với trường hợp Keras. Thay vì sử dụng strategy.scope , bây giờ chúng ta vượt qua các đối tượng chiến lược vào RunConfig cho Công cụ Ước tính.

Dưới đây là một đoạn mã mà chương trình này với một premade Estimator LinearRegressorMirroredStrategy :

 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}

Chúng tôi sử dụng Công cụ ước tính tiền tố ở đây, nhưng mã tương tự cũng hoạt động với Công cụ ước tính tùy chỉnh. train_distribute xác định cách đào tạo sẽ được phân phối và eval_distribute xác định cách đánh giá sẽ được phân phối. Đây là một điểm khác biệt so với Keras nơi chúng tôi sử dụng cùng một chiến lược cho cả đào tạo và eval.

Bây giờ chúng ta có thể đào tạo và đánh giá Công cụ ước tính này với chức năng nhập liệu:

 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}

Một điểm khác biệt cần làm nổi bật ở đây giữa Công cụ ước tính và Máy ảnh là việc xử lý đầu vào. Trong Keras, chúng tôi đã đề cập rằng mỗi lô dữ liệu được phân chia tự động trên nhiều bản sao. Tuy nhiên, trong Công cụ ước tính, chúng tôi không tự động phân tách lô, cũng không tự động phân chia dữ liệu giữa các công nhân khác nhau. Bạn có toàn quyền kiểm soát cách bạn muốn dữ liệu của mình được phân phối trên các công nhân và thiết bị và bạn phải cung cấp input_fn để chỉ định cách phân phối dữ liệu của mình.

input_fn của bạn được gọi một lần cho mỗi công nhân, do đó cung cấp một bộ dữ liệu cho mỗi công nhân. Sau đó, một lô từ bộ dữ liệu đó được đưa đến một bản sao trên công nhân đó, do đó tiêu thụ N lô cho N bản sao trên 1 công nhân. Nói cách khác, tập dữ liệu được trả về bởi input_fn sẽ cung cấp các lô có kích thước PER_REPLICA_BATCH_SIZE . Và kích thước lô toàn cầu cho một bước có thể được lấy là PER_REPLICA_BATCH_SIZE * strategy.num_replicas_in_sync .

Khi thực hiện đào tạo nhiều công nhân, bạn nên phân chia dữ liệu của mình cho các công nhân hoặc xáo trộn với một hạt giống ngẫu nhiên trên mỗi nhân viên. Bạn có thể xem một ví dụ về cách thực hiện việc này trong Đào tạo nhiều nhân viên với Công cụ ước tính .

Và tương tự, bạn cũng có thể sử dụng nhiều chiến lược máy chủ và tham số máy chủ. Mã vẫn giữ nguyên, nhưng bạn cần sử dụng tf.estimator.train_and_evaluate và đặt các biến môi trường TF_CONFIG cho mỗi nhị phân chạy trong cụm của bạn.

Những gì được hỗ trợ bây giờ?

Có hỗ trợ hạn chế cho việc đào tạo với Công cụ ước tính bằng cách sử dụng tất cả các chiến lược ngoại trừ TPUStrategy . Đào tạo và đánh giá cơ bản nên hoạt động, nhưng một số tính năng nâng cao như giàn giáo chưa hoạt động. Cũng có thể có một số lỗi trong tích hợp này. Tại thời điểm này, chúng tôi không có kế hoạch tích cực cải thiện hỗ trợ này, và thay vào đó tập trung vào Keras và hỗ trợ vòng lặp đào tạo tùy chỉnh. Nếu có thể, bạn nên sử dụng tf.distribute với các API đó thay thế.

API đào tạo Nhân đôi chiến lược Chiến lược MultiWorkerMirroredStrargety CentralStorageStrargety ParameterServerStrargety
API ước tính Hỗ trợ hạn chế Không được hỗ trợ Hỗ trợ hạn chế Hỗ trợ hạn chế Hỗ trợ hạn chế

Ví dụ và hướng dẫn

Dưới đây là một số ví dụ cho thấy việc sử dụng từ đầu đến cuối của các chiến lược khác nhau với Công cụ ước tính:

  1. Đào tạo nhiều công nhân với Công cụ ước tính để đào tạo MNIST với nhiều công nhân sử dụng MultiWorkerMirroredStrategy .
  2. Ví dụ từ đầu đến cuối để đào tạo nhiều công nhân trong hệ thống kéo căng / hệ sinh thái bằng cách sử dụng các mẫu Kubernetes. Ví dụ này bắt đầu với một mô hình Keras và chuyển đổi nó thành Công cụ ước tính bằng cách sử dụng API tf.keras.estimator.model_to_estimator .
  3. Mô hình ResNet50 chính thức, có thể được đào tạo bằng MirroredStrategy hoặc MultiWorkerMirroredStrategy .

Các chủ đề khác

Trong phần này, chúng tôi sẽ đề cập đến một số chủ đề có liên quan đến nhiều trường hợp sử dụng.

Thiết lập biến môi trường TF_CONFIG

Để đào tạo nhiều nhân viên, như đã đề cập trước đó, bạn cần đặt biến môi trường TF_CONFIG cho mỗi nhị phân chạy trong cụm của bạn. TF_CONFIG môi trường TF_CONFIG là một chuỗi JSON chỉ định những nhiệm vụ nào tạo thành một cụm, địa chỉ của chúng và từng vai trò của nhiệm vụ trong cụm. Chúng tôi cung cấp một mẫu Kubernetes trong repo dòng chảy / hệ sinh thái , thiết lập TF_CONFIG cho các nhiệm vụ đào tạo của bạn.

Có hai thành phần của TF_CONFIG: cluster và task. cụm cung cấp thông tin về cụm đào tạo, đó là một lệnh bao gồm các loại công việc khác nhau như công nhân. Trong đào tạo nhiều công nhân, thường có một công nhân chịu trách nhiệm hơn một chút như lưu điểm kiểm tra và viết tệp tóm tắt cho TensorBoard ngoài những gì một công nhân bình thường làm. Công nhân như vậy được gọi là công nhân 'trưởng' và theo thông lệ, công nhân có chỉ số 0 được bổ nhiệm làm công nhân trưởng (thực tế đây là cách tf.distribution.Strargety được thực hiện). mặt khác nhiệm vụ cung cấp thông tin của nhiệm vụ hiện tại. Cụm thành phần đầu tiên giống nhau cho tất cả các công nhân và nhiệm vụ thành phần thứ hai là khác nhau đối với mỗi công nhân và chỉ định loại và chỉ mục của công nhân đó.

Một ví dụ về TF_CONFIG là:

 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 này chỉ định rằng có ba công nhân và hai tác vụ ps trong cụm cùng với máy chủ và cổng của chúng. Phần "tác vụ" xác định rằng vai trò của tác vụ hiện tại trong cụm, worker 1 (worker thứ hai). Vai trò hợp lệ trong một cụm là "trưởng", "công nhân", "ps" và "người đánh giá". Không nên có công việc "ps" ngoại trừ khi sử dụng tf.distribute.experimental.ParameterServerStrategy .

Cái gì tiếp theo?

tf.distribute.Strategy đang tích cực phát triển. Chúng tôi hoan nghênh bạn dùng thử và cung cấp và phản hồi của bạn bằng các vấn đề của GitHub .