อบรมแบบกระจายด้วย TensorFlow

ดูบน TensorFlow.org ทำงานใน Google Colab ดูแหล่งที่มาบน GitHub ดาวน์โหลดโน๊ตบุ๊ค

ภาพรวม

tf.distribute.Strategy คือ API TensorFlow เพื่อกระจายการฝึกอบรมทั่ว GPUs หลายหลายเครื่องหรือ TPUs เมื่อใช้ API นี้ คุณสามารถแจกจ่ายโมเดลที่มีอยู่และโค้ดการฝึกอบรมโดยมีการเปลี่ยนแปลงโค้ดเพียงเล็กน้อย

tf.distribute.Strategy ได้รับการออกแบบที่มีเป้าหมายที่สำคัญเหล่านี้ในใจ:

  • ใช้งานง่ายและสนับสนุนกลุ่มผู้ใช้หลายกลุ่ม รวมถึงนักวิจัย วิศวกร ML เป็นต้น
  • ให้ประสิทธิภาพที่ดีตั้งแต่แกะกล่อง
  • สลับระหว่างกลยุทธ์ได้ง่าย

tf.distribute.Strategy สามารถนำมาใช้กับ API ระดับสูงเช่น Keras และยังสามารถนำมาใช้ในการแจกจ่ายลูปการฝึกอบรมที่กำหนดเอง (และโดยทั่วไปการคำนวณโดยใช้ TensorFlow)

ใน TensorFlow 2.x คุณสามารถรันโปรแกรมของคุณกระหายหรือในกราฟโดยใช้ tf.function tf.distribute.Strategy มุ่งมั่นที่จะสนับสนุนทั้งโหมดเหล่านี้ของการดำเนินการ แต่ทำงานได้ดีที่สุดกับ tf.function โหมดความกระตือรือร้นที่จะแนะนำเพียงเพื่อวัตถุประสงค์ในการแก้จุดบกพร่องและไม่สนับสนุนการ TPUStrategy แม้ว่าการฝึกอบรมจะเป็นจุดเน้นของคู่มือนี้ แต่ API นี้ยังสามารถใช้เพื่อแจกจ่ายการประเมินและการคาดการณ์บนแพลตฟอร์มต่างๆ

คุณสามารถใช้ tf.distribute.Strategy มีการเปลี่ยนแปลงน้อยมากในรหัสของคุณเพราะส่วนประกอบพื้นฐานของ TensorFlow จะถูกเปลี่ยนให้กลายเป็นกลยุทธ์ที่ทราบ ซึ่งรวมถึงตัวแปร เลเยอร์ โมเดล เครื่องมือเพิ่มประสิทธิภาพ ตัวชี้วัด สรุป และจุดตรวจสอบ

ในคู่มือนี้ คุณจะได้เรียนรู้เกี่ยวกับกลยุทธ์ประเภทต่างๆ และวิธีใช้งานในสถานการณ์ต่างๆ ต้องการเรียนรู้วิธีที่จะแก้ปัญหาปัญหาประสิทธิภาพการทำงานให้ดูที่ ผลการดำเนินงานเพิ่มประสิทธิภาพ TensorFlow GPU คู่มือ

# Import TensorFlow
import tensorflow as tf
2021-07-14 01:23:18.251555: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0

ประเภทของกลยุทธ์

tf.distribute.Strategy ตั้งใจที่จะครอบคลุมจำนวนของกรณีการใช้งานที่แตกต่างกันไปตามแกน ปัจจุบันชุดค่าผสมเหล่านี้บางส่วนได้รับการสนับสนุนและชุดค่าผสมอื่นๆ จะถูกเพิ่มในอนาคต แกนเหล่านี้บางส่วนคือ:

  • ซิงโคร VS การฝึกอบรมไม่ตรงกัน: เหล่านี้มีสองวิธีการทั่วไปของการกระจายการฝึกอบรมกับขนานข้อมูล ในการฝึกอบรมการซิงค์ ผู้ปฏิบัติงานทุกคนจะฝึกอบรมในส่วนต่างๆ ของข้อมูลอินพุตที่ซิงค์กัน และการรวมการไล่ระดับสีในแต่ละขั้นตอน ในการฝึกอบรมแบบอะซิงโครนัส ผู้ปฏิบัติงานทุกคนจะได้รับการฝึกอบรมเกี่ยวกับข้อมูลที่ป้อนเข้าและอัปเดตตัวแปรแบบอะซิงโครนัสอย่างอิสระ โดยทั่วไปการซิงค์การฝึกอบรมจะได้รับการสนับสนุนผ่านการลดทั้งหมดและอะซิงโครนัสผ่านสถาปัตยกรรมเซิร์ฟเวอร์พารามิเตอร์
  • แพลตฟอร์มฮาร์ดแวร์: คุณอาจต้องการที่จะไต่ฝึกอบรมของคุณบน GPUs หลายคนบนเครื่องหนึ่งหรือหลายเครื่องในเครือข่าย (0 หรือมากกว่า GPUs แต่ละ) หรือเกี่ยวกับ Cloud TPUs

