หน้านี้ได้รับการแปลโดย Cloud Translation API

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

ดูบน TensorFlow.org

ทำงานใน Google Colab

ดูแหล่งที่มาบน GitHub

ดาวน์โหลดโน๊ตบุ๊ค

ภาพรวม

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

tf.distribute.Strategy ได้รับการออกแบบโดยคำนึงถึงเป้าหมายหลักเหล่านี้:

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

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

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

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

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

ตั้งค่า TensorFlow

import tensorflow as tf

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

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

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

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

การฝึกอบรม API	`MirroredStrategy`	`TPUStrategy`	`MultiWorkerMirroredStrategy`	`CentralStorageStrategy`	`ParameterServerStrategy`
Keras `Model.fit`	ได้รับการสนับสนุน	ได้รับการสนับสนุน	ได้รับการสนับสนุน	การสนับสนุนการทดลอง	การสนับสนุนการทดลอง
วงการฝึกแบบกำหนดเอง	ได้รับการสนับสนุน	ได้รับการสนับสนุน	ได้รับการสนับสนุน	การสนับสนุนการทดลอง	การสนับสนุนการทดลอง
เครื่องมือประมาณการ API	การสนับสนุนที่จำกัด	ไม่รองรับ	การสนับสนุนที่จำกัด	การสนับสนุนที่จำกัด	การสนับสนุนที่จำกัด

คำเตือน: การสนับสนุนเครื่องมือประมาณการถูกจำกัด การฝึกอบรมและการประเมินขั้นพื้นฐานเป็นการทดลอง และคุณลักษณะขั้นสูง เช่น โครงนั่งร้าน จะไม่ถูกนำมาใช้ คุณควรใช้ Keras หรือลูปการฝึกแบบกำหนดเองหากไม่ครอบคลุมกรณีการใช้งาน ไม่แนะนำให้ใช้ตัวประมาณค่าสำหรับรหัสใหม่ เครื่องมือประมาณค่าเรียกใช้ v1.Session ซึ่งยากต่อการเขียนอย่างถูกต้อง และสามารถทำงานโดยไม่คาดคิด โดยเฉพาะอย่างยิ่งเมื่อรวมกับโค้ด TF 2 เครื่องมือประมาณการอยู่ภายใต้ การรับประกันความเข้ากันได้ ของเรา แต่จะไม่ได้รับการแก้ไขใด ๆ นอกจากช่องโหว่ด้านความปลอดภัย ไปที่ คู่มือการโยกย้าย สำหรับรายละเอียด

MirroredStrategy

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

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

นี่เป็นวิธีที่ง่ายที่สุดในการสร้าง MirroredStrategy :

mirrored_strategy = tf.distribute.MirroredStrategy()

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

ซึ่งจะสร้างอินสแตนซ์ MirroredStrategy ซึ่งจะใช้ GPU ทั้งหมดที่ 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:1,/job:localhost/replica:0/task:0/device:GPU:0
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1')

หากคุณต้องการแทนที่การสื่อสารข้ามอุปกรณ์ คุณสามารถทำได้โดยใช้อาร์กิวเมนต์ 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())

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

TPUStrategy

tf.distribute.TPUStrategy ช่วยให้คุณดำเนินการฝึกอบรม TensorFlow เกี่ยวกับ หน่วยประมวลผลเทนเซอร์ (TPU) TPU คือ ASIC เฉพาะของ Google ที่ออกแบบมาเพื่อเร่งปริมาณงานของแมชชีนเลิร์นนิงอย่างมาก มีอยู่ใน Google Colab , TPU Research Cloud และ Cloud TPU

ในแง่ของสถาปัตยกรรมการฝึกอบรมแบบกระจาย TPUStrategy เป็น MirroredStrategy เดียวกัน — ใช้การฝึกอบรมแบบซิงโครนัสแบบกระจาย TPU มีการนำการดำเนินการลดทั้งหมดและการทำงานร่วมกันอื่นๆ อย่างมีประสิทธิภาพไปใช้ในคอร์ของ 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 ช่วยระบุตำแหน่ง TPU ใน 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 และรองรับทั้ง CPU และ GPU CommunicationImplementation.NCCL ใช้ NCCL และให้ประสิทธิภาพที่ล้ำสมัยบน GPU แต่ไม่รองรับ CPU 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 ของเอกสารนี้

สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับ MultiWorkerMirroredStrategy ให้พิจารณาบทช่วยสอนต่อไปนี้:

ParameterServerStrategy

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

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

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

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

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

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ ParameterServerStrategy โปรดดูการ ฝึกอบรมเซิร์ฟเวอร์พารามิเตอร์ด้วย Keras Model.fit และบทแนะนำการฝึกวนซ้ำแบบกำหนดเอง

ใน TensorFlow 1 ParameterServerStrategy ใช้งานได้กับ Estimator ผ่านสัญลักษณ์ 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 ซึ่งจะใช้ GPU และ CPU ที่มองเห็นได้ทั้งหมด การอัปเดตตัวแปรบนแบบจำลองจะถูกรวมก่อนที่จะนำไปใช้กับตัวแปร

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

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

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

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

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

