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

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

ภาพรวม

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

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

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

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

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

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

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

ตั้งค่า TensorFlow

import tensorflow as tf

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

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

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

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

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

MirroredStrategy

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

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

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

mirrored_strategy = tf.distribute.MirroredStrategy()
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: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 ของคุณบน 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 ของเอกสารนี้

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

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)

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

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

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

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

กลยุทธ์การกระจาย TensorFlow สนับสนุนทุกประเภทของ Keras models- Sequential , ฟังก์ชั่น และ 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',).

ตัวอย่างนี้ใช้ 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)
2021-09-22 20:33:41.551842: 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
        }
      }
    }
  }
}
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',).
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.4687
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: 1.0912
2021-09-22 20:33:44.537154: 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.6776
0.6776412129402161

นี่เป็น 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-09-22 20:33:45.820303: 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.4823
Epoch 2/2
10/10 [==============================] - 0s 2ms/step - loss: 0.2132
<keras.callbacks.History at 0x7f12645690d0>

ในทั้งสองกรณีที่มี Dataset หรือ NumPy แต่ละชุดของการป้อนข้อมูลที่ได้รับจะถูกแบ่งออกอย่างเท่าเทียมกันระหว่างแบบจำลองหลาย ๆ ตัวอย่างเช่นถ้าคุณกำลังใช้ MirroredStrategy มี 2 GPUs ชุดขนาด 10 แต่ละคนจะได้รับการแบ่งออกเป็น 2 GPUs กับแต่ละที่ได้รับ 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 :

  1. กวดวิชา : การฝึกอบรมกับ Model.fit และ MirroredStrategy
  2. กวดวิชา : การฝึกอบรมกับ Model.fit และ MultiWorkerMirroredStrategy
  3. คู่มือ : มีตัวอย่างของการใช้ Model.fit และ TPUStrategy
  4. กวดวิชา : การฝึกอบรมเซิร์ฟเวอร์พารามิเตอร์กับ Model.fit และ ParameterServerStrategy
  5. กวดวิชา : BERT ปรับจูนสำหรับงานจำนวนมากจากมาตรฐานกาวที่มี Model.fit และ TPUStrategy
  6. 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-09-22 20:33:47.092428: 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.29786447, shape=(), dtype=float32)
tf.Tensor(0.29653987, shape=(), dtype=float32)
tf.Tensor(0.29522538, shape=(), dtype=float32)
tf.Tensor(0.29392087, shape=(), dtype=float32)
tf.Tensor(0.29262626, shape=(), dtype=float32)
tf.Tensor(0.29134142, shape=(), dtype=float32)
tf.Tensor(0.29006627, shape=(), dtype=float32)
tf.Tensor(0.28880078, shape=(), dtype=float32)
tf.Tensor(0.2875447, shape=(), dtype=float32)
tf.Tensor(0.28629807, shape=(), dtype=float32)
tf.Tensor(0.28506076, shape=(), dtype=float32)
tf.Tensor(0.2838327, shape=(), dtype=float32)
tf.Tensor(0.28261372, shape=(), dtype=float32)
tf.Tensor(0.28140378, shape=(), dtype=float32)
tf.Tensor(0.28020284, shape=(), dtype=float32)
tf.Tensor(0.27901068, shape=(), dtype=float32)
tf.Tensor(0.27782732, shape=(), dtype=float32)
tf.Tensor(0.27665266, shape=(), dtype=float32)
tf.Tensor(0.2754866, shape=(), dtype=float32)
tf.Tensor(0.274329, 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.2731799, shape=(), dtype=float32)
tf.Tensor(0.27203918, shape=(), dtype=float32)
tf.Tensor(0.27090666, shape=(), dtype=float32)
tf.Tensor(0.26978233, shape=(), dtype=float32)
tf.Tensor(0.26866615, shape=(), dtype=float32)
tf.Tensor(0.26755798, shape=(), dtype=float32)
tf.Tensor(0.2664578, shape=(), dtype=float32)
tf.Tensor(0.26536545, shape=(), dtype=float32)
tf.Tensor(0.2642809, shape=(), dtype=float32)
tf.Tensor(0.26320407, shape=(), dtype=float32)

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

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

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

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

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

  1. กวดวิชา : การฝึกอบรมพร้อมห่วงการฝึกอบรมที่กำหนดเองและ MirroredStrategy
  2. กวดวิชา : การฝึกอบรมพร้อมห่วงการฝึกอบรมที่กำหนดเองและ MultiWorkerMirroredStrategy
  3. คู่มือ : มีตัวอย่างของห่วงการฝึกอบรมที่กำหนดเองที่มี TPUStrategy
  4. การสอน การฝึกอบรมเซิร์ฟเวอร์พารามิเตอร์พร้อมห่วงการฝึกอบรมที่กำหนดเองและ: ParameterServerStrategy
  5. 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