เพื่อรองรับกรณีการใช้งานเหล่านี้ มี 6 กลยุทธ์ที่สามารถใช้ได้ ส่วนถัดไปจะอธิบายว่าสถานการณ์ใดได้รับการสนับสนุนในสถานการณ์ใดบ้างใน TensorFlow นี่คือภาพรวมโดยย่อ:

การฝึกอบรม API MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy CentralStorageStrategy ParameterServerStrategy
Keras API ได้รับการสนับสนุน ได้รับการสนับสนุน ได้รับการสนับสนุน การสนับสนุนการทดลอง รองรับการโพสต์ตามแผน 2.4
วงการฝึกแบบกำหนดเอง ได้รับการสนับสนุน ได้รับการสนับสนุน ได้รับการสนับสนุน การสนับสนุนการทดลอง การสนับสนุนการทดลอง
เครื่องมือประมาณการ API การสนับสนุนที่จำกัด ไม่รองรับ การสนับสนุนที่จำกัด การสนับสนุนที่จำกัด การสนับสนุนที่จำกัด

MirroredStrategy

tf.distribute.MirroredStrategy สนับสนุนการฝึกอบรมการกระจายซิงโครบน GPUs หลายคนในเครื่องหนึ่ง มันสร้างแบบจำลองหนึ่งรายการต่ออุปกรณ์ GPU ตัวแปรแต่ละตัวในแบบจำลองจะถูกมิเรอร์ในแบบจำลองทั้งหมด ร่วมกันตัวแปรเหล่านี้ในรูปแบบตัวแปรเดียวที่เรียกว่าแนวความคิด MirroredVariable ตัวแปรเหล่านี้ซิงค์กันโดยใช้การอัปเดตที่เหมือนกัน

อัลกอริธึมลดทั้งหมดอย่างมีประสิทธิภาพใช้เพื่อสื่อสารการอัปเดตตัวแปรในอุปกรณ์ต่างๆ All-reduce รวมเทนเซอร์ในอุปกรณ์ทั้งหมดโดยการเพิ่มเข้าด้วยกันและทำให้พร้อมใช้งานในแต่ละอุปกรณ์ เป็นอัลกอริธึมผสมที่มีประสิทธิภาพมากและสามารถลดโอเวอร์เฮดของการซิงโครไนซ์ได้อย่างมาก มีอัลกอริธึมและการใช้งานแบบลดทั้งหมดมากมาย ขึ้นอยู่กับประเภทของการสื่อสารระหว่างอุปกรณ์ โดยค่าเริ่มต้นจะใช้การ์ด NVIDIA Collective สื่อสารห้องสมุด ( NCCL ) ในขณะที่การดำเนินงานทั้งหมดลด คุณสามารถเลือกจากตัวเลือกอื่นๆ สองสามตัวหรือเขียนเอง

นี่คือวิธีที่ง่ายที่สุดในการสร้าง MirroredStrategy :

mirrored_strategy = tf.distribute.MirroredStrategy()
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
2021-07-14 01:23:19.530023: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcuda.so.1
2021-07-14 01:23:20.213426: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.214078: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: NVIDIA Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-07-14 01:23:20.214108: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-07-14 01:23:20.217733: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublas.so.11
2021-07-14 01:23:20.217820: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublasLt.so.11
2021-07-14 01:23:20.218871: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcufft.so.10
2021-07-14 01:23:20.219205: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcurand.so.10
2021-07-14 01:23:20.220324: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusolver.so.11
2021-07-14 01:23:20.221308: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusparse.so.11
2021-07-14 01:23:20.221482: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudnn.so.8
2021-07-14 01:23:20.221579: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.222279: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.222966: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-07-14 01:23:20.224084: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2021-07-14 01:23:20.224666: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.225322: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: NVIDIA Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-07-14 01:23:20.225396: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.226008: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.226671: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-07-14 01:23:20.226715: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-07-14 01:23:20.843669: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1258] Device interconnect StreamExecutor with strength 1 edge matrix:
2021-07-14 01:23:20.843707: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1264]      0 
2021-07-14 01:23:20.843716: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1277] 0:   N 
2021-07-14 01:23:20.843925: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.844616: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.845280: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.845985: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1418] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 14646 MB memory) -> physical GPU (device: 0, name: NVIDIA Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0)
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)

นี้จะสร้าง MirroredStrategy อินสแตนซ์ซึ่งจะใช้ GPUs ทั้งหมดที่สามารถมองเห็นได้ TensorFlow และ NCCL-เป็นการสื่อสารข้ามอุปกรณ์

หากคุณต้องการใช้ GPU เพียงบางส่วนในเครื่องของคุณ คุณสามารถทำได้ดังนี้:

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
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1')

หากคุณต้องการที่จะแทนที่การสื่อสารอุปกรณ์ข้ามคุณสามารถทำได้โดยใช้ cross_device_ops โต้แย้งโดยการจัดหาตัวอย่างของ tf.distribute.CrossDeviceOps ปัจจุบัน tf.distribute.HierarchicalCopyAllReduce และ tf.distribute.ReductionToOneDevice สองตัวเลือกอื่นที่ไม่ใช่ tf.distribute.NcclAllReduce ซึ่งเป็นค่าเริ่มต้น

mirrored_strategy = tf.distribute.MirroredStrategy(
    cross_device_ops=tf.distribute.HierarchicalCopyAllReduce())
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)