default_strategy = tf.distribute.get_strategy()

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

อนุญาตให้เขียนโค้ดไลบรารีที่รับรู้การแจกจ่ายโดยไม่มีเงื่อนไข ตัวอย่างเช่น ใน tf.optimizer คุณสามารถใช้ tf.distribute.get_strategy และใช้กลยุทธ์นั้นเพื่อลดการไล่ระดับสี ซึ่งจะส่งคืนอ็อบเจ็กต์กลยุทธ์ซึ่งคุณสามารถเรียกใช้ Strategy.reduce 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.))

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 กับ Keras Model.fit

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

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

สร้างอินสแตนซ์ของ tf.distribute.Strategy ที่เหมาะสม
ย้ายการสร้างโมเดล Keras เครื่องมือเพิ่มประสิทธิภาพและเมตริกภายใน strategy.scope

กลยุทธ์การกระจาย TensorFlow รองรับโมเดล Keras ทุกประเภท— Sequential , Functional และ subclassed

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

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

ตัวยึดตำแหน่ง23

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

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

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

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

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

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

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

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

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

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

บทช่วย สอน : การฝึกด้วย Model.fit และ MirroredStrategy
บทช่วย สอน : การฝึกด้วย Model.fit และ MultiWorkerMirroredStrategy
คำแนะนำ : มีตัวอย่างการใช้ Model.fit และ TPUStrategy
บทช่วย สอน : การฝึกเซิร์ฟเวอร์พารามิเตอร์ด้วย Model.fit และ ParameterServerStrategy
บทช่วย สอน : การปรับ BERT อย่างละเอียดสำหรับงานต่างๆ จากเกณฑ์มาตรฐาน GLUE ด้วย Model.fit และ TPUStrategy
พื้นที่เก็บข้อมูล TensorFlow Model Garden ที่มีคอลเล็กชันของแบบจำลองล้ำสมัยที่นำไปใช้โดยใช้กลยุทธ์ต่างๆ

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

จากนั้นให้กำหนดขั้นตอนหนึ่งของการฝึก ใช้ tf.GradientTape เพื่อคำนวณการไล่ระดับสีและเครื่องมือเพิ่มประสิทธิภาพเพื่อใช้การไล่ระดับสีเหล่านั้นเพื่ออัปเดตตัวแปรของโมเดลของคุณ หากต้องการแจกจ่ายขั้นตอนการฝึกนี้ ให้ใส่ในฟังก์ชัน train_step แล้วส่งต่อไปยัง tf.distribute.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)

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

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

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

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

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

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

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

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

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

ตัวยึดตำแหน่ง36

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

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

การฝึกอบรม API	`MirroredStrategy`	`TPUStrategy`	`MultiWorkerMirroredStrategy`	`ParameterServerStrategy`	`CentralStorageStrategy`
วงการฝึกแบบกำหนดเอง	ได้รับการสนับสนุน	ได้รับการสนับสนุน	ได้รับการสนับสนุน	การสนับสนุนการทดลอง	การสนับสนุนการทดลอง

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

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

บทช่วย สอน : การฝึกด้วยลูปการฝึกแบบกำหนดเองและ MirroredStrategy
บทช่วย สอน : การฝึกด้วยลูปการฝึกแบบกำหนดเองและ MultiWorkerMirroredStrategy
คำแนะนำ : ประกอบด้วยตัวอย่างการวนรอบการฝึกแบบกำหนดเองด้วย TPUStrategy
บทช่วย สอน : การฝึกเซิร์ฟเวอร์พารามิเตอร์พร้อมลูปการฝึกที่กำหนดเองและ ParameterServerStrategy
พื้นที่เก็บข้อมูล TensorFlow Model Garden ที่มีคอลเล็กชันของแบบจำลองล้ำสมัยที่นำไปใช้โดยใช้กลยุทธ์ต่างๆ

หัวข้ออื่นๆ

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

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

สำหรับการฝึกอบรมผู้ปฏิบัติงานหลายคน ดังที่ได้กล่าวไว้ก่อนหน้านี้ คุณต้องตั้งค่าตัวแปรสภาพแวดล้อม 'TF_CONFIG' สำหรับไบนารีแต่ละตัวที่ทำงานในคลัสเตอร์ของคุณ ตัวแปรสภาพแวดล้อม 'TF_CONFIG' คือสตริง JSON ซึ่งระบุว่างานใดเป็นคลัสเตอร์ ที่อยู่ และบทบาทของแต่ละงานในคลัสเตอร์ tensorflow/ecosystem มีเทมเพลต 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" —ผู้ปฏิบัติงาน 1 (ผู้ปฏิบัติงานคนที่สอง) บทบาทที่ถูกต้องในคลัสเตอร์คือ "chief" , "worker" , "ps" และ "evaluator" ไม่ควรมีงาน "ps" ยกเว้นเมื่อใช้ tf.distribute.experimental.ParameterServerStrategy

อะไรต่อไป?

tf.distribute.Strategy อยู่ระหว่างการพัฒนา ลองใช้และให้ข้อเสนอแนะของคุณโดยใช้ ปัญหา GitHub