TPUStrategy

tf.distribute.TPUStrategy ช่วยให้คุณสามารถเรียกใช้การฝึกอบรม TensorFlow ของคุณบน Tensor หน่วยประมวลผล (TPUs) TPU คือ ASIC เฉพาะของ Google ที่ออกแบบมาเพื่อเร่งปริมาณงานของแมชชีนเลิร์นนิงอย่างมาก พวกเขามีอยู่ใน Google Colab ที่ TPU วิจัยเมฆ และ เมฆ TPU

ในแง่ของสถาปัตยกรรมการฝึกอบรมกระจาย TPUStrategy เป็นเช่นเดียว MirroredStrategy -IT การดำเนินการฝึกอบรมการกระจายซิงโคร TPUs ให้การดำเนินงานของตัวเองที่มีประสิทธิภาพทั้งหมดลดและอื่น ๆ การดำเนินงานโดยรวมทั่วแกน TPU หลายที่ใช้ใน TPUStrategy

นี่คือวิธีที่คุณจะยกตัวอย่าง 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 เช่นช่วยหา TPUs ใน Colab คุณไม่จำเป็นต้องระบุอาร์กิวเมนต์ใดๆ

หากคุณต้องการใช้สิ่งนี้กับ Cloud TPU:

  • คุณต้องระบุชื่อของทรัพยากร TPU ของคุณใน tpu โต้แย้ง
  • คุณต้องเริ่มต้นระบบ TPU อย่างชัดเจนในช่วงเริ่มต้นของโปรแกรม สิ่งนี้จำเป็นก่อนจึงจะสามารถใช้ TPU สำหรับการคำนวณได้ การเริ่มต้นระบบ tpu จะทำให้หน่วยความจำ TPU หายไปด้วย ดังนั้นจึงต้องทำตามขั้นตอนนี้ให้เสร็จก่อนเพื่อหลีกเลี่ยงไม่ให้สถานะสูญหาย

MultiWorkerMirroredStrategy

tf.distribute.MultiWorkerMirroredStrategy จะคล้ายกับ MirroredStrategy ใช้การฝึกอบรมแบบกระจายแบบซิงโครนัสกับผู้ปฏิบัติงานหลายคน โดยแต่ละคนอาจมี GPU หลายตัว คล้ายกับ tf.distribute.MirroredStrategy จะสร้างสำเนาของตัวแปรทั้งหมดในรูปแบบบนอุปกรณ์ทั่วทุกคนแต่ละคน

นี่คือวิธีที่ง่ายที่สุดในการสร้าง MultiWorkerMirroredStrategy :

strategy = tf.distribute.MultiWorkerMirroredStrategy()
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 มีสองการใช้งานสำหรับการสื่อสารข้ามอุปกรณ์ CommunicationImplementation.RING เป็น RPC ชั่นและสนับสนุนทั้งซีพียูและ GPUs CommunicationImplementation.NCCL ใช้ NCCL และให้ประสิทธิภาพการทำงานของรัฐของศิลปะบน GPUs แต่มันไม่สนับสนุนซีพียู CollectiveCommunication.AUTO คล้อยตามทางเลือกที่จะ Tensorflow คุณสามารถระบุได้ด้วยวิธีต่อไปนี้:

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

ความแตกต่างที่สำคัญอย่างหนึ่งในการฝึกอบรมผู้ปฏิบัติงานหลายคน เมื่อเทียบกับการฝึกอบรม GPU หลายตัว คือการตั้งค่าผู้ปฏิบัติงานหลายคน TF_CONFIG ตัวแปรสภาพแวดล้อมเป็นวิธีมาตรฐานในการ TensorFlow เพื่อระบุการกำหนดค่าคลัสเตอร์เพื่อพนักงานแต่ละคนที่เป็นส่วนหนึ่งของกลุ่ม เรียนรู้เพิ่มเติมเกี่ยวกับ การตั้งค่า TF_CONFIG

ParameterServerStrategy

การฝึกอบรมเซิร์ฟเวอร์พารามิเตอร์เป็นวิธีคู่ขนานข้อมูลทั่วไปในการขยายขนาดการฝึกโมเดลบนเครื่องหลายเครื่อง คลัสเตอร์การฝึกอบรมเซิร์ฟเวอร์พารามิเตอร์ประกอบด้วยผู้ปฏิบัติงานและเซิร์ฟเวอร์พารามิเตอร์ ตัวแปรถูกสร้างขึ้นบนเซิร์ฟเวอร์พารามิเตอร์ และจะถูกอ่านและอัปเดตโดยผู้ปฏิบัติงานในแต่ละขั้นตอน ตรวจสอบ เซิร์ฟเวอร์พารามิเตอร์การฝึกอบรม การสอนสำหรับรายละเอียด

ใน TensorFlow 2 การฝึกอบรมเซิร์ฟเวอร์พารามิเตอร์ใช้สถาปัตยกรรมประสานงานตามกลางผ่าน tf.distribute.experimental.coordinator.ClusterCoordinator ระดับ

ในการดำเนินการนี้ worker และ parameter server งานทำงาน tf.distribute.Server s ที่ฟังสำหรับงานจากผู้ประสานงาน ผู้ประสานงานสร้างทรัพยากร จัดส่งงานฝึกอบรม เขียนจุดตรวจสอบ และจัดการกับความล้มเหลวของงาน

ในการเขียนโปรแกรมที่ทำงานบนประสานงานที่คุณจะใช้ ParameterServerStrategy วัตถุเพื่อกำหนดขั้นตอนการฝึกอบรมและใช้ ClusterCoordinator การส่งขั้นตอนการฝึกอบรมให้กับแรงงานที่ห่างไกล นี่เป็นวิธีที่ง่ายที่สุดในการสร้าง:

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

ใน TensorFlow 1 ParameterServerStrategy จะใช้ได้เฉพาะกับประมาณการผ่าน tf.compat.v1.distribute.experimental.ParameterServerStrategy สัญลักษณ์

CentralStorageStrategy

tf.distribute.experimental.CentralStorageStrategy ไม่ซิงโครการฝึกอบรมเป็นอย่างดี ตัวแปรจะไม่ถูกมิเรอร์ แต่จะวางบน CPU และการดำเนินการจะถูกจำลองใน GPU ทั้งหมดในเครื่อง หากมี GPU เพียงตัวเดียว ตัวแปรและการดำเนินการทั้งหมดจะถูกวางไว้บน GPU นั้น

สร้างตัวอย่างของ CentralStorageStrategy โดย:

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'

นี้จะสร้าง CentralStorageStrategy อินสแตนซ์ซึ่งจะใช้ GPUs ที่มองเห็นทั้งหมดและ CPU การอัปเดตตัวแปรบนแบบจำลองจะถูกรวมก่อนที่จะนำไปใช้กับตัวแปร

กลยุทธ์อื่นๆ

นอกเหนือไปจากกลยุทธ์ดังกล่าวข้างต้นมีสองกลยุทธ์อื่น ๆ ซึ่งอาจจะเป็นประโยชน์สำหรับการสร้างต้นแบบและการแก้จุดบกพร่องเมื่อใช้ tf.distribute APIs

กลยุทธ์เริ่มต้น

กลยุทธ์เริ่มต้นคือกลยุทธ์การกระจายที่มีอยู่เมื่อไม่มีกลยุทธ์การกระจายที่ชัดเจนอยู่ในขอบเขต มันดำเนิน tf.distribute.Strategy อินเตอร์เฟซ แต่เป็นส่งผ่านและให้ไม่มีการกระจายที่เกิดขึ้นจริง ยกตัวอย่างเช่น strategy.run(fn) ก็จะเรียก fn โค้ดที่เขียนโดยใช้กลยุทธ์นี้ควรทำงานเหมือนกับโค้ดที่เขียนโดยไม่มีกลยุทธ์ใดๆ คุณสามารถคิดได้ว่าเป็นกลยุทธ์ที่ "ไม่ดำเนินการ"

กลยุทธ์เริ่มต้นคือซิงเกิลตัน—และไม่มีใครสามารถสร้างอินสแตนซ์เพิ่มเติมได้ มันสามารถรับใช้ tf.distribute.get_strategy นอกขอบเขตใด ๆ กลยุทธ์ที่ชัดเจนของ (API เดียวกันที่สามารถนำมาใช้เพื่อให้ได้กลยุทธ์ปัจจุบันภายในขอบเขตกลยุทธ์ที่ชัดเจนของ)

default_strategy = tf.distribute.get_strategy()

กลยุทธ์นี้มีจุดประสงค์หลักสองประการ:

  • อนุญาตให้เขียนโค้ดไลบรารีที่รับรู้การแจกจ่ายโดยไม่มีเงื่อนไข ยกตัวอย่างเช่นใน tf.optimizer s ใช้สามารถ tf.distribute.get_strategy และการใช้กลยุทธ์ในการลดการไล่ระดับสีมันก็จะกลับมาเป็นวัตถุกลยุทธ์ที่คุณสามารถเรียกลด API
# 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
  • คล้ายกับรหัสไลบรารี สามารถใช้เขียนโปรแกรมของผู้ใช้ปลายทางเพื่อทำงานโดยมีและไม่มีกลยุทธ์การแจกจ่าย โดยไม่ต้องใช้ตรรกะแบบมีเงื่อนไข นี่คือตัวอย่างข้อมูลโค้ดที่แสดงสิ่งนี้:
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.))
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)
MirroredVariable:{
  0: <tf.Variable 'Variable:0' shape=() dtype=float32, numpy=1.0>
}

OneDeviceStrategy

tf.distribute.OneDeviceStrategy เป็นกลยุทธ์ที่จะวางตัวแปรทั้งหมดและการคำนวณบนอุปกรณ์ที่ระบุเดียว

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

กลยุทธ์นี้แตกต่างจากกลยุทธ์เริ่มต้นในหลายวิธี ในกลยุทธ์เริ่มต้น ตรรกะการจัดตำแหน่งตัวแปรยังคงไม่เปลี่ยนแปลงเมื่อเปรียบเทียบกับการรัน TensorFlow โดยไม่มีกลยุทธ์การกระจายใดๆ แต่เมื่อใช้ OneDeviceStrategy ตัวแปรทั้งหมดที่สร้างขึ้นในขอบเขตจะถูกวางไว้อย่างชัดเจนบนอุปกรณ์ที่ระบุ นอกจากนี้ยังมีฟังก์ชั่นใด ๆ ที่เรียกว่าผ่าน OneDeviceStrategy.run ยังจะถูกวางไว้บนอุปกรณ์ที่ระบุ

อินพุตที่กระจายผ่านกลยุทธ์นี้จะถูกดึงข้อมูลล่วงหน้าไปยังอุปกรณ์ที่ระบุ ในกลยุทธ์เริ่มต้น ไม่มีการกระจายอินพุต

เช่นเดียวกับกลยุทธ์เริ่มต้น กลยุทธ์นี้สามารถใช้เพื่อทดสอบโค้ดของคุณก่อนที่จะเปลี่ยนไปใช้กลยุทธ์อื่นที่แจกจ่ายไปยังอุปกรณ์/เครื่องจักรหลายเครื่องจริงๆ นี้จะออกกำลังกายเครื่องจักรกลยุทธ์การกระจายค่อนข้างมากกว่ากลยุทธ์ค่าเริ่มต้น แต่ไม่เต็มที่กับการใช้ MirroredStrategy หรือ TPUStrategy ฯลฯ หากคุณต้องการรหัสที่ทำงานเป็นถ้าไม่มีกลยุทธ์แล้วใช้กลยุทธ์การเริ่มต้น

จนถึงตอนนี้ คุณได้เห็นกลยุทธ์ต่างๆ ที่มีอยู่แล้ว และวิธีที่คุณสามารถยกตัวอย่างได้ สองสามส่วนถัดไปจะแสดงวิธีต่างๆ ที่คุณสามารถใช้เพื่อแจกจ่ายการฝึกอบรมของคุณ

ใช้ tf.distribute.Strategy กับ tf.keras.Model.fit

tf.distribute.Strategy ถูกรวมเข้าไปใน tf.keras ซึ่งคือการดำเนินการ TensorFlow ของ ข้อกำหนด Keras API tf.keras คือ API ระดับสูงในการสร้างและรถไฟรุ่น โดยบูรณาการเข้าไปใน tf.keras แบ็กเอนด์มันราบรื่นสำหรับคุณที่จะแจกจ่ายฝึกอบรมของคุณเขียนในกรอบการฝึกอบรมโดยใช้ Keras Model.fit

นี่คือสิ่งที่คุณต้องเปลี่ยนในโค้ดของคุณ:

  1. สร้างตัวอย่างของความเหมาะสม tf.distribute.Strategy
  2. ย้ายการสร้าง Keras รูปแบบ, เพิ่มประสิทธิภาพและตัวชี้วัดภายใน strategy.scope

กลยุทธ์การกระจาย TensorFlow รองรับโมเดล Keras ทุกประเภท—แบบลำดับ ฟังก์ชัน และคลาสย่อย

นี่คือตัวอย่างโค้ดสำหรับทำโมเดล Keras แบบง่ายๆ ที่มีเลเยอร์หนาแน่นเพียงชั้นเดียว:

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')
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
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',).

ตัวอย่างนี้ใช้ MirroredStrategy เพื่อให้คุณสามารถทำงานนี้ในเครื่องที่มีหลาย GPUs strategy.scope() บอก Keras ซึ่งกลยุทธ์ที่จะใช้ในการกระจายการฝึกอบรม การสร้างโมเดล/ตัวเพิ่มประสิทธิภาพ/ตัววัดภายในขอบเขตนี้ช่วยให้คุณสร้างตัวแปรแบบกระจายแทนตัวแปรปกติได้ เมื่อตั้งค่าแล้ว คุณสามารถใส่โมเดลของคุณได้ตามปกติ MirroredStrategy ดูแลการจำลองการฝึกอบรมรุ่นบน GPUs ที่มีอยู่รวมการไล่ระดับสีและอื่น ๆ

dataset = tf.data.Dataset.from_tensors(([1.], [1.])).repeat(100).batch(10)
model.fit(dataset, epochs=2)
model.evaluate(dataset)
Epoch 1/2
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
2021-07-14 01:23:21.641884: 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
        }
      }
    }
  }
}

2021-07-14 01:23:21.671942: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:176] None of the MLIR Optimization Passes are enabled (registered 2)
2021-07-14 01:23:21.672424: I tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 2000175000 Hz
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-07-14 01:23:24.013985: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublas.so.11
10/10 [==============================] - 3s 2ms/step - loss: 0.0014
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: 6.3687e-04
2021-07-14 01:23:24.434928: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublasLt.so.11
2021-07-14 01:23:24.528027: 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: 3.9551e-04
0.00039551049121655524

นี่เป็น tf.data.Dataset ให้การฝึกอบรมและการป้อนข้อมูล EVAL คุณยังสามารถใช้อาร์เรย์ 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
2021-07-14 01:23:25.775102: 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_1006"
    }
  }
}
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: 2.8150e-04
Epoch 2/2
10/10 [==============================] - 0s 2ms/step - loss: 1.2442e-04
<tensorflow.python.keras.callbacks.History at 0x7fe091028f50>

ในทั้งสองกรณีที่มี Dataset หรือ Numpy แต่ละชุดของการป้อนข้อมูลที่ได้รับจะถูกแบ่งออกอย่างเท่าเทียมกันระหว่างแบบจำลองหลาย ๆ ตัวอย่างเช่นถ้าคุณกำลังใช้ MirroredStrategy มี 2 GPUs ชุดขนาด 10 แต่ละคนจะได้รับการแบ่งออกเป็น 2 GPUs กับแต่ละที่ได้รับ 5 ตัวอย่างการป้อนข้อมูลในแต่ละขั้นตอน แต่ละยุคจะฝึกเร็วขึ้นเมื่อคุณเพิ่ม GPU มากขึ้น โดยปกติ คุณจะต้องเพิ่มขนาดแบทช์ของคุณเมื่อคุณเพิ่มตัวเร่งความเร็ว เพื่อที่จะใช้ประโยชน์จากพลังการประมวลผลพิเศษอย่างมีประสิทธิภาพ คุณจะต้องปรับอัตราการเรียนรู้ของคุณใหม่ ขึ้นอยู่กับรุ่น คุณสามารถใช้ strategy.num_replicas_in_sync จะได้รับหมายเลขของแบบจำลอง

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

ตอนนี้รองรับอะไรบ้าง?

การฝึกอบรม API MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy ParameterServerStrategy CentralStorageStrategy
Keras APIs ได้รับการสนับสนุน ได้รับการสนับสนุน การสนับสนุนการทดลอง การสนับสนุนการทดลอง การสนับสนุนการทดลอง

ตัวอย่างและแบบฝึกหัด

ต่อไปนี้คือรายการของบทช่วยสอนและตัวอย่างที่แสดงการผสานรวมแบบ end-to-end กับ Keras ข้างต้น:

  1. กวดวิชา ในการฝึกอบรม MNIST กับ MirroredStrategy
  2. สอน การฝึกอบรมการใช้ MNIST MultiWorkerMirroredStrategy
  3. ให้คำแนะนำ ในการฝึกอบรมการใช้ MNIST TPUStrategy
  4. กวดวิชา สำหรับการฝึกอบรมเซิร์ฟเวอร์พารามิเตอร์ใน TensorFlow 2 ParameterServerStrategy
  5. TensorFlow รุ่นสวน พื้นที่เก็บข้อมูล ที่มีคอลเลกชันของแบบจำลองรัฐของศิลปะดำเนินการโดยใช้กลยุทธ์ต่างๆ

ใช้ tf.distribute.Strategy กับลูปการฝึกอบรมที่กำหนดเอง

ในขณะที่คุณเคยเห็นใช้ tf.distribute.Strategy กับ Keras model.fit ต้องเปลี่ยนเพียงเส้นคู่ของรหัสของคุณ ด้วยความพยายามที่น้อยมากนอกจากนี้คุณยังสามารถใช้ tf.distribute.Strategy กับลูปการฝึกอบรมที่กำหนดเอง

หากคุณต้องการความยืดหยุ่นและการควบคุมลูปการฝึกมากกว่าที่จะเป็นไปได้ด้วย Estimator หรือ Keras คุณสามารถเขียนลูปการฝึกแบบกำหนดเองได้ ตัวอย่างเช่น เมื่อใช้ GAN คุณอาจต้องการใช้ขั้นตอนการสร้างหรือการเลือกปฏิบัติที่แตกต่างกันในแต่ละรอบ กรอบงานระดับสูงไม่เหมาะสำหรับการฝึกอบรมการเรียนรู้การเสริมแรง

tf.distribute.Strategy เรียนให้ชุดหลักของวิธีการผ่านไปยังการสนับสนุนการฝึกอบรมลูปที่กำหนดเอง การใช้สิ่งเหล่านี้อาจต้องมีการปรับโครงสร้างโค้ดเล็กน้อยในขั้นต้น แต่เมื่อเสร็จแล้ว คุณจะสามารถสลับไปมาระหว่าง GPU, TPU และหลายเครื่องได้ง่ายๆ โดยเปลี่ยนอินสแตนซ์กลยุทธ์

ที่นี่ คุณจะเห็นตัวอย่างสั้นๆ ที่แสดงกรณีการใช้งานนี้สำหรับตัวอย่างการฝึกง่ายๆ โดยใช้โมเดล Keras เดียวกันกับเมื่อก่อน

ขั้นแรก สร้างโมเดลและเครื่องมือเพิ่มประสิทธิภาพภายในขอบเขตของกลยุทธ์ เพื่อให้แน่ใจว่าตัวแปรใดๆ ที่สร้างด้วยโมเดลและตัวเพิ่มประสิทธิภาพเป็นตัวแปรที่มิเรอร์

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

ถัดไปสร้างชุดข้อมูลที่เข้าและโทร tf.distribute.Strategy.experimental_distribute_dataset เพื่อแจกจ่ายชุดข้อมูลที่อยู่บนพื้นฐานของกลยุทธ์ที่

dataset = tf.data.Dataset.from_tensors(([1.], [1.])).repeat(100).batch(
    global_batch_size)
dist_dataset = mirrored_strategy.experimental_distribute_dataset(dataset)
2021-07-14 01:23:27.005233: 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
        }
      }
    }
  }
}

จากนั้นให้กำหนดขั้นตอนหนึ่งของการฝึก ใช้ tf.GradientTape การไล่ระดับสีและเพิ่มประสิทธิภาพการประมวลผลเพื่อนำไปใช้การไล่ระดับสีเหล่านั้นเพื่อปรับปรุงตัวแปรรูปแบบของคุณ หากต้องการเผยแพร่ขั้นตอนการฝึกอบรมนี้ใส่ไว้ในฟังก์ชั่น train_step และผ่านมันไป tf.distrbute.Strategy.run พร้อมกับปัจจัยการผลิตชุดข้อมูลที่คุณได้รับจาก dist_dataset สร้างขึ้นก่อน:

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)

สิ่งอื่น ๆ ที่ควรทราบในรหัสด้านบน:

  1. คุณใช้ tf.nn.compute_average_loss การคำนวณการสูญเสีย tf.nn.compute_average_loss สรุปต่อตัวอย่างเช่นการสูญเสียและแบ่งผลรวมโดย global_batch_size นี้เป็นสิ่งสำคัญเพราะต่อมาหลังจากการไล่ระดับสีที่มีการคำนวณในแต่ละแบบจำลองที่พวกเขาจะรวบรวมจากแบบจำลองจากข้อสรุปพวกเขา
  2. นอกจากนี้คุณยังใช้ tf.distribute.Strategy.reduce API เพื่อรวบรวมผลการส่งกลับโดย tf.distribute.Strategy.run tf.distribute.Strategy.run ส่งกลับผลลัพธ์จากแต่ละท้องถิ่นแบบจำลองในกลยุทธ์และมีหลายวิธีที่จะบริโภคผลนี้ คุณสามารถ reduce พวกเขาจะได้รับความคุ้มค่ารวม นอกจากนี้คุณยังสามารถทำ tf.distribute.Strategy.experimental_local_results ที่จะได้รับรายการของค่าที่มีอยู่ในผลต่อหนึ่งแบบจำลองท้องถิ่น
  3. เมื่อคุณเรียก apply_gradients ภายในขอบเขตกลยุทธ์การกระจายพฤติกรรมของมันมีการแก้ไข โดยเฉพาะอย่างยิ่ง ก่อนที่จะใช้การไล่ระดับสีกับอินสแตนซ์คู่ขนานแต่ละรายการระหว่างการฝึกแบบซิงโครนัส

สุดท้ายเมื่อคุณได้กำหนดขั้นตอนการฝึกอบรมที่คุณสามารถย้ำกว่า dist_dataset และเรียกใช้การฝึกอบรมในวงนี้:

for dist_inputs in dist_dataset:
  print(distributed_train_step(dist_inputs))
tf.Tensor(0.36346385, shape=(), dtype=float32)
tf.Tensor(0.3616105, shape=(), dtype=float32)
tf.Tensor(0.3597728, shape=(), dtype=float32)
tf.Tensor(0.35795057, shape=(), dtype=float32)
tf.Tensor(0.35614368, shape=(), dtype=float32)
tf.Tensor(0.35435185, shape=(), dtype=float32)
tf.Tensor(0.3525751, shape=(), dtype=float32)
tf.Tensor(0.35081312, shape=(), dtype=float32)
tf.Tensor(0.3490658, shape=(), dtype=float32)
tf.Tensor(0.34733298, shape=(), dtype=float32)
tf.Tensor(0.34561458, shape=(), dtype=float32)
tf.Tensor(0.3439103, shape=(), dtype=float32)
tf.Tensor(0.3422201, shape=(), dtype=float32)
tf.Tensor(0.34054378, shape=(), dtype=float32)
tf.Tensor(0.33888122, shape=(), dtype=float32)
tf.Tensor(0.33723223, shape=(), dtype=float32)
tf.Tensor(0.3355967, shape=(), dtype=float32)
tf.Tensor(0.3339745, shape=(), dtype=float32)
tf.Tensor(0.33236548, shape=(), dtype=float32)
tf.Tensor(0.33076945, shape=(), dtype=float32)

ในตัวอย่างข้างต้นคุณซ้ำมากกว่า dist_dataset เพื่อให้เข้ากับการฝึกอบรมของคุณ คุณยังมีให้กับ tf.distribute.Strategy.make_experimental_numpy_dataset ให้การสนับสนุนปัจจัยการผลิต NumPy คุณสามารถใช้ API นี้เพื่อสร้างชุดข้อมูลก่อนที่จะเรียก tf.distribute.Strategy.experimental_distribute_dataset

อีกวิธีหนึ่งในการวนซ้ำข้อมูลของคุณคือการใช้ตัววนซ้ำอย่างชัดเจน คุณอาจต้องการทำเช่นนี้เมื่อคุณต้องการเรียกใช้ตามจำนวนขั้นตอนที่กำหนด ซึ่งต่างจากการวนซ้ำชุดข้อมูลทั้งหมด ดังกล่าวข้างต้นย้ำตอนนี้จะได้รับการแก้ไขไปก่อนสร้าง iterator แล้วชัดเจนโทร next มันจะได้รับการป้อนข้อมูล

iterator = iter(dist_dataset)
for _ in range(10):
  print(distributed_train_step(next(iterator)))
tf.Tensor(0.3291864, shape=(), dtype=float32)
tf.Tensor(0.32761604, shape=(), dtype=float32)
tf.Tensor(0.32605836, shape=(), dtype=float32)
tf.Tensor(0.3245131, shape=(), dtype=float32)
tf.Tensor(0.32298028, shape=(), dtype=float32)
tf.Tensor(0.32145968, shape=(), dtype=float32)
tf.Tensor(0.3199512, shape=(), dtype=float32)
tf.Tensor(0.31845465, shape=(), dtype=float32)
tf.Tensor(0.31697, shape=(), dtype=float32)
tf.Tensor(0.31549713, shape=(), dtype=float32)

ปกนี้กรณีที่ง่ายของการใช้ tf.distribute.Strategy API เพื่อแจกจ่ายลูปการฝึกอบรมที่กำหนดเอง

ตอนนี้รองรับอะไรบ้าง?

การฝึกอบรม API MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy ParameterServerStrategy CentralStorageStrategy
Custom Training Loop ได้รับการสนับสนุน ได้รับการสนับสนุน การสนับสนุนการทดลอง การสนับสนุนการทดลอง การสนับสนุนการทดลอง

ตัวอย่างและแบบฝึกหัด

ต่อไปนี้คือตัวอย่างบางส่วนสำหรับการใช้กลยุทธ์การแจกจ่ายกับลูปการฝึกแบบกำหนดเอง:

  1. สอน การฝึกอบรมการใช้ MNIST MirroredStrategy
  2. ให้คำแนะนำ ในการฝึกอบรมการใช้ MNIST TPUStrategy
  3. TensorFlow รุ่นสวน พื้นที่เก็บข้อมูล ที่มีคอลเลกชันของแบบจำลองรัฐของศิลปะดำเนินการโดยใช้กลยุทธ์ต่างๆ

หัวข้ออื่นๆ

ส่วนนี้ครอบคลุมบางหัวข้อที่เกี่ยวข้องกับกรณีการใช้งานหลายกรณี

การตั้งค่าตัวแปรสภาพแวดล้อม TF_CONFIG

สำหรับการฝึกอบรมหลายงานดังกล่าวก่อนที่คุณจะต้องตั้งค่า TF_CONFIG ตัวแปรสภาพแวดล้อมในการทำงานสำหรับแต่ละไบนารีในคลัสเตอร์ของคุณ TF_CONFIG ตัวแปรสภาพแวดล้อมเป็นสตริง JSON ซึ่งระบุสิ่งที่งานประกอบขึ้นเป็นกลุ่มอยู่ของพวกเขาและบทบาทของงานแต่ละงานในคลัสเตอร์ tensorflow/ecosystem repo ให้แม่แบบ Kubernetes ซึ่งชุดขึ้น TF_CONFIG สำหรับงานฝึกอบรมของคุณ

มีสององค์ประกอบของการมี TF_CONFIG คลัสเตอร์และงาน:

  • คลัสเตอร์ให้ข้อมูลเกี่ยวกับคลัสเตอร์การฝึกอบรม ซึ่งเป็น dict ที่ประกอบด้วยงานประเภทต่างๆ เช่น ผู้ปฏิบัติงาน ในการฝึกอบรมผู้ปฏิบัติงานหลายคน มักจะมีพนักงานคนหนึ่งที่รับผิดชอบมากกว่าเล็กน้อย เช่น การบันทึกจุดตรวจและการเขียนไฟล์สรุปสำหรับ TensorBoard นอกเหนือจากสิ่งที่พนักงานทั่วไปทำ คนงานดังกล่าวจะเรียกว่าเป็น "หัวหน้า" คนงานและมันเป็นธรรมเนียมที่ปฏิบัติงานที่มีค่าดัชนี 0 ได้รับการแต่งตั้งเป็นหัวหน้าคนงาน (ในความเป็นจริงนี้เป็นวิธีที่ tf.distribute.Strategy จะดำเนินการ)
  • งานในทางกลับกันให้ข้อมูลของงานปัจจุบัน คลัสเตอร์องค์ประกอบแรกจะเหมือนกันสำหรับผู้ปฏิบัติงานทั้งหมด และงานองค์ประกอบที่สองจะแตกต่างกันไปในแต่ละผู้ปฏิบัติงาน และระบุประเภทและดัชนีของผู้ปฏิบัติงานนั้น

ตัวอย่างหนึ่งของ TF_CONFIG คือ:

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 ระบุว่ามีสามคนและสอง "ps" งานใน "cluster" พร้อมกับครอบครัวและพอร์ตของพวกเขา "task" ส่วนหนึ่งระบุว่าบทบาทของงานปัจจุบันใน "cluster" -worker 1 (คนงานสอง) บทบาทที่ถูกต้องในคลัสเตอร์เป็น "chief" , "worker" , "ps" และ "evaluator" ไม่ควรมี "ps" งานยกเว้นเมื่อใช้ tf.distribute.experimental.ParameterServerStrategy

อะไรต่อไป?

tf.distribute.Strategy แข็งขันภายใต้การพัฒนา พยายามที่จะออกและให้การและข้อเสนอแนะของคุณโดยใช้ ปัญหา GitHub